| blob | 81640bd6089145007fb0ee960be7860b67ecef40 |
1 /*
2 * CDDL HEADER START
3 *
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.
7 *
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.
12 *
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]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
23 *
24 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T.
25 * All rights reserved.
26 */
28 /*
29 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
30 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
31 */
33 #include <sys/param.h>
34 #include <sys/types.h>
35 #include <sys/systm.h>
36 #include <sys/cred.h>
37 #include <sys/time.h>
38 #include <sys/vnode.h>
39 #include <sys/vfs.h>
40 #include <sys/file.h>
41 #include <sys/filio.h>
42 #include <sys/uio.h>
43 #include <sys/buf.h>
44 #include <sys/mman.h>
45 #include <sys/pathname.h>
46 #include <sys/dirent.h>
47 #include <sys/debug.h>
48 #include <sys/vmsystm.h>
49 #include <sys/fcntl.h>
50 #include <sys/flock.h>
51 #include <sys/swap.h>
52 #include <sys/errno.h>
53 #include <sys/strsubr.h>
54 #include <sys/sysmacros.h>
55 #include <sys/kmem.h>
56 #include <sys/cmn_err.h>
57 #include <sys/pathconf.h>
58 #include <sys/utsname.h>
59 #include <sys/dnlc.h>
60 #include <sys/acl.h>
61 #include <sys/atomic.h>
62 #include <sys/policy.h>
63 #include <sys/sdt.h>
65 #include <rpc/types.h>
66 #include <rpc/auth.h>
67 #include <rpc/clnt.h>
69 #include <nfs/nfs.h>
70 #include <nfs/nfs_clnt.h>
71 #include <nfs/rnode.h>
72 #include <nfs/nfs_acl.h>
73 #include <nfs/lm.h>
75 #include <vm/hat.h>
76 #include <vm/as.h>
77 #include <vm/page.h>
78 #include <vm/pvn.h>
79 #include <vm/seg.h>
80 #include <vm/seg_map.h>
81 #include <vm/seg_kpm.h>
82 #include <vm/seg_vn.h>
84 #include <sys/fs_subr.h>
86 #include <sys/ddi.h>
89 cred_t *);
96 caller_context_t *);
103 cred_t *);
110 /*
111 * Error flags used to pass information about certain special errors
112 * which need to be handled specially.
113 */
114 #define NFS_EOF -98
116 /*
117 * These are the vnode ops routines which implement the vnode interface to
118 * the networked file system. These routines just take their parameters,
119 * make them look networkish by putting the right info into interface structs,
120 * and then calling the appropriate remote routine(s) to do the work.
121 *
122 * Note on directory name lookup cacheing: If we detect a stale fhandle,
123 * we purge the directory cache relative to that vnode. This way, the
124 * user won't get burned by the cache repeatedly. See <nfs/rnode.h> for
125 * more details on rnode locking.
126 */
130 caller_context_t *);
132 caller_context_t *);
134 caller_context_t *);
136 caller_context_t *);
138 caller_context_t *);
140 caller_context_t *);
144 caller_context_t *);
152 vsecattr_t *);
175 caller_context_t *);
188 caller_context_t *);
192 caller_context_t *);
194 caller_context_t *);
196 caller_context_t *);
239 };
241 /*
242 * XXX: This is referenced in modstubs.s
243 */
246 {
248 }
250 /* ARGSUSED */
251 static int
253 {
267 }
270 /*
271 * If there is no cached data or if close-to-open
272 * consistency checking is turned off, we can avoid
273 * the over the wire getattr. Otherwise, if the
274 * file system is mounted readonly, then just verify
275 * the caches are up to date using the normal mechanism.
276 * Else, if the file is not mmap'd, then just mark
277 * the attributes as timed out. They will be refreshed
278 * and the caches validated prior to being used.
279 * Else, the file system is mounted writeable so
280 * force an over the wire GETATTR in order to ensure
281 * that all cached data is valid.
282 */
294 }
299 }
301 /* ARGSUSED */
302 static int
305 {
310 /*
311 * zone_enter(2) prevents processes from changing zones with NFS files
312 * open; if we happen to get here from the wrong zone we can't do
313 * anything over the wire.
314 */
316 /*
317 * We could attempt to clean up locks, except we're sure
318 * that the current process didn't acquire any locks on
319 * the file: any attempt to lock a file belong to another zone
320 * will fail, and one can't lock an NFS file and then change
321 * zones, as that fails too.
322 *
323 * Returning an error here is the sane thing to do. A
324 * subsequent call to VN_RELE() which translates to a
325 * nfs_inactive() will clean up state: if the zone of the
326 * vnode's origin is still alive and kicking, an async worker
327 * thread will handle the request (from the correct zone), and
328 * everything (minus the final nfs_getattr_otw() call) should
329 * be OK. If the zone is going away nfs_async_inactive() will
330 * throw away cached pages inline.
331 */
333 }
335 /*
336 * If we are using local locking for this filesystem, then
337 * release all of the SYSV style record locks. Otherwise,
338 * we are doing network locking and we need to release all
339 * of the network locks. All of the locks held by this
340 * process on this file are released no matter what the
341 * incoming reference count is.
342 */
352 /*
353 * If the file has been `unlinked', then purge the
354 * DNLC so that this vnode will get reycled quicker
355 * and the .nfs* file on the server will get removed.
356 */
361 /*
362 * If the file was open for write and there are pages,
363 * then if the file system was mounted using the "no-close-
364 * to-open" semantics, then start an asynchronous flush
365 * of the all of the pages in the file.
366 * else the file system was not mounted using the "no-close-
367 * to-open" semantics, then do a synchronous flush and
368 * commit of all of the dirty and uncommitted pages.
369 *
370 * The asynchronous flush of the pages in the "nocto" path
371 * mostly just associates a cred pointer with the rnode so
372 * writes which happen later will have a better chance of
373 * working. It also starts the data being written to the
374 * server, but without unnecessarily delaying the application.
375 */
389 }
395 }
397 /*
398 * If RWRITEATTR is set, then issue an over the wire GETATTR to
399 * refresh the attribute cache with a set of attributes which
400 * weren't returned from a WRITE. This will enable the close-
401 * to-open processing to work.
402 */
407 }
409 /* ARGSUSED */
410 static int
413 {
415 uoff_t off;
416 offset_t diff;
419 caddr_t base;
420 uint_t flags;
445 /*
446 * Bypass VM if caching has been disabled (e.g., locking) or if
447 * using client-side direct I/O and the file is not mmap'd and
448 * there are no cached pages.
449 */
457 /*
458 * Let's try to do read in as large a chunk as we can
459 * (Filesystem (NFS client) bsize if possible/needed).
460 * For V3, this is 32K and for V2, this is 8K.
461 */
471 }
475 }
493 }
494 }
503 /*
504 * Copy data.
505 */
512 }
515 /*
516 * If read a whole block or read to eof,
517 * won't need this buffer again soon.
518 */
523 else
530 }
536 }
537 }
541 }
543 /* ARGSUSED */
544 static int
547 {
549 uoff_t off;
550 caddr_t base;
551 uint_t flags;
557 offset_t offset;
558 rlim_t limit;
575 /*
576 * Must serialize if appending.
577 */
583 }
590 }
604 }
606 /*
607 * Check to make sure that the process will not exceed
608 * its limit on file size. It is okay to write up to
609 * the limit, but not beyond. Thus, the write which
610 * reaches the limit will be short and the next write
611 * will return an error.
612 */
626 }
627 }
632 /*
633 * Bypass VM if caching has been disabled (e.g., locking) or if
634 * using client-side direct I/O and the file is not mmap'd and
635 * there are no cached pages.
636 */
643 uint_t org_offset;
645 nfs_fwrite:
650 /*
651 * A close may have cleared r_error, if so,
652 * propagate ESTALE error return properly
653 */
657 }
669 }
673 }
685 /*
686 * A close may have cleared r_error, if so,
687 * propagate ESTALE error return properly
688 */
692 }
694 /*
695 * Don't create dirty pages faster than they
696 * can be cleaned so that the system doesn't
697 * get imbalanced. If the async queue is
698 * maxed out, then wait for it to drain before
699 * creating more dirty pages. Also, wait for
700 * any threads doing pagewalks in the vop_getattr
701 * entry points so that they don't block for
702 * long periods.
703 */
719 }
724 }
727 /*
728 * Touch the page and fault it in if it is not in core
729 * before segmap_getmapflt or vpm_data_copy can lock it.
730 * This is to avoid the deadlock if the buffer is mapped
731 * to the same file through mmap which we want to write.
732 */
736 /*
737 * It will use kpm mappings, so no need to
738 * pass an address.
739 */
757 pagecreate);
763 }
764 }
770 /*
771 * Have written a whole block.
772 * Start an asynchronous write
773 * and mark the buffer to
774 * indicate that it won't be
775 * needed again soon.
776 */
784 }
789 }
795 }
796 /*
797 * In the event that we got an access error while
798 * faulting in a page for a write-only file just
799 * force a write.
800 */
803 }
806 bottom:
816 }
818 /*
819 * Flags are composed of {B_ASYNC, B_INVAL, B_FREE, B_DONTNEED}
820 */
821 static int
824 {
832 /*
833 * pageio_setup should have set b_addr to 0. This
834 * is correct since we want to do I/O on a page
835 * boundary. bp_mapin will use this addr to calculate
836 * an offset, and then set b_addr to the kernel virtual
837 * address it allocated for us.
838 */
854 }
856 /*
857 * Write to file. Writes to remote server in largest size
858 * chunks that the server can handle. Write is synchronous.
859 */
860 static int
862 {
893 }
905 }
909 /*
910 * Can't check for stale fhandle and purge caches
911 * here because pages are held by nfs_getpage.
912 * Just mark the attribute cache as timed out
913 * and set RWRITEATTR to indicate that the file
914 * was modified with a WRITE operation.
915 */
923 writes++;
927 }
933 }
934 }
938 }
940 /*
941 * Read from a file. Reads data in largest chunks our interface can handle.
942 */
943 static int
946 {
953 failinfo_t fi;
956 hrtime_t t;
978 }
998 }
1012 }
1014 }
1015 }
1021 /*
1022 * Since no error occurred, we have the current
1023 * attributes and we need to do a cache check and then
1024 * potentially update the cached attributes. We can't
1025 * use the normal attribute check and cache mechanisms
1026 * because they might cause a cache flush which would
1027 * deadlock. Instead, we just check the cache to see
1028 * if the attributes have changed. If it is, then we
1029 * just mark the attributes as out of date. The next
1030 * time that the attributes are checked, they will be
1031 * out of date, new attributes will be fetched, and
1032 * the page cache will be flushed. If the attributes
1033 * weren't changed, then we just update the cached
1034 * attributes with these attributes.
1035 */
1036 /*
1037 * If NFS_ACL is supported on the server, then the
1038 * attributes returned by server may have minimal
1039 * permissions sometimes denying access to users having
1040 * proper access. To get the proper attributes, mark
1041 * the attributes as expired so that they will be
1042 * regotten via the NFS_ACL GETATTR2 procedure.
1043 */
1053 }
1055 }
1056 }
1059 }
1061 /* ARGSUSED */
1062 static int
1065 {
1074 }
1075 }
1077 /* ARGSUSED */
1078 static int
1081 {
1087 /*
1088 * If it has been specified that the return value will
1089 * just be used as a hint, and we are only being asked
1090 * for size, fsid or rdevid, then return the client's
1091 * notion of these values without checking to make sure
1092 * that the attribute cache is up to date.
1093 * The whole point is to avoid an over the wire GETATTR
1094 * call.
1095 */
1108 }
1110 /*
1111 * Only need to flush pages if asking for the mtime
1112 * and if there any dirty pages or any outstanding
1113 * asynchronous (write) requests for this file.
1114 */
1126 }
1130 }
1131 }
1134 }
1136 /*ARGSUSED4*/
1137 static int
1140 {
1142 uint_t mask;
1165 vp);
1176 }
1178 static int
1180 {
1182 uint_t mask;
1188 mode_t omode;
1191 hrtime_t t;
1199 /*
1200 * Only need to flush pages if there are any pages and
1201 * if the file is marked as dirty in some fashion. The
1202 * file must be flushed so that we can accurately
1203 * determine the size of the file and the cached data
1204 * after the SETATTR returns. A file is considered to
1205 * be dirty if it is either marked with RDIRTY, has
1206 * outstanding i/o's active, or is mmap'd. In this
1207 * last case, we can't tell whether there are dirty
1208 * pages, so we flush just to be sure.
1209 */
1221 }
1222 }
1224 /*
1225 * If the system call was utime(2) or utimes(2) and the
1226 * application did not specify the times, then set the
1227 * mtime nanosecond field to 1 billion. This will get
1228 * translated from 1 billion nanoseconds to 1 million
1229 * microseconds in the over the wire request. The
1230 * server will use 1 million in the microsecond field
1231 * to tell whether both the mtime and atime should be
1232 * set to the server's current time.
1233 *
1234 * This is an overload of the protocol and should be
1235 * documented in the NFS Version 2 protocol specification.
1236 */
1243 /*
1244 * Use server times. vap time values will not be used.
1245 * To ensure no time overflow, make sure vap has
1246 * valid values, but retain the original values.
1247 */
1254 /* Just in case server does not know of this */
1260 }
1262 /* set vap times back on */
1265 }
1267 /* Either do not set times or use the client specified times */
1269 }
1271 /* req time field(s) overflow - return immediately */
1273 }
1293 /*
1294 * Purge the access cache and ACL cache if changing either the
1295 * owner of the file, the group owner, or the mode. These may
1296 * change the access permissions of the file, so purge old
1297 * information and start over again.
1298 */
1308 }
1309 }
1314 /*
1315 * If changing the size of the file, invalidate
1316 * any local cached data which is no longer part
1317 * of the file. We also possibly invalidate the
1318 * last page in the file. We could use
1319 * pvn_vpzero(), but this would mark the page as
1320 * modified and require it to be written back to
1321 * the server for no particularly good reason.
1322 * This way, if we access it, then we bring it
1323 * back in. A read should be cheaper than a
1324 * write.
1325 */
1329 }
1331 /*
1332 * If NFS_ACL is supported on the server, then the
1333 * attributes returned by server may have minimal
1334 * permissions sometimes denying access to users having
1335 * proper access. To get the proper attributes, mark
1336 * the attributes as expired so that they will be
1337 * regotten via the NFS_ACL GETATTR2 procedure.
1338 */
1341 }
1342 /*
1343 * This next check attempts to deal with NFS
1344 * servers which can not handle increasing
1345 * the size of the file via setattr. Most
1346 * of these servers do not return an error,
1347 * but do not change the size of the file.
1348 * Hence, this check and then attempt to set
1349 * the file size by writing 1 byte at the
1350 * offset of the end of the file that we need.
1351 */
1359 }
1360 /*
1361 * Some servers will change the mode to clear the setuid
1362 * and setgid bits when changing the uid or gid. The
1363 * client needs to compensate appropriately.
1364 */
1378 else
1381 }
1382 }
1386 }
1389 }
1392 }
1394 static int
1396 {
1399 }
1401 /* ARGSUSED */
1402 static int
1404 {
1418 }
1425 /*
1426 * Disallow write attempts on read-only
1427 * file systems, unless the file is a
1428 * device node.
1429 */
1433 /*
1434 * Disallow attempts to access mandatory lock files.
1435 */
1440 /*
1441 * Access check is based on only
1442 * one of owner, group, public.
1443 * If not owner, then check group.
1444 * If not a member of the group,
1445 * then check public access.
1446 */
1451 }
1455 }
1459 /* ARGSUSED */
1460 static int
1462 {
1467 failinfo_t fi;
1469 /*
1470 * We want to be consistent with UFS semantics so we will return
1471 * EINVAL instead of ENXIO. This violates the XNFS spec and
1472 * the RFC 1094, which are wrong any way. BUGID 1138002.
1473 */
1491 }
1493 }
1515 }
1531 NFS_MAXPATHLEN);
1532 }
1536 }
1541 }
1543 /*
1544 * Conform to UFS semantics (see comment above)
1545 */
1547 }
1549 /*
1550 * Flush local dirty pages to stable storage on the server.
1551 *
1552 * If FNODSYNC is specified, then there is nothing to do because
1553 * metadata changes are not cached on the client before being
1554 * sent to the server.
1555 */
1556 /* ARGSUSED */
1557 static int
1559 {
1572 }
1575 /*
1576 * Weirdness: if the file was removed or the target of a rename
1577 * operation while it was open, it got renamed instead. Here we
1578 * remove the renamed file.
1579 */
1580 /* ARGSUSED */
1581 static void
1583 {
1588 /*
1589 * If this is coming from the wrong zone, we let someone in the right
1590 * zone take care of it asynchronously. We can get here due to
1591 * VN_RELE() being called from pageout() or fsflush(). This call may
1592 * potentially turn into an expensive no-op if, for instance, v_count
1593 * gets incremented in the meantime, but it's still correct.
1594 */
1598 }
1601 redo:
1603 /*
1604 * Save the vnode pointer for the directory where the
1605 * unlinked-open file got renamed, then set it to NULL
1606 * to prevent another thread from getting here before
1607 * we're done with the remove. While we have the
1608 * statelock, make local copies of the pertinent rnode
1609 * fields. If we weren't to do this in an atomic way, the
1610 * the unl* fields could become inconsistent with respect
1611 * to each other due to a race condition between this
1612 * code and nfs_remove(). See bug report 1034328.
1613 */
1632 /*
1633 * If there are any dirty pages left, then flush
1634 * them. This is unfortunate because they just
1635 * may get thrown away during the remove operation,
1636 * but we have to do this for correctness.
1637 */
1648 }
1649 }
1651 /*
1652 * Do the remove operation on the renamed file
1653 */
1667 /*
1668 * Release stuff held for the remove
1669 */
1674 }
1676 }
1679 }
1681 /*
1682 * Remote file system operations having to do with directory manipulation.
1683 */
1685 /* ARGSUSED */
1686 static int
1690 {
1701 /*
1702 * Are we looking up extended attributes? If so, "dvp" is
1703 * the file or directory for which we want attributes, and
1704 * we need a lookup of the hidden attribute directory
1705 * before we lookup the rest of the path.
1706 */
1721 else
1730 }
1733 }
1738 }
1744 /*
1745 * If vnode is a device, create special vnode.
1746 */
1751 }
1753 out:
1758 }
1762 #ifdef DEBUG
1768 #endif
1770 /* ARGSUSED */
1771 int
1774 {
1779 /*
1780 * If lookup is for "", just return dvp. Don't need
1781 * to send it over the wire, look it up in the dnlc,
1782 * or perform any access checks.
1783 */
1788 }
1790 /*
1791 * Can't do lookups in non-directories.
1792 */
1796 /*
1797 * If we're called with RFSCALL_SOFT, it's important that
1798 * the only rfscall is one we make directly; if we permit
1799 * an access call because we're looking up "." or validating
1800 * a dnlc hit, we'll deadlock because that rfscall will not
1801 * have the RFSCALL_SOFT set.
1802 */
1806 /*
1807 * If lookup is for ".", just return dvp. Don't need
1808 * to send it over the wire or look it up in the dnlc,
1809 * just need to check access.
1810 */
1818 }
1820 /*
1821 * Lookup this name in the DNLC. If there was a valid entry,
1822 * then return the results of the lookup.
1823 */
1828 callit:
1832 }
1834 static int
1836 {
1843 /*
1844 * Lookup this name in the DNLC. If successful, then validate
1845 * the caches and then recheck the DNLC. The DNLC is rechecked
1846 * just in case this entry got invalidated during the call
1847 * to nfs_validate_caches.
1848 *
1849 * An assumption is being made that it is safe to say that a
1850 * file exists which may not on the server. Any operations to
1851 * the server will fail with ESTALE.
1852 */
1853 #ifdef DEBUG
1854 nfs_lookup_dnlc_lookups++;
1855 #endif
1861 }
1871 }
1874 #ifdef DEBUG
1875 nfs_lookup_dnlc_neg_hits++;
1876 #endif
1878 }
1880 #ifdef DEBUG
1881 nfs_lookup_dnlc_hits++;
1882 #endif
1884 }
1885 #ifdef DEBUG
1886 nfs_lookup_dnlc_disappears++;
1887 #endif
1888 }
1889 #ifdef DEBUG
1890 else
1891 nfs_lookup_dnlc_misses++;
1892 #endif
1897 }
1899 static int
1902 {
1907 failinfo_t fi;
1908 hrtime_t t;
1936 /*
1937 * If NFS_ACL is supported on the server, then the
1938 * attributes returned by server may have minimal
1939 * permissions sometimes denying access to users having
1940 * proper access. To get the proper attributes, mark
1941 * the attributes as expired so that they will be
1942 * regotten via the NFS_ACL GETATTR2 procedure.
1943 */
1946 }
1953 }
1954 }
1957 }
1959 /* ARGSUSED */
1960 static int
1964 {
1974 hrtime_t t;
1983 /*
1984 * We make a copy of the attributes because the caller does not
1985 * expect us to change what va points to.
1986 */
1989 /*
1990 * If the pathname is "", just use dvp. Don't need
1991 * to send it over the wire, look it up in the dnlc,
1992 * or perform any access checks.
1993 */
1998 /*
1999 * If the pathname is ".", just use dvp. Don't need
2000 * to send it over the wire or look it up in the dnlc,
2001 * just need to check access.
2002 */
2008 }
2011 /*
2012 * We need to go over the wire, just to be sure whether the
2013 * file exists or not. Using the DNLC can be dangerous in
2014 * this case when making a decision regarding existence.
2015 */
2018 }
2025 /*
2026 * If vnode is a device, create special vnode.
2027 */
2032 }
2040 /*
2041 * Existing file was truncated;
2042 * emit a create event.
2043 */
2045 }
2046 }
2047 }
2048 }
2054 }
2056 }
2064 }
2065 }
2071 /*
2072 * Decide what the group-id of the created file should be.
2073 * Set it in attribute list as advisory...then do a setattr
2074 * if the server didn't get it right the first time.
2075 */
2080 }
2083 /*
2084 * This is a completely gross hack to make mknod
2085 * work over the wire until we can wack the protocol
2086 */
2091 /*
2092 * dev_t is uint_t in 5.x and short in 4.x. Both 4.x
2093 * supports 8 bit majors. 5.x supports 14 bit majors. 5.x supports 18
2094 * bits in the minor number where 4.x supports 8 bits. If the 5.x
2095 * minor/major numbers <= 8 bits long, compress the device
2096 * number before sending it. Otherwise, the 4.x server will not
2097 * create the device with the correct device number and nothing can be
2098 * done about this.
2099 */
2102 dev32_t dev32;
2106 else
2112 else
2122 /*
2123 * To avoid triggering bugs in the servers set VATTR_SIZE
2124 * (all other RFS_CREATE calls set this).
2125 */
2128 }
2133 /* req time field(s) overflow - return immediately */
2136 }
2156 /*
2157 * If NFS_ACL is supported on the server, then the
2158 * attributes returned by server may have minimal
2159 * permissions sometimes denying access to users having
2160 * proper access. To get the proper attributes, mark
2161 * the attributes as expired so that they will be
2162 * regotten via the NFS_ACL GETATTR2 procedure.
2163 */
2166 }
2177 }
2178 }
2180 /*
2181 * Make sure the gid was set correctly.
2182 * If not, try to set it (but don't lose
2183 * any sleep over it).
2184 */
2188 }
2190 /*
2191 * If vnode is a device create special vnode
2192 */
2200 }
2201 }
2206 }
2208 /*
2209 * Weirdness: if the vnode to be removed is open
2210 * we rename it instead of removing it and nfs_inactive
2211 * will remove the new name.
2212 */
2213 /* ARGSUSED */
2214 static int
2216 {
2236 }
2242 }
2244 /*
2245 * First just remove the entry from the name cache, as it
2246 * is most likely the only entry for this vp.
2247 */
2250 /*
2251 * If the file has a v_count > 1 then there may be more than one
2252 * entry in the name cache due multiple links or an open file,
2253 * but we don't have the real reference count so flush all
2254 * possible entries.
2255 */
2259 /*
2260 * Now we have the real reference count on the vnode
2261 */
2284 }
2286 }
2289 /*
2290 * We need to flush any dirty pages which happen to
2291 * be hanging around before removing the file. This
2292 * shouldn't happen very often and mostly on file
2293 * systems mounted "nocto".
2294 */
2303 }
2304 }
2315 /*
2316 * The xattr dir may be gone after last attr is removed,
2317 * so flush it from dnlc.
2318 */
2332 }
2333 }
2334 }
2338 }
2344 }
2346 /* ARGSUSED */
2347 static int
2350 {
2387 }
2388 }
2393 /*
2394 * Notify the source file of this link operation.
2395 */
2397 }
2399 }
2401 /* ARGSUSED */
2402 static int
2405 {
2414 }
2416 /*
2417 * nfsrename does the real work of renaming in NFS Version 2.
2418 */
2419 static int
2422 {
2447 }
2454 }
2455 }
2457 /*
2458 * Lookup the target file. If it exists, it needs to be
2459 * checked to see whether it is a mount point and whether
2460 * it is active (open).
2461 */
2464 /*
2465 * If this file has been mounted on, then just
2466 * return busy because renaming to it would remove
2467 * the mounted file system from the name space.
2468 */
2474 }
2476 /*
2477 * Purge the name cache of all references to this vnode
2478 * so that we can check the reference count to infer
2479 * whether it is active or not.
2480 */
2481 /*
2482 * First just remove the entry from the name cache, as it
2483 * is most likely the only entry for this vp.
2484 */
2486 /*
2487 * If the file has a v_count > 1 then there may be more
2488 * than one entry in the name cache due multiple links
2489 * or an open file, but we don't have the real reference
2490 * count so flush all possible entries.
2491 */
2495 /*
2496 * If the vnode is active and is not a directory,
2497 * arrange to rename it to a
2498 * temporary file so that it will continue to be
2499 * accessible. This implements the "unlink-open-file"
2500 * semantics for the target of a rename operation.
2501 * Before doing this though, make sure that the
2502 * source and target files are not already the same.
2503 */
2505 /*
2506 * Lookup the source name.
2507 */
2511 /*
2512 * The source name *should* already exist.
2513 */
2519 }
2521 /*
2522 * Compare the two vnodes. If they are the same,
2523 * just release all held vnodes and return success.
2524 */
2531 }
2533 /*
2534 * Can't mix and match directories and non-
2535 * directories in rename operations. We already
2536 * know that the target is not a directory. If
2537 * the source is a directory, return an error.
2538 */
2545 }
2547 /*
2548 * The target file exists, is not the same as
2549 * the source file, and is active. Link it
2550 * to a temporary filename to avoid having
2551 * the server removing the file completely.
2552 */
2558 }
2566 }
2580 }
2582 }
2583 }
2586 /*
2587 * When renaming directories to be a subdirectory of a
2588 * different parent, the dnlc entry for ".." will no
2589 * longer be valid, so it must be removed.
2590 *
2591 * We do a lookup here to determine whether we are renaming
2592 * a directory and we need to check if we are renaming
2593 * an unlinked file. This might have already been done
2594 * in previous code, so we check ovp == NULL to avoid
2595 * doing it twice.
2596 */
2600 /*
2601 * The source name *should* already exist.
2602 */
2608 }
2610 }
2612 }
2637 /*
2638 * when renaming directories to be a subdirectory of a
2639 * different parent, the dnlc entry for ".." will no
2640 * longer be valid, so it must be removed
2641 */
2648 }
2649 }
2651 /*
2652 * If we are renaming the unlinked file, update the
2653 * r_unldvp and r_unlname as needed.
2654 */
2666 }
2667 }
2668 }
2671 /*
2672 * System V defines rename to return EEXIST, not
2673 * ENOTEMPTY if the target directory is not empty.
2674 * Over the wire, the error is NFSERR_ENOTEMPTY
2675 * which geterrno maps to ENOTEMPTY.
2676 */
2679 }
2680 }
2691 }
2695 }
2702 }
2704 /* ARGSUSED */
2705 static int
2708 {
2714 hrtime_t t;
2721 /*
2722 * Decide what the group-id and set-gid bit of the created directory
2723 * should be. May have to do a setattr to get the gid right.
2724 */
2736 /* req time field(s) overflow - return immediately */
2738 }
2762 /*
2763 * The attributes returned by RFS_MKDIR can not
2764 * be depended upon, so mark the attribute cache
2765 * as purged. A subsequent GETATTR will get the
2766 * correct attributes from the server.
2767 */
2773 /*
2774 * Make sure the gid was set correctly.
2775 * If not, try to set it (but don't lose
2776 * any sleep over it).
2777 */
2781 }
2784 }
2785 }
2790 }
2792 /* ARGSUSED */
2793 static int
2796 {
2810 /*
2811 * Attempt to prevent a rmdir(".") from succeeding.
2812 */
2817 }
2823 }
2827 /*
2828 * First just remove the entry from the name cache, as it
2829 * is most likely an entry for this vp.
2830 */
2833 /*
2834 * If there vnode reference count is greater than one, then
2835 * there may be additional references in the DNLC which will
2836 * need to be purged. First, trying removing the entry for
2837 * the parent directory and see if that removes the additional
2838 * reference(s). If that doesn't do it, then use dnlc_purge_vp
2839 * to completely remove any references to the directory which
2840 * might still exist in the DNLC.
2841 */
2846 }
2861 }
2871 /*
2872 * System V defines rmdir to return EEXIST, not
2873 * ENOTEMPTY if the directory is not empty. Over
2874 * the wire, the error is NFSERR_ENOTEMPTY which
2875 * geterrno maps to ENOTEMPTY.
2876 */
2879 }
2883 }
2889 }
2891 /* ARGSUSED */
2892 static int
2895 {
2908 /* req time field(s) overflow - return immediately */
2910 }
2935 }
2936 }
2941 }
2943 #ifdef DEBUG
2949 #endif
2953 /*
2954 * Read directory entries.
2955 * There are some weird things to look out for here. The uio_offset
2956 * field is either 0 or it is the offset returned from a previous
2957 * readdir. It is an opaque value used by the server to find the
2958 * correct directory block to read. The count field is the number
2959 * of blocks to read on the server. This is advisory only, the server
2960 * may return only one block's worth of entries. Entries may be compressed
2961 * on the server.
2962 */
2963 /* ARGSUSED */
2964 static int
2967 {
2974 #ifdef DEBUG
2976 #endif
2977 rddir_cache srdc;
2978 avl_index_t where;
2985 /*
2986 * Make sure that the directory cache is valid.
2987 */
2990 /*
2991 * Setting nfs_disable_rddir_cache in /etc/system
2992 * allows interoperability with servers that do not
2993 * properly update the attributes of directories.
2994 * Any cached information gets purged before an
2995 * access is made to it.
2996 */
3002 }
3003 }
3005 /*
3006 * UGLINESS: SunOS 3.2 servers apparently cannot always handle an
3007 * RFS_READDIR request with rda_count set to more than 0x400. So
3008 * we reduce the request size here purely for compatibility.
3009 *
3010 * In general, this is no longer required. However, if a server
3011 * is discovered which can not handle requests larger than 1024,
3012 * nfs_shrinkreaddir can be set to 1 to enable this backwards
3013 * compatibility.
3014 *
3015 * In any case, the request size is limited to NFS_MAXDATA bytes.
3016 */
3021 #ifdef DEBUG
3023 #endif
3024 top:
3025 /*
3026 * Short circuit last readdir which always returns 0 bytes.
3027 * This can be done after the directory has been read through
3028 * completely at least once. This will set r_direof which
3029 * can be used to find the value of the last cookie.
3030 */
3035 #ifdef DEBUG
3036 nfs_readdir_cache_shorts++;
3037 #endif
3043 }
3044 /*
3045 * Look for a cache entry. Cache entries are identified
3046 * by the NFS cookie value and the byte count requested.
3047 */
3053 /*
3054 * If the cache entry is in the process of being
3055 * filled in, wait until this completes. The
3056 * RDDIRWAIT bit is set to indicate that someone
3057 * is waiting and then the thread currently
3058 * filling the entry is done, it should do a
3059 * cv_broadcast to wakeup all of the threads
3060 * waiting for it to finish.
3061 */
3065 #ifdef DEBUG
3066 nfs_readdir_cache_waits++;
3067 #endif
3069 /*
3070 * We got interrupted, probably
3071 * the user typed ^C or an alarm
3072 * fired. We free the new entry
3073 * if we allocated one.
3074 */
3082 }
3088 }
3089 /*
3090 * Check to see if a readdir is required to
3091 * fill the entry. If so, mark this entry
3092 * as being filled, remove our reference,
3093 * and branch to the code to fill the entry.
3094 */
3103 }
3104 #ifdef DEBUG
3106 nfs_readdir_cache_hits++;
3107 #endif
3108 /*
3109 * If an error occurred while attempting
3110 * to fill the cache entry, just return it.
3111 */
3119 }
3121 /*
3122 * The cache entry is complete and good,
3123 * copyout the dirent structs to the calling
3124 * thread.
3125 */
3128 /*
3129 * If no error occurred during the copyout,
3130 * update the offset in the uio struct to
3131 * contain the value of the next cookie
3132 * and set the eof value appropriately.
3133 */
3138 }
3140 /*
3141 * Decide whether to do readahead. Don't if
3142 * have already read to the end of directory.
3143 */
3151 }
3153 /*
3154 * Check to see whether we found an entry
3155 * for the readahead. If so, we don't need
3156 * to do anything further, so free the new
3157 * entry if one was allocated. Otherwise,
3158 * allocate a new entry, add it to the cache,
3159 * and then initiate an asynchronous readdir
3160 * operation to fill it.
3161 */
3173 }
3181 #ifdef DEBUG
3182 nfs_readdir_readahead++;
3183 #endif
3186 }
3187 }
3192 }
3194 /*
3195 * Didn't find an entry in the cache. Construct a new empty
3196 * entry and link it into the cache. Other processes attempting
3197 * to access this entry will need to wait until it is filled in.
3198 *
3199 * Since kmem_alloc may block, another pass through the cache
3200 * will need to be taken to make sure that another process
3201 * hasn't already added an entry to the cache for this request.
3202 */
3209 }
3211 /*
3212 * Add this entry to the cache.
3213 */
3218 bottom:
3219 #ifdef DEBUG
3221 nfs_readdir_cache_misses++;
3222 #endif
3223 /*
3224 * Do the readdir.
3225 */
3228 /*
3229 * If this operation failed, just return the error which occurred.
3230 */
3234 /*
3235 * Since the RPC operation will have taken sometime and blocked
3236 * this process, another pass through the cache will need to be
3237 * taken to find the correct cache entry. It is possible that
3238 * the correct cache entry will not be there (although one was
3239 * added) because the directory changed during the RPC operation
3240 * and the readdir cache was flushed. In this case, just start
3241 * over. It is hoped that this will not happen too often... :-)
3242 */
3245 /* NOTREACHED */
3246 }
3248 static int
3250 {
3256 uint_t count;
3269 /*
3270 * NFS client failover support
3271 * suppress failover unless we have a zero cookie
3272 */
3282 }
3294 }
3308 }
3310 /*
3311 * Since we are actually doing a READDIR RPC, we must have
3312 * exclusive access to the cache entry being filled. Thus,
3313 * it is safe to update all fields except for the flags
3314 * field. The r_statelock in the rnode must be held to
3315 * prevent two different threads from simultaneously
3316 * attempting to update the flags field. This can happen
3317 * if we are turning off RDDIR and the other thread is
3318 * trying to set RDDIRWAIT.
3319 */
3328 #ifdef DEBUG
3330 KM_SLEEP);
3331 #else
3333 #endif
3342 }
3345 }
3346 }
3350 }
3358 }
3366 }
3368 #ifdef DEBUG
3370 #endif
3372 static int
3374 {
3379 uint_t offset;
3396 }
3398 read_again:
3405 /*
3406 * Didn't get it all because we hit EOF,
3407 * zero all the memory beyond the EOF.
3408 */
3409 /* bzero(rdaddr + */
3412 }
3416 /*
3417 * We didn't read anything at all as we are
3418 * past EOF. Return an error indicator back
3419 * but don't destroy the pages (yet).
3420 */
3422 }
3435 }
3437 }
3449 }
3451 write_again:
3457 #ifdef DEBUG
3461 offset);
3465 }
3466 #endif
3481 }
3483 }
3486 /*
3487 * Don't print EDQUOT errors on the console.
3488 * Don't print asynchronous EACCES errors.
3489 * Don't print EFBIG errors.
3490 * Print all other write errors.
3491 */
3496 /*
3497 * Update r_error and r_flags as appropriate.
3498 * If the error was ESTALE, then mark the
3499 * rnode as not being writeable and save
3500 * the error status. Otherwise, save any
3501 * errors which occur from asynchronous
3502 * page invalidations. Any errors occurring
3503 * from other operations should be saved
3504 * by the caller.
3505 */
3516 }
3518 }
3522 /*
3523 * A close may have cleared r_error, if so,
3524 * propagate ESTALE error return properly
3525 */
3528 }
3529 }
3537 }
3539 /* ARGSUSED */
3540 static int
3542 {
3551 }
3557 }
3559 /* ARGSUSED2 */
3560 static int
3562 {
3568 }
3575 }
3579 }
3581 /* ARGSUSED */
3582 static void
3584 {
3588 }
3590 /* ARGSUSED */
3591 static int
3593 {
3595 /*
3596 * Because we stuff the readdir cookie into the offset field
3597 * someone may attempt to do an lseek with the cookie which
3598 * we want to succeed.
3599 */
3605 }
3607 /*
3608 * number of NFS_MAXDATA blocks to read ahead
3609 * optimized for 100 base-T.
3610 */
3613 #ifdef DEBUG
3615 #endif
3617 /*
3618 * Return all the pages from [off..off+len) in file
3619 */
3620 /* ARGSUSED */
3621 static int
3625 {
3639 /*
3640 * Now valididate that the caches are up to date.
3641 */
3648 retry:
3651 /*
3652 * Don't create dirty pages faster than they
3653 * can be cleaned so that the system doesn't
3654 * get imbalanced. If the async queue is
3655 * maxed out, then wait for it to drain before
3656 * creating more dirty pages. Also, wait for
3657 * any threads doing pagewalks in the vop_getattr
3658 * entry points so that they don't block for
3659 * long periods.
3660 */
3666 }
3668 /*
3669 * If we are getting called as a side effect of an nfs_write()
3670 * operation the local file size might not be extended yet.
3671 * In this case we want to be able to return pages of zeroes.
3672 */
3676 }
3689 }
3692 }
3694 /*
3695 * Called from pvn_getpages to get a particular page.
3696 */
3697 /* ARGSUSED */
3698 static int
3702 {
3704 uint_t bsize;
3707 uoff_t lbn;
3708 uoff_t io_off;
3709 uoff_t blkoff;
3710 uoff_t rablkoff;
3712 uint_t blksize;
3724 reread:
3736 /*
3737 * Queueing up the readahead before doing the synchronous read
3738 * results in a significant increase in read throughput because
3739 * of the increased parallelism between the async threads and
3740 * the process context.
3741 */
3747 /*
3748 * Calculate the number of readaheads to do.
3749 * a) No readaheads at offset = 0.
3750 * b) Do maximum(nfs_nra) readaheads when the readahead
3751 * window is closed.
3752 * c) Do readaheads between 1 to (nfs_nra - 1) depending
3753 * upon how far the readahead window is open or close.
3754 * d) No readaheads if rp->r_nextr is not within the scope
3755 * of the readahead window (random i/o).
3756 */
3766 else
3777 }
3778 readahead--;
3780 /*
3781 * Indicate that we did a readahead so
3782 * readahead offset is not updated
3783 * by the synchronous read below.
3784 */
3787 /*
3788 * set readahead offset to
3789 * offset of last async readahead
3790 * request.
3791 */
3793 }
3795 }
3797 again:
3801 nfs_readahead);
3803 /*
3804 * Block for this page is not allocated, or the offset
3805 * is beyond the current allocation size, or we're
3806 * allocating a swap slot and the page was not found,
3807 * so allocate it and return a zero page.
3808 */
3817 /*
3818 * Need to go to server to get a BLOCK, exception to
3819 * that being while reading at offset = 0 or doing
3820 * random i/o, in that case read only a PAGE.
3821 */
3825 /*
3826 * If only a block or less is left in
3827 * the file, read all that is remaining.
3828 */
3830 /*
3831 * Trying to access beyond EOF,
3832 * set up to get at least one page.
3833 */
3848 /*
3849 * Some other thread has entered the page,
3850 * so just use it.
3851 */
3855 /*
3856 * Now round the request size up to page boundaries.
3857 * This ensures that the entire page will be
3858 * initialized to zeroes if EOF is encountered.
3859 */
3865 /*
3866 * pageio_setup should have set b_addr to 0. This
3867 * is correct since we want to do I/O on a page
3868 * boundary. bp_mapin will use this addr to calculate
3869 * an offset, and then set b_addr to the kernel virtual
3870 * address it allocated for us.
3871 */
3881 /*
3882 * If doing a write beyond what we believe is EOF,
3883 * don't bother trying to read the pages from the
3884 * server, we'll just zero the pages here. We
3885 * don't check that the rw flag is S_WRITE here
3886 * because some implementations may attempt a
3887 * read access to the buffer before copying data.
3888 */
3896 }
3898 /*
3899 * Unmap the buffer before freeing it.
3900 */
3905 /*
3906 * If doing a write system call just return
3907 * zeroed pages, else user tried to get pages
3908 * beyond EOF, return error. We don't check
3909 * that the rw flag is S_WRITE here because
3910 * some implementations may attempt a read
3911 * access to the buffer before copying data.
3912 */
3915 else
3917 }
3923 }
3924 }
3925 }
3927 out:
3935 }
3940 /*
3941 * Page exists in the cache, acquire the appropriate lock.
3942 * If this fails, start all over again.
3943 */
3945 #ifdef DEBUG
3946 nfs_lostpage++;
3947 #endif
3949 }
3953 }
3959 }
3961 static void
3964 {
3967 uoff_t io_off;
3979 /*
3980 * If less than a block left in file read less
3981 * than a block.
3982 */
3990 /*
3991 * The isra flag passed to the kluster function is 1, we may have
3992 * gotten a return value of NULL for a variety of reasons (# of free
3993 * pages < minfree, someone entered the page on the vnode etc). In all
3994 * cases, we want to punt on the readahead.
3995 */
3999 /*
4000 * Now round the request size up to page boundaries.
4001 * This ensures that the entire page will be
4002 * initialized to zeroes if EOF is encountered.
4003 */
4009 /*
4010 * pageio_setup should have set b_addr to 0. This is correct since
4011 * we want to do I/O on a page boundary. bp_mapin() will use this addr
4012 * to calculate an offset, and then set b_addr to the kernel virtual
4013 * address it allocated for us.
4014 */
4024 /*
4025 * If doing a write beyond what we believe is EOF, don't bother trying
4026 * to read the pages from the server, we'll just zero the pages here.
4027 * We don't check that the rw flag is S_WRITE here because some
4028 * implementations may attempt a read access to the buffer before
4029 * copying data.
4030 */
4041 }
4043 /*
4044 * Unmap the buffer before freeing it.
4045 */
4051 /*
4052 * In case of error set readahead offset
4053 * to the lowest offset.
4054 * pvn_read_done() calls VN_DISPOSE to destroy the pages
4055 */
4061 }
4062 }
4064 /*
4065 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
4066 * If len == 0, do from off to EOF.
4067 *
4068 * The normal cases should be len == 0 && off == 0 (entire vp list),
4069 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
4070 * (from pageout).
4071 */
4072 /* ARGSUSED */
4073 static int
4076 {
4082 /*
4083 * XXX - Why should this check be made here?
4084 */
4106 }
4108 /*
4109 * Write out a single page, possibly klustering adjacent dirty pages.
4110 */
4111 int
4114 {
4115 uoff_t io_off;
4116 uoff_t lbn_off;
4117 uoff_t lbn;
4119 uint_t bsize;
4137 /*
4138 * Find a kluster that fits in one block, or in
4139 * one page if pages are bigger than blocks. If
4140 * there is less file space allocated than a whole
4141 * page, we'll shorten the i/o request below.
4142 */
4146 /*
4147 * pvn_write_kluster shouldn't have returned a page with offset
4148 * behind the original page we were given. Verify that.
4149 */
4152 /*
4153 * Now pp will have the list of kept dirty pages marked for
4154 * write back. It will also handle invalidation and freeing
4155 * of pages that are not dirty. Check for page length rounding
4156 * problems.
4157 */
4161 }
4162 /*
4163 * The RMODINPROGRESS flag makes sure that nfs(3)_bio() sees a
4164 * consistent value of r_size. RMODINPROGRESS is set in writerp().
4165 * When RMODINPROGRESS is set it indicates that a uiomove() is in
4166 * progress and the r_size has not been made consistent with the
4167 * new size of the file. When the uiomove() completes the r_size is
4168 * updated and the RMODINPROGRESS flag is cleared.
4169 *
4170 * The RMODINPROGRESS flag makes sure that nfs(3)_bio() sees a
4171 * consistent value of r_size. Without this handshaking, it is
4172 * possible that nfs(3)_bio() picks up the old value of r_size
4173 * before the uiomove() in writerp() completes. This will result
4174 * in the write through nfs(3)_bio() being dropped.
4175 *
4176 * More precisely, there is a window between the time the uiomove()
4177 * completes and the time the r_size is updated. If a fop_putpage()
4178 * operation intervenes in this window, the page will be picked up,
4179 * because it is dirty (it will be unlocked, unless it was
4180 * pagecreate'd). When the page is picked up as dirty, the dirty
4181 * bit is reset (pvn_getdirty()). In nfs(3)write(), r_size is
4182 * checked. This will still be the old size. Therefore the page will
4183 * not be written out. When segmap_release() calls fop_putpage(),
4184 * the page will be found to be clean and the write will be dropped.
4185 */
4192 /*
4193 * A write is in progress for this region of the file.
4194 * If we did not detect RMODINPROGRESS here then this
4195 * path through nfs_putapage() would eventually go to
4196 * nfs(3)_bio() and may not write out all of the data
4197 * in the pages. We end up losing data. So we decide
4198 * to set the modified bit on each page in the page
4199 * list and mark the rnode with RDIRTY. This write
4200 * will be restarted at some later time.
4201 */
4209 }
4217 }
4219 }
4223 nfs_sync_putapage);
4232 }
4234 static int
4237 {
4254 }
4257 /*
4258 * If this was not an async thread, then try again to
4259 * write out the pages, but this time, also destroy
4260 * them whether or not the write is successful. This
4261 * will prevent memory from filling up with these
4262 * pages and destroying them is the only alternative
4263 * if they can't be written out.
4264 *
4265 * Don't do this if this is an async thread because
4266 * when the pages are unlocked in pvn_write_done,
4267 * some other thread could have come along, locked
4268 * them, and queued for an async thread. It would be
4269 * possible for all of the async threads to be tied
4270 * up waiting to lock the pages again and they would
4271 * all already be locked and waiting for an async
4272 * thread to handle them. Deadlock.
4273 */
4277 }
4285 }
4287 }
4290 }
4292 /* ARGSUSED */
4293 static int
4297 {
4318 /*
4319 * If there is cached data and if close-to-open consistency
4320 * checking is not turned off and if the file system is not
4321 * mounted readonly, then force an over the wire getattr.
4322 * Otherwise, just invoke nfsgetattr to get a copy of the
4323 * attributes. The attribute cache will be used unless it
4324 * is timed out and if it is, then an over the wire getattr
4325 * will be issued.
4326 */
4331 else
4336 /*
4337 * Check to see if the vnode is currently marked as not cachable.
4338 * This means portions of the file are locked (through fop_frlock).
4339 * In this case the map request must be refused. We use
4340 * rp->r_lkserlock to avoid a race with concurrent lock requests.
4341 */
4344 /*
4345 * Atomically increment r_inmap after acquiring r_rwlock. The
4346 * idea here is to acquire r_rwlock to block read/write and
4347 * not to protect r_inmap. r_inmap will inform nfs_read/write()
4348 * that we are in nfs_map(). Now, r_rwlock is acquired in order
4349 * and we can prevent the deadlock that would have occurred
4350 * when nfs_addmap() would have acquired it out of order.
4351 *
4352 * Since we are not protecting r_inmap by any lock, we do not
4353 * hold any lock when we decrement it. We atomically decrement
4354 * r_inmap after we release r_lkserlock.
4355 */
4365 }
4369 }
4371 /*
4372 * Don't allow concurrent locks and mapping if mandatory locking is
4373 * enabled.
4374 */
4379 }
4386 }
4402 done:
4406 }
4408 /* ARGSUSED */
4409 static int
4413 {
4425 }
4427 /* ARGSUSED */
4428 static int
4431 {
4432 netobj lm_fh;
4438 /* check for valid cmd parameter */
4444 /* Verify l_type. */
4460 }
4462 /* check the validity of the lock range */
4468 /*
4469 * If the filesystem is mounted using local locking, pass the
4470 * request off to the local locking code.
4471 */
4476 /*
4477 * For complete safety, we should be holding
4478 * r_lkserlock. However, we can't call
4479 * lm_safelock and then fs_frlock while
4480 * holding r_lkserlock, so just invoke
4481 * lm_safelock and expect that this will
4482 * catch enough of the cases.
4483 */
4486 }
4488 }
4492 /*
4493 * Check whether the given lock request can proceed, given the
4494 * current file mappings.
4495 */
4502 }
4503 }
4505 /*
4506 * Flush the cache after waiting for async I/O to finish. For new
4507 * locks, this is so that the process gets the latest bits from the
4508 * server. For unlocks, this is so that other clients see the
4509 * latest bits once the file has been unlocked. If currently dirty
4510 * pages can't be flushed, then don't allow a lock to be set. But
4511 * allow unlocks to succeed, to avoid having orphan locks on the
4512 * server.
4513 */
4528 }
4533 }
4544 }
4548 }
4549 }
4550 }
4555 /*
4556 * Call the lock manager to do the real work of contacting
4557 * the server and obtaining the lock.
4558 */
4564 done:
4567 }
4569 /*
4570 * Free storage space associated with the specified vnode. The portion
4571 * to be freed is specified by bfp->l_start and bfp->l_len (already
4572 * normalized to a "whence" of 0).
4573 *
4574 * This is an experimental facility whose continued existence is not
4575 * guaranteed. Currently, we only support the special case
4576 * of l_len == 0, meaning free to end of file.
4577 */
4578 /* ARGSUSED */
4579 static int
4582 {
4605 /*
4606 * ftruncate should not change the ctime and
4607 * mtime if we truncate the file to its
4608 * previous size.
4609 */
4622 }
4625 }
4627 /* ARGSUSED */
4628 static int
4630 {
4633 }
4635 /*
4636 * Setup and add an address space callback to do the work of the delmap call.
4637 * The callback will (and must be) deleted in the actual callback function.
4638 *
4639 * This is done in order to take care of the problem that we have with holding
4640 * the address space's a_lock for a long period of time (e.g. if the NFS server
4641 * is down). Callbacks will be executed in the address space code while the
4642 * a_lock is not held. Holding the address space's a_lock causes things such
4643 * as ps and fork to hang because they are trying to acquire this lock as well.
4644 */
4645 /* ARGSUSED */
4646 static int
4650 {
4659 /*
4660 * A process may not change zones if it has NFS pages mmap'ed
4661 * in, so we can't legitimately get here from the wrong zone.
4662 */
4667 /*
4668 * The way that the address space of this process deletes its mapping
4669 * of this file is via the following call chains:
4670 * - as_free()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs_delmap()
4671 * - as_unmap()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs_delmap()
4672 *
4673 * With the use of address space callbacks we are allowed to drop the
4674 * address space lock, a_lock, while executing the NFS operations that
4675 * need to go over the wire. Returning EAGAIN to the caller of this
4676 * function is what drives the execution of the callback that we add
4677 * below. The callback will be executed by the address space code
4678 * after dropping the a_lock. When the callback is finished, since
4679 * we dropped the a_lock, it must be re-acquired and segvn_unmap()
4680 * is called again on the same segment to finish the rest of the work
4681 * that needs to happen during unmapping.
4682 *
4683 * This action of calling back into the segment driver causes
4684 * nfs_delmap() to get called again, but since the callback was
4685 * already executed at this point, it already did the work and there
4686 * is nothing left for us to do.
4687 *
4688 * To Summarize:
4689 * - The first time nfs_delmap is called by the current thread is when
4690 * we add the caller associated with this delmap to the delmap caller
4691 * list, add the callback, and return EAGAIN.
4692 * - The second time in this call chain when nfs_delmap is called we
4693 * will find this caller in the delmap caller list and realize there
4694 * is no more work to do thus removing this caller from the list and
4695 * returning the error that was set in the callback execution.
4696 */
4699 /*
4700 * 'error' is from the actual delmap operations. To avoid
4701 * hangs, we need to handle the return of EAGAIN differently
4702 * since this is what drives the callback execution.
4703 * In this case, we don't want to return EAGAIN and do the
4704 * callback execution because there are none to execute.
4705 */
4708 else
4710 }
4712 /* current caller was not in the list */
4735 }
4737 /*
4738 * Remove some pages from an mmap'd vnode. Just update the
4739 * count of pages. If doing close-to-open, then flush all
4740 * of the pages associated with this file. Otherwise, start
4741 * an asynchronous page flush to write out any dirty pages.
4742 * This will also associate a credential with the rnode which
4743 * can be used to write the pages.
4744 */
4745 /* ARGSUSED */
4746 static void
4748 {
4760 /*
4761 * Initiate a page flush if there are pages, the file system
4762 * was not mounted readonly, the segment was mapped shared, and
4763 * the pages themselves were writeable.
4764 */
4770 /*
4771 * If this is a cross-zone access a sync putpage won't work, so
4772 * the best we can do is try an async putpage. That seems
4773 * better than something more draconian such as discarding the
4774 * dirty pages.
4775 */
4780 else
4788 }
4799 }
4801 /* ARGSUSED */
4802 static int
4805 {
4810 /*
4811 * This looks a little weird because it's written in a general
4812 * manner but we make little use of cases. If cntl() ever gets
4813 * widely used, the outer switch will make more sense.
4814 */
4818 /*
4819 * Large file spec - need to base answer new query with
4820 * hardcoded constant based on the protocol.
4821 */
4850 /*
4851 * if we got here, error is really a boolean which
4852 * indicates whether cmd is set or not.
4853 */
4858 /*
4859 * if we got here, error is really a boolean which
4860 * indicates whether cmd is set or not.
4861 */
4865 }
4867 }
4893 }
4894 }
4903 }
4904 }
4906 /*
4907 * Called by async thread to do synchronous pageio. Do the i/o, wait
4908 * for it to complete, and cleanup the page list when done.
4909 */
4910 static int
4913 {
4920 else
4923 }
4925 /* ARGSUSED */
4926 static int
4929 {
4947 nfs_sync_pageio);
4955 }
4957 /* ARGSUSED */
4958 static int
4961 {
4973 }
4976 }
4978 /* ARGSUSED */
4979 static int
4982 {
4994 }
4997 }
4999 /* ARGSUSED */
5000 static int
5003 {
5007 netobj lm_fh;
5012 /*
5013 * check for valid cmd parameter
5014 */
5018 /*
5019 * Check access permissions
5020 */
5026 /*
5027 * If the filesystem is mounted using local locking, pass the
5028 * request off to the local share code.
5029 */
5039 /*
5040 * If passed an owner that is too large to fit in an
5041 * nfs_owner it is likely a recursive call from the
5042 * lock manager client and pass it straight through. If
5043 * it is not a nfs_owner then simply return an error.
5044 */
5047 NFS_OWNER_MAGIC)
5052 }
5054 }
5055 /*
5056 * Remote share reservations owner is a combination of
5057 * a magic number, hostname, and the local owner
5058 */
5073 }
5078 /*
5079 * NFS client can't store remote locks itself
5080 */
5088 }
5091 }