4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
23 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved.
25 * Copyright 2018, Joyent, Inc.
28 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
32 * Portions of this source code were derived from Berkeley 4.3 BSD
33 * under license from the Regents of the University of California.
37 #include <sys/param.h>
38 #include <sys/isa_defs.h>
39 #include <sys/types.h>
40 #include <sys/sysmacros.h>
41 #include <sys/systm.h>
42 #include <sys/errno.h>
43 #include <sys/fcntl.h>
44 #include <sys/flock.h>
45 #include <sys/vnode.h>
49 #include <sys/filio.h>
50 #include <sys/share.h>
51 #include <sys/debug.h>
53 #include <sys/nbmlock.h>
55 #include <sys/cmn_err.h>
57 static int flock_check(vnode_t
*, flock64_t
*, offset_t
, offset_t
);
58 static int flock_get_start(vnode_t
*, flock64_t
*, offset_t
, uoff_t
*);
59 static void fd_too_big(proc_t
*);
65 fcntl(int fdes
, int cmd
, intptr_t arg
)
81 struct flock64_32 bf64_32
;
84 struct shr_locowner shr_own
;
89 #if defined(_ILP32) && !defined(lint) && defined(_SYSCALL32)
90 ASSERT(sizeof (struct flock
) == sizeof (struct flock32
));
91 ASSERT(sizeof (struct flock64
) == sizeof (struct flock64_32
));
93 #if defined(_LP64) && !defined(lint) && defined(_SYSCALL32)
94 ASSERT(sizeof (struct flock
) == sizeof (struct flock64_64
));
95 ASSERT(sizeof (struct flock64
) == sizeof (struct flock64_64
));
99 * First, for speed, deal with the subset of cases
100 * that do not require getf() / releasef().
104 if ((error
= f_getfd_error(fdes
, &flag
)) == 0)
109 error
= f_setfd_error(fdes
, (int)arg
);
114 if ((error
= f_getfl(fdes
, &flag
)) == 0) {
115 retval
= OFLAGS(flag
) & (FCNTLFLAGS
| O_ASYNC
|
121 if ((error
= f_getfl(fdes
, &flag
)) == 0) {
122 retval
= OFLAGS(flag
);
127 if ((error
= f_badfd(fdes
, &fdres
, (int)arg
)) == 0)
133 * Second, for speed, deal with the subset of cases that
134 * require getf() / releasef() but do not require copyin.
136 if ((fp
= getf(fdes
)) == NULL
) {
144 case F_DUPFD_CLOEXEC
:
146 if ((uint_t
)iarg
>= p
->p_fno_ctl
) {
153 * We need to increment the f_count reference counter
154 * before allocating a new file descriptor.
155 * Doing it other way round opens a window for race condition
156 * with closeandsetf() on the target file descriptor which can
157 * close the file still referenced by the original
160 mutex_enter(&fp
->f_tlock
);
162 mutex_exit(&fp
->f_tlock
);
163 if ((retval
= ufalloc_file(iarg
, fp
)) == -1) {
165 * New file descriptor can't be allocated.
166 * Revert the reference count.
168 mutex_enter(&fp
->f_tlock
);
170 mutex_exit(&fp
->f_tlock
);
173 if (cmd
== F_DUPFD_CLOEXEC
) {
174 f_setfd(retval
, FD_CLOEXEC
);
179 case F_DUP2FD_CLOEXEC
:
191 } else if ((uint_t
)iarg
>= p
->p_fno_ctl
) {
197 * We can't hold our getf(fdes) across the call to
198 * closeandsetf() because it creates a window for
199 * deadlock: if one thread is doing dup2(a, b) while
200 * another is doing dup2(b, a), each one will block
201 * waiting for the other to call releasef(). The
202 * solution is to increment the file reference count
203 * (which we have to do anyway), then releasef(fdes),
204 * then closeandsetf(). Incrementing f_count ensures
205 * that fp won't disappear after we call releasef().
206 * When closeandsetf() fails, we try avoid calling
207 * closef() because of all the side effects.
209 mutex_enter(&fp
->f_tlock
);
211 mutex_exit(&fp
->f_tlock
);
213 if ((error
= closeandsetf(iarg
, fp
)) == 0) {
214 if (cmd
== F_DUP2FD_CLOEXEC
) {
215 f_setfd(iarg
, FD_CLOEXEC
);
219 mutex_enter(&fp
->f_tlock
);
220 if (fp
->f_count
> 1) {
222 mutex_exit(&fp
->f_tlock
);
224 mutex_exit(&fp
->f_tlock
);
236 if ((iarg
& (FNONBLOCK
|FNDELAY
)) == (FNONBLOCK
|FNDELAY
))
238 if ((error
= fop_setfl(vp
, flag
, iarg
, fp
->f_cred
, NULL
)) ==
241 mutex_enter(&fp
->f_tlock
);
242 fp
->f_flag
&= ~FCNTLFLAGS
;
244 mutex_exit(&fp
->f_tlock
);
251 * Finally, deal with the expensive cases.
255 maxoffset
= MAXOFF_T
;
256 datamodel
= DATAMODEL_NATIVE
;
257 #if defined(_SYSCALL32_IMPL)
258 if ((datamodel
= get_udatamodel()) == DATAMODEL_ILP32
)
259 maxoffset
= INT32_MAX
;
264 offset
= fp
->f_offset
;
268 * The file system and vnode layers understand and implement
269 * locking with flock64 structures. So here once we pass through
270 * the test for compatibility as defined by LFS API, (for F_SETLK,
271 * F_SETLKW, F_GETLK, F_GETLKW, F_OFD_GETLK, F_OFD_SETLK, F_OFD_SETLKW,
272 * F_FREESP) we transform the flock structure to a flock64 structure
273 * and send it to the lower layers. Similarly in case of GETLK and
274 * OFD_GETLK the returned flock64 structure is transformed to a flock
275 * structure if everything fits in nicely, otherwise we return
291 * Copy in input fields only.
294 if (cmd
== F_O_GETLK
) {
295 if (datamodel
!= DATAMODEL_ILP32
) {
300 if (copyin((void *)arg
, &obf
, sizeof (obf
))) {
304 bf
.l_type
= obf
.l_type
;
305 bf
.l_whence
= obf
.l_whence
;
306 bf
.l_start
= (off64_t
)obf
.l_start
;
307 bf
.l_len
= (off64_t
)obf
.l_len
;
308 bf
.l_sysid
= (int)obf
.l_sysid
;
309 bf
.l_pid
= obf
.l_pid
;
310 } else if (datamodel
== DATAMODEL_NATIVE
) {
311 if (copyin((void *)arg
, &sbf
, sizeof (sbf
))) {
316 * XXX In an LP64 kernel with an LP64 application
317 * there's no need to do a structure copy here
318 * struct flock == struct flock64. However,
319 * we did it this way to avoid more conditional
322 bf
.l_type
= sbf
.l_type
;
323 bf
.l_whence
= sbf
.l_whence
;
324 bf
.l_start
= (off64_t
)sbf
.l_start
;
325 bf
.l_len
= (off64_t
)sbf
.l_len
;
326 bf
.l_sysid
= sbf
.l_sysid
;
327 bf
.l_pid
= sbf
.l_pid
;
329 #if defined(_SYSCALL32_IMPL)
331 struct flock32 sbf32
;
332 if (copyin((void *)arg
, &sbf32
, sizeof (sbf32
))) {
336 bf
.l_type
= sbf32
.l_type
;
337 bf
.l_whence
= sbf32
.l_whence
;
338 bf
.l_start
= (off64_t
)sbf32
.l_start
;
339 bf
.l_len
= (off64_t
)sbf32
.l_len
;
340 bf
.l_sysid
= sbf32
.l_sysid
;
341 bf
.l_pid
= sbf32
.l_pid
;
343 #endif /* _SYSCALL32_IMPL */
346 * 64-bit support: check for overflow for 32-bit lock ops
348 if ((error
= flock_check(vp
, &bf
, offset
, maxoffset
)) != 0)
351 if (cmd
== F_FLOCK
|| cmd
== F_FLOCKW
) {
352 /* FLOCK* locking is always over the entire file. */
353 if (bf
.l_whence
!= 0 || bf
.l_start
!= 0 ||
358 if (bf
.l_type
< F_RDLCK
|| bf
.l_type
> F_UNLCK
) {
364 if (cmd
== F_OFD_GETLK
|| cmd
== F_OFD_SETLK
||
365 cmd
== F_OFD_SETLKW
) {
367 * TBD OFD-style locking is currently limited to
368 * covering the entire file.
370 if (bf
.l_whence
!= 0 || bf
.l_start
!= 0 ||
378 * Not all of the filesystems understand F_O_GETLK, and
379 * there's no need for them to know. Map it to F_GETLK.
381 * The *_frlock functions in the various file systems basically
382 * do some validation and then funnel everything through the
383 * fs_frlock function. For OFD-style locks fs_frlock will do
384 * nothing so that once control returns here we can call the
385 * ofdlock function with the correct fp. For OFD-style locks
386 * the unsupported remote file systems, such as NFS, detect and
387 * reject the OFD-style cmd argument.
389 if ((error
= fop_frlock(vp
, (cmd
== F_O_GETLK
) ? F_GETLK
: cmd
,
390 &bf
, flag
, offset
, NULL
, fp
->f_cred
, NULL
)) != 0)
393 if (cmd
== F_FLOCK
|| cmd
== F_FLOCKW
|| cmd
== F_OFD_GETLK
||
394 cmd
== F_OFD_SETLK
|| cmd
== F_OFD_SETLKW
) {
396 * This is an OFD-style lock so we need to handle it
397 * here. Because OFD-style locks are associated with
398 * the file_t we didn't have enough info down the
399 * fop_frlock path immediately above.
401 if ((error
= ofdlock(fp
, cmd
, &bf
, flag
, offset
)) != 0)
406 * If command is GETLK and no lock is found, only
407 * the type field is changed.
409 if ((cmd
== F_O_GETLK
|| cmd
== F_GETLK
||
410 cmd
== F_OFD_GETLK
) && bf
.l_type
== F_UNLCK
) {
411 /* l_type always first entry, always a short */
412 if (copyout(&bf
.l_type
, &((struct flock
*)arg
)->l_type
,
418 if (cmd
== F_O_GETLK
) {
420 * Return an SVR3 flock structure to the user.
422 obf
.l_type
= (int16_t)bf
.l_type
;
423 obf
.l_whence
= (int16_t)bf
.l_whence
;
424 obf
.l_start
= (int32_t)bf
.l_start
;
425 obf
.l_len
= (int32_t)bf
.l_len
;
426 if (bf
.l_sysid
> SHRT_MAX
|| bf
.l_pid
> SHRT_MAX
) {
428 * One or both values for the above fields
429 * is too large to store in an SVR3 flock
435 obf
.l_sysid
= (int16_t)bf
.l_sysid
;
436 obf
.l_pid
= (int16_t)bf
.l_pid
;
437 if (copyout(&obf
, (void *)arg
, sizeof (obf
)))
439 } else if (cmd
== F_GETLK
|| cmd
== F_OFD_GETLK
) {
441 * Copy out SVR4 flock.
445 if (bf
.l_start
> maxoffset
|| bf
.l_len
> maxoffset
) {
450 if (datamodel
== DATAMODEL_NATIVE
) {
451 for (i
= 0; i
< 4; i
++)
454 * XXX In an LP64 kernel with an LP64
455 * application there's no need to do a
456 * structure copy here as currently
457 * struct flock == struct flock64.
458 * We did it this way to avoid more
459 * conditional compilation.
461 sbf
.l_type
= bf
.l_type
;
462 sbf
.l_whence
= bf
.l_whence
;
463 sbf
.l_start
= (off_t
)bf
.l_start
;
464 sbf
.l_len
= (off_t
)bf
.l_len
;
465 sbf
.l_sysid
= bf
.l_sysid
;
466 sbf
.l_pid
= bf
.l_pid
;
467 if (copyout(&sbf
, (void *)arg
, sizeof (sbf
)))
470 #if defined(_SYSCALL32_IMPL)
472 struct flock32 sbf32
;
473 if (bf
.l_start
> INT32_MAX
||
474 bf
.l_len
> INT32_MAX
) {
478 for (i
= 0; i
< 4; i
++)
480 sbf32
.l_type
= (int16_t)bf
.l_type
;
481 sbf32
.l_whence
= (int16_t)bf
.l_whence
;
482 sbf32
.l_start
= (off_t
)bf
.l_start
;
483 sbf32
.l_len
= (off_t
)bf
.l_len
;
484 sbf32
.l_sysid
= (int32_t)bf
.l_sysid
;
485 sbf32
.l_pid
= (pid32_t
)bf
.l_pid
;
487 (void *)arg
, sizeof (sbf32
)))
496 * This is for internal use only, to allow the vnode layer
497 * to validate a flags setting before applying it. User
498 * programs can't issue it.
508 * Test for not-a-regular-file (and returning EINVAL)
509 * before testing for open-for-writing (and returning EBADF).
510 * This is relied upon by posix_fallocate() in libc.
512 if (vp
->v_type
!= VREG
) {
517 if ((flag
& FWRITE
) == 0) {
522 if (datamodel
!= DATAMODEL_ILP32
&&
523 (cmd
== F_ALLOCSP64
|| cmd
== F_FREESP64
)) {
528 #if defined(_ILP32) || defined(_SYSCALL32_IMPL)
529 if (datamodel
== DATAMODEL_ILP32
&&
530 (cmd
== F_ALLOCSP
|| cmd
== F_FREESP
)) {
531 struct flock32 sbf32
;
533 * For compatibility we overlay an SVR3 flock on an SVR4
534 * flock. This works because the input field offsets
535 * in "struct flock" were preserved.
537 if (copyin((void *)arg
, &sbf32
, sizeof (sbf32
))) {
541 bf
.l_type
= sbf32
.l_type
;
542 bf
.l_whence
= sbf32
.l_whence
;
543 bf
.l_start
= (off64_t
)sbf32
.l_start
;
544 bf
.l_len
= (off64_t
)sbf32
.l_len
;
545 bf
.l_sysid
= sbf32
.l_sysid
;
546 bf
.l_pid
= sbf32
.l_pid
;
549 #endif /* _ILP32 || _SYSCALL32_IMPL */
552 if (datamodel
== DATAMODEL_LP64
&&
553 (cmd
== F_ALLOCSP
|| cmd
== F_FREESP
)) {
554 if (copyin((void *)arg
, &bf
, sizeof (bf
))) {
559 #endif /* defined(_LP64) */
561 #if !defined(_LP64) || defined(_SYSCALL32_IMPL)
562 if (datamodel
== DATAMODEL_ILP32
&&
563 (cmd
== F_ALLOCSP64
|| cmd
== F_FREESP64
)) {
564 if (copyin((void *)arg
, &bf64_32
, sizeof (bf64_32
))) {
569 * Note that the size of flock64 is different in
570 * the ILP32 and LP64 models, due to the l_pad
571 * field. We do not want to assume that the
572 * flock64 structure is laid out the same in
573 * ILP32 and LP64 environments, so we will
574 * copy in the ILP32 version of flock64
575 * explicitly and copy it to the native
578 bf
.l_type
= (short)bf64_32
.l_type
;
579 bf
.l_whence
= (short)bf64_32
.l_whence
;
580 bf
.l_start
= bf64_32
.l_start
;
581 bf
.l_len
= bf64_32
.l_len
;
582 bf
.l_sysid
= (int)bf64_32
.l_sysid
;
583 bf
.l_pid
= (pid_t
)bf64_32
.l_pid
;
586 #endif /* !defined(_LP64) || defined(_SYSCALL32_IMPL) */
588 if (cmd
== F_ALLOCSP
|| cmd
== F_FREESP
)
589 error
= flock_check(vp
, &bf
, offset
, maxoffset
);
590 else if (cmd
== F_ALLOCSP64
|| cmd
== F_FREESP64
)
591 error
= flock_check(vp
, &bf
, offset
, MAXOFFSET_T
);
595 if (vp
->v_type
== VREG
&& bf
.l_len
== 0 &&
596 bf
.l_start
> OFFSET_MAX(fp
)) {
602 * Make sure that there are no conflicting non-blocking
603 * mandatory locks in the region being manipulated. If
604 * there are such locks then return EACCES.
606 if ((error
= flock_get_start(vp
, &bf
, offset
, &start
)) != 0)
609 if (nbl_need_check(vp
)) {
613 nbl_start_crit(vp
, RW_READER
);
615 vattr
.va_mask
= VATTR_SIZE
;
616 if ((error
= fop_getattr(vp
, &vattr
, 0, CRED(), NULL
))
619 begin
= start
> vattr
.va_size
? vattr
.va_size
: start
;
620 length
= vattr
.va_size
> start
? vattr
.va_size
- start
:
621 start
- vattr
.va_size
;
622 if (nbl_conflict(vp
, NBL_WRITE
, begin
, length
, 0,
629 if (cmd
== F_ALLOCSP64
)
631 else if (cmd
== F_FREESP64
)
634 error
= fop_space(vp
, cmd
, &bf
, flag
, offset
, fp
->f_cred
, NULL
);
638 #if !defined(_LP64) || defined(_SYSCALL32_IMPL)
642 case F_SETLK64_NBMAND
:
649 * Large Files: Here we set cmd as *LK and send it to
650 * lower layers. *LK64 is only for the user land.
651 * Most of the comments described above for F_SETLK
653 * Large File support is only needed for ILP32 apps!
655 if (datamodel
!= DATAMODEL_ILP32
) {
660 if (cmd
== F_GETLK64
)
662 else if (cmd
== F_SETLK64
)
664 else if (cmd
== F_SETLKW64
)
666 else if (cmd
== F_SETLK64_NBMAND
)
667 cmd
= F_SETLK_NBMAND
;
668 else if (cmd
== F_OFD_GETLK64
)
670 else if (cmd
== F_OFD_SETLK64
)
672 else if (cmd
== F_OFD_SETLKW64
)
674 else if (cmd
== F_FLOCK64
)
676 else if (cmd
== F_FLOCKW64
)
680 * Note that the size of flock64 is different in the ILP32
681 * and LP64 models, due to the sucking l_pad field.
682 * We do not want to assume that the flock64 structure is
683 * laid out in the same in ILP32 and LP64 environments, so
684 * we will copy in the ILP32 version of flock64 explicitly
685 * and copy it to the native flock64 structure.
688 if (copyin((void *)arg
, &bf64_32
, sizeof (bf64_32
))) {
693 bf
.l_type
= (short)bf64_32
.l_type
;
694 bf
.l_whence
= (short)bf64_32
.l_whence
;
695 bf
.l_start
= bf64_32
.l_start
;
696 bf
.l_len
= bf64_32
.l_len
;
697 bf
.l_sysid
= (int)bf64_32
.l_sysid
;
698 bf
.l_pid
= (pid_t
)bf64_32
.l_pid
;
700 if ((error
= flock_check(vp
, &bf
, offset
, MAXOFFSET_T
)) != 0)
703 if (cmd
== F_FLOCK
|| cmd
== F_FLOCKW
) {
704 /* FLOCK* locking is always over the entire file. */
705 if (bf
.l_whence
!= 0 || bf
.l_start
!= 0 ||
710 if (bf
.l_type
< F_RDLCK
|| bf
.l_type
> F_UNLCK
) {
716 if (cmd
== F_OFD_GETLK
|| cmd
== F_OFD_SETLK
||
717 cmd
== F_OFD_SETLKW
) {
719 * TBD OFD-style locking is currently limited to
720 * covering the entire file.
722 if (bf
.l_whence
!= 0 || bf
.l_start
!= 0 ||
730 * The *_frlock functions in the various file systems basically
731 * do some validation and then funnel everything through the
732 * fs_frlock function. For OFD-style locks fs_frlock will do
733 * nothing so that once control returns here we can call the
734 * ofdlock function with the correct fp. For OFD-style locks
735 * the unsupported remote file systems, such as NFS, detect and
736 * reject the OFD-style cmd argument.
738 if ((error
= fop_frlock(vp
, cmd
, &bf
, flag
, offset
,
739 NULL
, fp
->f_cred
, NULL
)) != 0)
742 if (cmd
== F_FLOCK
|| cmd
== F_FLOCKW
|| cmd
== F_OFD_GETLK
||
743 cmd
== F_OFD_SETLK
|| cmd
== F_OFD_SETLKW
) {
745 * This is an OFD-style lock so we need to handle it
746 * here. Because OFD-style locks are associated with
747 * the file_t we didn't have enough info down the
748 * fop_frlock path immediately above.
750 if ((error
= ofdlock(fp
, cmd
, &bf
, flag
, offset
)) != 0)
754 if ((cmd
== F_GETLK
|| cmd
== F_OFD_GETLK
) &&
755 bf
.l_type
== F_UNLCK
) {
756 if (copyout(&bf
.l_type
, &((struct flock
*)arg
)->l_type
,
762 if (cmd
== F_GETLK
|| cmd
== F_OFD_GETLK
) {
766 * We do not want to assume that the flock64 structure
767 * is laid out in the same in ILP32 and LP64
768 * environments, so we will copy out the ILP32 version
769 * of flock64 explicitly after copying the native
770 * flock64 structure to it.
772 for (i
= 0; i
< 4; i
++)
773 bf64_32
.l_pad
[i
] = 0;
774 bf64_32
.l_type
= (int16_t)bf
.l_type
;
775 bf64_32
.l_whence
= (int16_t)bf
.l_whence
;
776 bf64_32
.l_start
= bf
.l_start
;
777 bf64_32
.l_len
= bf
.l_len
;
778 bf64_32
.l_sysid
= (int32_t)bf
.l_sysid
;
779 bf64_32
.l_pid
= (pid32_t
)bf
.l_pid
;
780 if (copyout(&bf64_32
, (void *)arg
, sizeof (bf64_32
)))
784 #endif /* !defined(_LP64) || defined(_SYSCALL32_IMPL) */
791 * Copy in input fields only.
793 if (copyin((void *)arg
, &fsh
, sizeof (fsh
))) {
799 * Local share reservations always have this simple form
801 shr
.s_access
= fsh
.f_access
;
802 shr
.s_deny
= fsh
.f_deny
;
804 shr
.s_pid
= ttoproc(curthread
)->p_pid
;
805 shr_own
.sl_pid
= shr
.s_pid
;
806 shr_own
.sl_id
= fsh
.f_id
;
807 shr
.s_own_len
= sizeof (shr_own
);
808 shr
.s_owner
= (caddr_t
)&shr_own
;
809 error
= fop_shrlock(vp
, cmd
, &shr
, flag
, fp
->f_cred
, NULL
);
824 return (set_errno(error
));
829 flock_check(vnode_t
*vp
, flock64_t
*flp
, offset_t offset
, offset_t max
)
836 * Determine the starting point of the request
838 switch (flp
->l_whence
) {
839 case 0: /* SEEK_SET */
840 start
= (uoff_t
)flp
->l_start
;
844 case 1: /* SEEK_CUR */
845 if (flp
->l_start
> (max
- offset
))
847 start
= (uoff_t
)(flp
->l_start
+ offset
);
851 case 2: /* SEEK_END */
852 vattr
.va_mask
= VATTR_SIZE
;
853 if (error
= fop_getattr(vp
, &vattr
, 0, CRED(), NULL
))
855 if (flp
->l_start
> (max
- (offset_t
)vattr
.va_size
))
857 start
= (uoff_t
)(flp
->l_start
+ (offset_t
)vattr
.va_size
);
866 * Determine the range covered by the request.
870 else if ((offset_t
)flp
->l_len
> 0) {
871 if (flp
->l_len
> (max
- start
+ 1))
873 end
= (uoff_t
)(start
+ (flp
->l_len
- 1));
877 * Negative length; why do we even allow this ?
878 * Because this allows easy specification of
879 * the last n bytes of the file.
882 start
+= (uoff_t
)flp
->l_len
;
888 ASSERT(start
<= max
);
889 if (flp
->l_type
== F_UNLCK
&& flp
->l_len
> 0 &&
890 end
== (offset_t
)max
) {
899 flock_get_start(vnode_t
*vp
, flock64_t
*flp
, offset_t offset
, uoff_t
*start
)
905 * Determine the starting point of the request. Assume that it is
906 * a valid starting point.
908 switch (flp
->l_whence
) {
909 case 0: /* SEEK_SET */
910 *start
= (uoff_t
)flp
->l_start
;
912 case 1: /* SEEK_CUR */
913 *start
= (uoff_t
)(flp
->l_start
+ offset
);
915 case 2: /* SEEK_END */
916 vattr
.va_mask
= VATTR_SIZE
;
917 if (error
= fop_getattr(vp
, &vattr
, 0, CRED(), NULL
))
919 *start
= (uoff_t
)(flp
->l_start
+ (offset_t
)vattr
.va_size
);
929 * Take rctl action when the requested file descriptor is too big.
932 fd_too_big(proc_t
*p
)
934 mutex_enter(&p
->p_lock
);
935 (void) rctl_action(rctlproc_legacy
[RLIMIT_NOFILE
],
936 p
->p_rctls
, p
, RCA_SAFE
);
937 mutex_exit(&p
->p_lock
);