| blob | 664c6b1e58e0deeffdc1a165eb9a9902ef03d7f8 |
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 */
1109 }
1110 }
1112 /*
1113 * Only need to flush pages if asking for the mtime
1114 * and if there any dirty pages or any outstanding
1115 * asynchronous (write) requests for this file.
1116 */
1128 }
1132 }
1133 }
1136 }
1138 /*ARGSUSED4*/
1139 static int
1142 {
1144 uint_t mask;
1167 vp);
1178 }
1180 static int
1182 {
1184 uint_t mask;
1190 mode_t omode;
1193 hrtime_t t;
1201 /*
1202 * Only need to flush pages if there are any pages and
1203 * if the file is marked as dirty in some fashion. The
1204 * file must be flushed so that we can accurately
1205 * determine the size of the file and the cached data
1206 * after the SETATTR returns. A file is considered to
1207 * be dirty if it is either marked with RDIRTY, has
1208 * outstanding i/o's active, or is mmap'd. In this
1209 * last case, we can't tell whether there are dirty
1210 * pages, so we flush just to be sure.
1211 */
1223 }
1224 }
1226 /*
1227 * If the system call was utime(2) or utimes(2) and the
1228 * application did not specify the times, then set the
1229 * mtime nanosecond field to 1 billion. This will get
1230 * translated from 1 billion nanoseconds to 1 million
1231 * microseconds in the over the wire request. The
1232 * server will use 1 million in the microsecond field
1233 * to tell whether both the mtime and atime should be
1234 * set to the server's current time.
1235 *
1236 * This is an overload of the protocol and should be
1237 * documented in the NFS Version 2 protocol specification.
1238 */
1245 /*
1246 * Use server times. vap time values will not be used.
1247 * To ensure no time overflow, make sure vap has
1248 * valid values, but retain the original values.
1249 */
1256 /* Just in case server does not know of this */
1262 }
1264 /* set vap times back on */
1267 }
1269 /* Either do not set times or use the client specified times */
1271 }
1273 /* req time field(s) overflow - return immediately */
1275 }
1295 /*
1296 * Purge the access cache and ACL cache if changing either the
1297 * owner of the file, the group owner, or the mode. These may
1298 * change the access permissions of the file, so purge old
1299 * information and start over again.
1300 */
1310 }
1311 }
1316 /*
1317 * If changing the size of the file, invalidate
1318 * any local cached data which is no longer part
1319 * of the file. We also possibly invalidate the
1320 * last page in the file. We could use
1321 * pvn_vpzero(), but this would mark the page as
1322 * modified and require it to be written back to
1323 * the server for no particularly good reason.
1324 * This way, if we access it, then we bring it
1325 * back in. A read should be cheaper than a
1326 * write.
1327 */
1331 }
1333 /*
1334 * If NFS_ACL is supported on the server, then the
1335 * attributes returned by server may have minimal
1336 * permissions sometimes denying access to users having
1337 * proper access. To get the proper attributes, mark
1338 * the attributes as expired so that they will be
1339 * regotten via the NFS_ACL GETATTR2 procedure.
1340 */
1343 }
1344 /*
1345 * This next check attempts to deal with NFS
1346 * servers which can not handle increasing
1347 * the size of the file via setattr. Most
1348 * of these servers do not return an error,
1349 * but do not change the size of the file.
1350 * Hence, this check and then attempt to set
1351 * the file size by writing 1 byte at the
1352 * offset of the end of the file that we need.
1353 */
1361 }
1362 /*
1363 * Some servers will change the mode to clear the setuid
1364 * and setgid bits when changing the uid or gid. The
1365 * client needs to compensate appropriately.
1366 */
1380 else
1383 }
1384 }
1388 }
1391 }
1394 }
1396 static int
1398 {
1401 }
1403 /* ARGSUSED */
1404 static int
1406 {
1420 }
1427 /*
1428 * Disallow write attempts on read-only
1429 * file systems, unless the file is a
1430 * device node.
1431 */
1435 /*
1436 * Disallow attempts to access mandatory lock files.
1437 */
1442 /*
1443 * Access check is based on only
1444 * one of owner, group, public.
1445 * If not owner, then check group.
1446 * If not a member of the group,
1447 * then check public access.
1448 */
1453 }
1457 }
1461 /* ARGSUSED */
1462 static int
1464 {
1469 failinfo_t fi;
1471 /*
1472 * We want to be consistent with UFS semantics so we will return
1473 * EINVAL instead of ENXIO. This violates the XNFS spec and
1474 * the RFC 1094, which are wrong any way. BUGID 1138002.
1475 */
1493 }
1495 }
1517 }
1533 NFS_MAXPATHLEN);
1534 }
1538 }
1543 }
1545 /*
1546 * Conform to UFS semantics (see comment above)
1547 */
1549 }
1551 /*
1552 * Flush local dirty pages to stable storage on the server.
1553 *
1554 * If FNODSYNC is specified, then there is nothing to do because
1555 * metadata changes are not cached on the client before being
1556 * sent to the server.
1557 */
1558 /* ARGSUSED */
1559 static int
1561 {
1574 }
1577 /*
1578 * Weirdness: if the file was removed or the target of a rename
1579 * operation while it was open, it got renamed instead. Here we
1580 * remove the renamed file.
1581 */
1582 /* ARGSUSED */
1583 static void
1585 {
1590 /*
1591 * If this is coming from the wrong zone, we let someone in the right
1592 * zone take care of it asynchronously. We can get here due to
1593 * VN_RELE() being called from pageout() or fsflush(). This call may
1594 * potentially turn into an expensive no-op if, for instance, v_count
1595 * gets incremented in the meantime, but it's still correct.
1596 */
1600 }
1603 redo:
1605 /*
1606 * Save the vnode pointer for the directory where the
1607 * unlinked-open file got renamed, then set it to NULL
1608 * to prevent another thread from getting here before
1609 * we're done with the remove. While we have the
1610 * statelock, make local copies of the pertinent rnode
1611 * fields. If we weren't to do this in an atomic way, the
1612 * the unl* fields could become inconsistent with respect
1613 * to each other due to a race condition between this
1614 * code and nfs_remove(). See bug report 1034328.
1615 */
1634 /*
1635 * If there are any dirty pages left, then flush
1636 * them. This is unfortunate because they just
1637 * may get thrown away during the remove operation,
1638 * but we have to do this for correctness.
1639 */
1650 }
1651 }
1653 /*
1654 * Do the remove operation on the renamed file
1655 */
1669 /*
1670 * Release stuff held for the remove
1671 */
1676 }
1678 }
1681 }
1683 /*
1684 * Remote file system operations having to do with directory manipulation.
1685 */
1687 /* ARGSUSED */
1688 static int
1692 {
1703 /*
1704 * Are we looking up extended attributes? If so, "dvp" is
1705 * the file or directory for which we want attributes, and
1706 * we need a lookup of the hidden attribute directory
1707 * before we lookup the rest of the path.
1708 */
1723 else
1732 }
1735 }
1740 }
1746 /*
1747 * If vnode is a device, create special vnode.
1748 */
1753 }
1755 out:
1760 }
1764 #ifdef DEBUG
1770 #endif
1772 /* ARGSUSED */
1773 int
1776 {
1781 /*
1782 * If lookup is for "", just return dvp. Don't need
1783 * to send it over the wire, look it up in the dnlc,
1784 * or perform any access checks.
1785 */
1790 }
1792 /*
1793 * Can't do lookups in non-directories.
1794 */
1798 /*
1799 * If we're called with RFSCALL_SOFT, it's important that
1800 * the only rfscall is one we make directly; if we permit
1801 * an access call because we're looking up "." or validating
1802 * a dnlc hit, we'll deadlock because that rfscall will not
1803 * have the RFSCALL_SOFT set.
1804 */
1808 /*
1809 * If lookup is for ".", just return dvp. Don't need
1810 * to send it over the wire or look it up in the dnlc,
1811 * just need to check access.
1812 */
1820 }
1822 /*
1823 * Lookup this name in the DNLC. If there was a valid entry,
1824 * then return the results of the lookup.
1825 */
1830 callit:
1834 }
1836 static int
1838 {
1845 /*
1846 * Lookup this name in the DNLC. If successful, then validate
1847 * the caches and then recheck the DNLC. The DNLC is rechecked
1848 * just in case this entry got invalidated during the call
1849 * to nfs_validate_caches.
1850 *
1851 * An assumption is being made that it is safe to say that a
1852 * file exists which may not on the server. Any operations to
1853 * the server will fail with ESTALE.
1854 */
1855 #ifdef DEBUG
1856 nfs_lookup_dnlc_lookups++;
1857 #endif
1863 }
1873 }
1876 #ifdef DEBUG
1877 nfs_lookup_dnlc_neg_hits++;
1878 #endif
1880 }
1882 #ifdef DEBUG
1883 nfs_lookup_dnlc_hits++;
1884 #endif
1886 }
1887 #ifdef DEBUG
1888 nfs_lookup_dnlc_disappears++;
1889 #endif
1890 }
1891 #ifdef DEBUG
1892 else
1893 nfs_lookup_dnlc_misses++;
1894 #endif
1899 }
1901 static int
1904 {
1909 failinfo_t fi;
1910 hrtime_t t;
1938 /*
1939 * If NFS_ACL is supported on the server, then the
1940 * attributes returned by server may have minimal
1941 * permissions sometimes denying access to users having
1942 * proper access. To get the proper attributes, mark
1943 * the attributes as expired so that they will be
1944 * regotten via the NFS_ACL GETATTR2 procedure.
1945 */
1948 }
1955 }
1956 }
1959 }
1961 /* ARGSUSED */
1962 static int
1966 {
1976 hrtime_t t;
1985 /*
1986 * We make a copy of the attributes because the caller does not
1987 * expect us to change what va points to.
1988 */
1991 /*
1992 * If the pathname is "", just use dvp. Don't need
1993 * to send it over the wire, look it up in the dnlc,
1994 * or perform any access checks.
1995 */
2000 /*
2001 * If the pathname is ".", just use dvp. Don't need
2002 * to send it over the wire or look it up in the dnlc,
2003 * just need to check access.
2004 */
2010 }
2013 /*
2014 * We need to go over the wire, just to be sure whether the
2015 * file exists or not. Using the DNLC can be dangerous in
2016 * this case when making a decision regarding existence.
2017 */
2020 }
2027 /*
2028 * If vnode is a device, create special vnode.
2029 */
2034 }
2042 /*
2043 * Existing file was truncated;
2044 * emit a create event.
2045 */
2047 }
2048 }
2049 }
2050 }
2056 }
2058 }
2066 }
2067 }
2073 /*
2074 * Decide what the group-id of the created file should be.
2075 * Set it in attribute list as advisory...then do a setattr
2076 * if the server didn't get it right the first time.
2077 */
2082 }
2085 /*
2086 * This is a completely gross hack to make mknod
2087 * work over the wire until we can wack the protocol
2088 */
2093 /*
2094 * dev_t is uint_t in 5.x and short in 4.x. Both 4.x
2095 * supports 8 bit majors. 5.x supports 14 bit majors. 5.x supports 18
2096 * bits in the minor number where 4.x supports 8 bits. If the 5.x
2097 * minor/major numbers <= 8 bits long, compress the device
2098 * number before sending it. Otherwise, the 4.x server will not
2099 * create the device with the correct device number and nothing can be
2100 * done about this.
2101 */
2104 dev32_t dev32;
2108 else
2114 else
2124 /*
2125 * To avoid triggering bugs in the servers set AT_SIZE
2126 * (all other RFS_CREATE calls set this).
2127 */
2130 }
2135 /* req time field(s) overflow - return immediately */
2138 }
2158 /*
2159 * If NFS_ACL is supported on the server, then the
2160 * attributes returned by server may have minimal
2161 * permissions sometimes denying access to users having
2162 * proper access. To get the proper attributes, mark
2163 * the attributes as expired so that they will be
2164 * regotten via the NFS_ACL GETATTR2 procedure.
2165 */
2168 }
2179 }
2180 }
2182 /*
2183 * Make sure the gid was set correctly.
2184 * If not, try to set it (but don't lose
2185 * any sleep over it).
2186 */
2190 }
2192 /*
2193 * If vnode is a device create special vnode
2194 */
2202 }
2203 }
2208 }
2210 /*
2211 * Weirdness: if the vnode to be removed is open
2212 * we rename it instead of removing it and nfs_inactive
2213 * will remove the new name.
2214 */
2215 /* ARGSUSED */
2216 static int
2218 {
2238 }
2244 }
2246 /*
2247 * First just remove the entry from the name cache, as it
2248 * is most likely the only entry for this vp.
2249 */
2252 /*
2253 * If the file has a v_count > 1 then there may be more than one
2254 * entry in the name cache due multiple links or an open file,
2255 * but we don't have the real reference count so flush all
2256 * possible entries.
2257 */
2261 /*
2262 * Now we have the real reference count on the vnode
2263 */
2286 }
2288 }
2291 /*
2292 * We need to flush any dirty pages which happen to
2293 * be hanging around before removing the file. This
2294 * shouldn't happen very often and mostly on file
2295 * systems mounted "nocto".
2296 */
2305 }
2306 }
2317 /*
2318 * The xattr dir may be gone after last attr is removed,
2319 * so flush it from dnlc.
2320 */
2334 }
2335 }
2336 }
2340 }
2346 }
2348 /* ARGSUSED */
2349 static int
2352 {
2389 }
2390 }
2395 /*
2396 * Notify the source file of this link operation.
2397 */
2399 }
2401 }
2403 /* ARGSUSED */
2404 static int
2407 {
2416 }
2418 /*
2419 * nfsrename does the real work of renaming in NFS Version 2.
2420 */
2421 static int
2424 {
2449 }
2456 }
2457 }
2459 /*
2460 * Lookup the target file. If it exists, it needs to be
2461 * checked to see whether it is a mount point and whether
2462 * it is active (open).
2463 */
2466 /*
2467 * If this file has been mounted on, then just
2468 * return busy because renaming to it would remove
2469 * the mounted file system from the name space.
2470 */
2476 }
2478 /*
2479 * Purge the name cache of all references to this vnode
2480 * so that we can check the reference count to infer
2481 * whether it is active or not.
2482 */
2483 /*
2484 * First just remove the entry from the name cache, as it
2485 * is most likely the only entry for this vp.
2486 */
2488 /*
2489 * If the file has a v_count > 1 then there may be more
2490 * than one entry in the name cache due multiple links
2491 * or an open file, but we don't have the real reference
2492 * count so flush all possible entries.
2493 */
2497 /*
2498 * If the vnode is active and is not a directory,
2499 * arrange to rename it to a
2500 * temporary file so that it will continue to be
2501 * accessible. This implements the "unlink-open-file"
2502 * semantics for the target of a rename operation.
2503 * Before doing this though, make sure that the
2504 * source and target files are not already the same.
2505 */
2507 /*
2508 * Lookup the source name.
2509 */
2513 /*
2514 * The source name *should* already exist.
2515 */
2521 }
2523 /*
2524 * Compare the two vnodes. If they are the same,
2525 * just release all held vnodes and return success.
2526 */
2533 }
2535 /*
2536 * Can't mix and match directories and non-
2537 * directories in rename operations. We already
2538 * know that the target is not a directory. If
2539 * the source is a directory, return an error.
2540 */
2547 }
2549 /*
2550 * The target file exists, is not the same as
2551 * the source file, and is active. Link it
2552 * to a temporary filename to avoid having
2553 * the server removing the file completely.
2554 */
2560 }
2568 }
2582 }
2584 }
2585 }
2588 /*
2589 * When renaming directories to be a subdirectory of a
2590 * different parent, the dnlc entry for ".." will no
2591 * longer be valid, so it must be removed.
2592 *
2593 * We do a lookup here to determine whether we are renaming
2594 * a directory and we need to check if we are renaming
2595 * an unlinked file. This might have already been done
2596 * in previous code, so we check ovp == NULL to avoid
2597 * doing it twice.
2598 */
2602 /*
2603 * The source name *should* already exist.
2604 */
2610 }
2612 }
2614 }
2639 /*
2640 * when renaming directories to be a subdirectory of a
2641 * different parent, the dnlc entry for ".." will no
2642 * longer be valid, so it must be removed
2643 */
2650 }
2651 }
2653 /*
2654 * If we are renaming the unlinked file, update the
2655 * r_unldvp and r_unlname as needed.
2656 */
2668 }
2669 }
2670 }
2673 /*
2674 * System V defines rename to return EEXIST, not
2675 * ENOTEMPTY if the target directory is not empty.
2676 * Over the wire, the error is NFSERR_ENOTEMPTY
2677 * which geterrno maps to ENOTEMPTY.
2678 */
2681 }
2682 }
2693 }
2697 }
2704 }
2706 /* ARGSUSED */
2707 static int
2710 {
2716 hrtime_t t;
2723 /*
2724 * Decide what the group-id and set-gid bit of the created directory
2725 * should be. May have to do a setattr to get the gid right.
2726 */
2738 /* req time field(s) overflow - return immediately */
2740 }
2764 /*
2765 * The attributes returned by RFS_MKDIR can not
2766 * be depended upon, so mark the attribute cache
2767 * as purged. A subsequent GETATTR will get the
2768 * correct attributes from the server.
2769 */
2775 /*
2776 * Make sure the gid was set correctly.
2777 * If not, try to set it (but don't lose
2778 * any sleep over it).
2779 */
2783 }
2786 }
2787 }
2792 }
2794 /* ARGSUSED */
2795 static int
2798 {
2812 /*
2813 * Attempt to prevent a rmdir(".") from succeeding.
2814 */
2819 }
2825 }
2829 /*
2830 * First just remove the entry from the name cache, as it
2831 * is most likely an entry for this vp.
2832 */
2835 /*
2836 * If there vnode reference count is greater than one, then
2837 * there may be additional references in the DNLC which will
2838 * need to be purged. First, trying removing the entry for
2839 * the parent directory and see if that removes the additional
2840 * reference(s). If that doesn't do it, then use dnlc_purge_vp
2841 * to completely remove any references to the directory which
2842 * might still exist in the DNLC.
2843 */
2848 }
2863 }
2873 /*
2874 * System V defines rmdir to return EEXIST, not
2875 * ENOTEMPTY if the directory is not empty. Over
2876 * the wire, the error is NFSERR_ENOTEMPTY which
2877 * geterrno maps to ENOTEMPTY.
2878 */
2881 }
2885 }
2891 }
2893 /* ARGSUSED */
2894 static int
2897 {
2910 /* req time field(s) overflow - return immediately */
2912 }
2937 }
2938 }
2943 }
2945 #ifdef DEBUG
2951 #endif
2955 /*
2956 * Read directory entries.
2957 * There are some weird things to look out for here. The uio_offset
2958 * field is either 0 or it is the offset returned from a previous
2959 * readdir. It is an opaque value used by the server to find the
2960 * correct directory block to read. The count field is the number
2961 * of blocks to read on the server. This is advisory only, the server
2962 * may return only one block's worth of entries. Entries may be compressed
2963 * on the server.
2964 */
2965 /* ARGSUSED */
2966 static int
2969 {
2976 #ifdef DEBUG
2978 #endif
2979 rddir_cache srdc;
2980 avl_index_t where;
2987 /*
2988 * Make sure that the directory cache is valid.
2989 */
2992 /*
2993 * Setting nfs_disable_rddir_cache in /etc/system
2994 * allows interoperability with servers that do not
2995 * properly update the attributes of directories.
2996 * Any cached information gets purged before an
2997 * access is made to it.
2998 */
3004 }
3005 }
3007 /*
3008 * UGLINESS: SunOS 3.2 servers apparently cannot always handle an
3009 * RFS_READDIR request with rda_count set to more than 0x400. So
3010 * we reduce the request size here purely for compatibility.
3011 *
3012 * In general, this is no longer required. However, if a server
3013 * is discovered which can not handle requests larger than 1024,
3014 * nfs_shrinkreaddir can be set to 1 to enable this backwards
3015 * compatibility.
3016 *
3017 * In any case, the request size is limited to NFS_MAXDATA bytes.
3018 */
3023 #ifdef DEBUG
3025 #endif
3026 top:
3027 /*
3028 * Short circuit last readdir which always returns 0 bytes.
3029 * This can be done after the directory has been read through
3030 * completely at least once. This will set r_direof which
3031 * can be used to find the value of the last cookie.
3032 */
3037 #ifdef DEBUG
3038 nfs_readdir_cache_shorts++;
3039 #endif
3045 }
3046 /*
3047 * Look for a cache entry. Cache entries are identified
3048 * by the NFS cookie value and the byte count requested.
3049 */
3055 /*
3056 * If the cache entry is in the process of being
3057 * filled in, wait until this completes. The
3058 * RDDIRWAIT bit is set to indicate that someone
3059 * is waiting and then the thread currently
3060 * filling the entry is done, it should do a
3061 * cv_broadcast to wakeup all of the threads
3062 * waiting for it to finish.
3063 */
3067 #ifdef DEBUG
3068 nfs_readdir_cache_waits++;
3069 #endif
3071 /*
3072 * We got interrupted, probably
3073 * the user typed ^C or an alarm
3074 * fired. We free the new entry
3075 * if we allocated one.
3076 */
3084 }
3090 }
3091 /*
3092 * Check to see if a readdir is required to
3093 * fill the entry. If so, mark this entry
3094 * as being filled, remove our reference,
3095 * and branch to the code to fill the entry.
3096 */
3105 }
3106 #ifdef DEBUG
3108 nfs_readdir_cache_hits++;
3109 #endif
3110 /*
3111 * If an error occurred while attempting
3112 * to fill the cache entry, just return it.
3113 */
3121 }
3123 /*
3124 * The cache entry is complete and good,
3125 * copyout the dirent structs to the calling
3126 * thread.
3127 */
3130 /*
3131 * If no error occurred during the copyout,
3132 * update the offset in the uio struct to
3133 * contain the value of the next cookie
3134 * and set the eof value appropriately.
3135 */
3140 }
3142 /*
3143 * Decide whether to do readahead. Don't if
3144 * have already read to the end of directory.
3145 */
3153 }
3155 /*
3156 * Check to see whether we found an entry
3157 * for the readahead. If so, we don't need
3158 * to do anything further, so free the new
3159 * entry if one was allocated. Otherwise,
3160 * allocate a new entry, add it to the cache,
3161 * and then initiate an asynchronous readdir
3162 * operation to fill it.
3163 */
3175 }
3183 #ifdef DEBUG
3184 nfs_readdir_readahead++;
3185 #endif
3188 }
3189 }
3194 }
3196 /*
3197 * Didn't find an entry in the cache. Construct a new empty
3198 * entry and link it into the cache. Other processes attempting
3199 * to access this entry will need to wait until it is filled in.
3200 *
3201 * Since kmem_alloc may block, another pass through the cache
3202 * will need to be taken to make sure that another process
3203 * hasn't already added an entry to the cache for this request.
3204 */
3211 }
3213 /*
3214 * Add this entry to the cache.
3215 */
3220 bottom:
3221 #ifdef DEBUG
3223 nfs_readdir_cache_misses++;
3224 #endif
3225 /*
3226 * Do the readdir.
3227 */
3230 /*
3231 * If this operation failed, just return the error which occurred.
3232 */
3236 /*
3237 * Since the RPC operation will have taken sometime and blocked
3238 * this process, another pass through the cache will need to be
3239 * taken to find the correct cache entry. It is possible that
3240 * the correct cache entry will not be there (although one was
3241 * added) because the directory changed during the RPC operation
3242 * and the readdir cache was flushed. In this case, just start
3243 * over. It is hoped that this will not happen too often... :-)
3244 */
3247 /* NOTREACHED */
3248 }
3250 static int
3252 {
3258 uint_t count;
3271 /*
3272 * NFS client failover support
3273 * suppress failover unless we have a zero cookie
3274 */
3284 }
3296 }
3310 }
3312 /*
3313 * Since we are actually doing a READDIR RPC, we must have
3314 * exclusive access to the cache entry being filled. Thus,
3315 * it is safe to update all fields except for the flags
3316 * field. The r_statelock in the rnode must be held to
3317 * prevent two different threads from simultaneously
3318 * attempting to update the flags field. This can happen
3319 * if we are turning off RDDIR and the other thread is
3320 * trying to set RDDIRWAIT.
3321 */
3330 #ifdef DEBUG
3332 KM_SLEEP);
3333 #else
3335 #endif
3344 }
3347 }
3348 }
3352 }
3360 }
3368 }
3370 #ifdef DEBUG
3372 #endif
3374 static int
3376 {
3381 uint_t offset;
3398 }
3400 read_again:
3407 /*
3408 * Didn't get it all because we hit EOF,
3409 * zero all the memory beyond the EOF.
3410 */
3411 /* bzero(rdaddr + */
3414 }
3418 /*
3419 * We didn't read anything at all as we are
3420 * past EOF. Return an error indicator back
3421 * but don't destroy the pages (yet).
3422 */
3424 }
3437 }
3439 }
3451 }
3453 write_again:
3459 #ifdef DEBUG
3463 offset);
3467 }
3468 #endif
3483 }
3485 }
3488 /*
3489 * Don't print EDQUOT errors on the console.
3490 * Don't print asynchronous EACCES errors.
3491 * Don't print EFBIG errors.
3492 * Print all other write errors.
3493 */
3498 /*
3499 * Update r_error and r_flags as appropriate.
3500 * If the error was ESTALE, then mark the
3501 * rnode as not being writeable and save
3502 * the error status. Otherwise, save any
3503 * errors which occur from asynchronous
3504 * page invalidations. Any errors occurring
3505 * from other operations should be saved
3506 * by the caller.
3507 */
3518 }
3520 }
3524 /*
3525 * A close may have cleared r_error, if so,
3526 * propagate ESTALE error return properly
3527 */
3530 }
3531 }
3539 }
3541 /* ARGSUSED */
3542 static int
3544 {
3553 }
3559 }
3561 /* ARGSUSED2 */
3562 static int
3564 {
3570 }
3577 }
3581 }
3583 /* ARGSUSED */
3584 static void
3586 {
3590 }
3592 /* ARGSUSED */
3593 static int
3595 {
3597 /*
3598 * Because we stuff the readdir cookie into the offset field
3599 * someone may attempt to do an lseek with the cookie which
3600 * we want to succeed.
3601 */
3607 }
3609 /*
3610 * number of NFS_MAXDATA blocks to read ahead
3611 * optimized for 100 base-T.
3612 */
3615 #ifdef DEBUG
3617 #endif
3619 /*
3620 * Return all the pages from [off..off+len) in file
3621 */
3622 /* ARGSUSED */
3623 static int
3627 {
3641 /*
3642 * Now valididate that the caches are up to date.
3643 */
3650 retry:
3653 /*
3654 * Don't create dirty pages faster than they
3655 * can be cleaned so that the system doesn't
3656 * get imbalanced. If the async queue is
3657 * maxed out, then wait for it to drain before
3658 * creating more dirty pages. Also, wait for
3659 * any threads doing pagewalks in the vop_getattr
3660 * entry points so that they don't block for
3661 * long periods.
3662 */
3668 }
3670 /*
3671 * If we are getting called as a side effect of an nfs_write()
3672 * operation the local file size might not be extended yet.
3673 * In this case we want to be able to return pages of zeroes.
3674 */
3678 }
3691 }
3694 }
3696 /*
3697 * Called from pvn_getpages to get a particular page.
3698 */
3699 /* ARGSUSED */
3700 static int
3704 {
3706 uint_t bsize;
3709 uoff_t lbn;
3710 uoff_t io_off;
3711 uoff_t blkoff;
3712 uoff_t rablkoff;
3714 uint_t blksize;
3726 reread:
3738 /*
3739 * Queueing up the readahead before doing the synchronous read
3740 * results in a significant increase in read throughput because
3741 * of the increased parallelism between the async threads and
3742 * the process context.
3743 */
3749 /*
3750 * Calculate the number of readaheads to do.
3751 * a) No readaheads at offset = 0.
3752 * b) Do maximum(nfs_nra) readaheads when the readahead
3753 * window is closed.
3754 * c) Do readaheads between 1 to (nfs_nra - 1) depending
3755 * upon how far the readahead window is open or close.
3756 * d) No readaheads if rp->r_nextr is not within the scope
3757 * of the readahead window (random i/o).
3758 */
3768 else
3779 }
3780 readahead--;
3782 /*
3783 * Indicate that we did a readahead so
3784 * readahead offset is not updated
3785 * by the synchronous read below.
3786 */
3789 /*
3790 * set readahead offset to
3791 * offset of last async readahead
3792 * request.
3793 */
3795 }
3797 }
3799 again:
3803 nfs_readahead);
3805 /*
3806 * Block for this page is not allocated, or the offset
3807 * is beyond the current allocation size, or we're
3808 * allocating a swap slot and the page was not found,
3809 * so allocate it and return a zero page.
3810 */
3819 /*
3820 * Need to go to server to get a BLOCK, exception to
3821 * that being while reading at offset = 0 or doing
3822 * random i/o, in that case read only a PAGE.
3823 */
3827 /*
3828 * If only a block or less is left in
3829 * the file, read all that is remaining.
3830 */
3832 /*
3833 * Trying to access beyond EOF,
3834 * set up to get at least one page.
3835 */
3850 /*
3851 * Some other thread has entered the page,
3852 * so just use it.
3853 */
3857 /*
3858 * Now round the request size up to page boundaries.
3859 * This ensures that the entire page will be
3860 * initialized to zeroes if EOF is encountered.
3861 */
3867 /*
3868 * pageio_setup should have set b_addr to 0. This
3869 * is correct since we want to do I/O on a page
3870 * boundary. bp_mapin will use this addr to calculate
3871 * an offset, and then set b_addr to the kernel virtual
3872 * address it allocated for us.
3873 */
3883 /*
3884 * If doing a write beyond what we believe is EOF,
3885 * don't bother trying to read the pages from the
3886 * server, we'll just zero the pages here. We
3887 * don't check that the rw flag is S_WRITE here
3888 * because some implementations may attempt a
3889 * read access to the buffer before copying data.
3890 */
3898 }
3900 /*
3901 * Unmap the buffer before freeing it.
3902 */
3907 /*
3908 * If doing a write system call just return
3909 * zeroed pages, else user tried to get pages
3910 * beyond EOF, return error. We don't check
3911 * that the rw flag is S_WRITE here because
3912 * some implementations may attempt a read
3913 * access to the buffer before copying data.
3914 */
3917 else
3919 }
3925 }
3926 }
3927 }
3929 out:
3937 }
3942 /*
3943 * Page exists in the cache, acquire the appropriate lock.
3944 * If this fails, start all over again.
3945 */
3947 #ifdef DEBUG
3948 nfs_lostpage++;
3949 #endif
3951 }
3955 }
3961 }
3963 static void
3966 {
3969 uoff_t io_off;
3981 /*
3982 * If less than a block left in file read less
3983 * than a block.
3984 */
3992 /*
3993 * The isra flag passed to the kluster function is 1, we may have
3994 * gotten a return value of NULL for a variety of reasons (# of free
3995 * pages < minfree, someone entered the page on the vnode etc). In all
3996 * cases, we want to punt on the readahead.
3997 */
4001 /*
4002 * Now round the request size up to page boundaries.
4003 * This ensures that the entire page will be
4004 * initialized to zeroes if EOF is encountered.
4005 */
4011 /*
4012 * pageio_setup should have set b_addr to 0. This is correct since
4013 * we want to do I/O on a page boundary. bp_mapin() will use this addr
4014 * to calculate an offset, and then set b_addr to the kernel virtual
4015 * address it allocated for us.
4016 */
4026 /*
4027 * If doing a write beyond what we believe is EOF, don't bother trying
4028 * to read the pages from the server, we'll just zero the pages here.
4029 * We don't check that the rw flag is S_WRITE here because some
4030 * implementations may attempt a read access to the buffer before
4031 * copying data.
4032 */
4043 }
4045 /*
4046 * Unmap the buffer before freeing it.
4047 */
4053 /*
4054 * In case of error set readahead offset
4055 * to the lowest offset.
4056 * pvn_read_done() calls VN_DISPOSE to destroy the pages
4057 */
4063 }
4064 }
4066 /*
4067 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
4068 * If len == 0, do from off to EOF.
4069 *
4070 * The normal cases should be len == 0 && off == 0 (entire vp list),
4071 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
4072 * (from pageout).
4073 */
4074 /* ARGSUSED */
4075 static int
4078 {
4084 /*
4085 * XXX - Why should this check be made here?
4086 */
4108 }
4110 /*
4111 * Write out a single page, possibly klustering adjacent dirty pages.
4112 */
4113 int
4116 {
4117 uoff_t io_off;
4118 uoff_t lbn_off;
4119 uoff_t lbn;
4121 uint_t bsize;
4139 /*
4140 * Find a kluster that fits in one block, or in
4141 * one page if pages are bigger than blocks. If
4142 * there is less file space allocated than a whole
4143 * page, we'll shorten the i/o request below.
4144 */
4148 /*
4149 * pvn_write_kluster shouldn't have returned a page with offset
4150 * behind the original page we were given. Verify that.
4151 */
4154 /*
4155 * Now pp will have the list of kept dirty pages marked for
4156 * write back. It will also handle invalidation and freeing
4157 * of pages that are not dirty. Check for page length rounding
4158 * problems.
4159 */
4163 }
4164 /*
4165 * The RMODINPROGRESS flag makes sure that nfs(3)_bio() sees a
4166 * consistent value of r_size. RMODINPROGRESS is set in writerp().
4167 * When RMODINPROGRESS is set it indicates that a uiomove() is in
4168 * progress and the r_size has not been made consistent with the
4169 * new size of the file. When the uiomove() completes the r_size is
4170 * updated and the RMODINPROGRESS flag is cleared.
4171 *
4172 * The RMODINPROGRESS flag makes sure that nfs(3)_bio() sees a
4173 * consistent value of r_size. Without this handshaking, it is
4174 * possible that nfs(3)_bio() picks up the old value of r_size
4175 * before the uiomove() in writerp() completes. This will result
4176 * in the write through nfs(3)_bio() being dropped.
4177 *
4178 * More precisely, there is a window between the time the uiomove()
4179 * completes and the time the r_size is updated. If a fop_putpage()
4180 * operation intervenes in this window, the page will be picked up,
4181 * because it is dirty (it will be unlocked, unless it was
4182 * pagecreate'd). When the page is picked up as dirty, the dirty
4183 * bit is reset (pvn_getdirty()). In nfs(3)write(), r_size is
4184 * checked. This will still be the old size. Therefore the page will
4185 * not be written out. When segmap_release() calls fop_putpage(),
4186 * the page will be found to be clean and the write will be dropped.
4187 */
4194 /*
4195 * A write is in progress for this region of the file.
4196 * If we did not detect RMODINPROGRESS here then this
4197 * path through nfs_putapage() would eventually go to
4198 * nfs(3)_bio() and may not write out all of the data
4199 * in the pages. We end up losing data. So we decide
4200 * to set the modified bit on each page in the page
4201 * list and mark the rnode with RDIRTY. This write
4202 * will be restarted at some later time.
4203 */
4211 }
4219 }
4221 }
4225 nfs_sync_putapage);
4234 }
4236 static int
4239 {
4256 }
4259 /*
4260 * If this was not an async thread, then try again to
4261 * write out the pages, but this time, also destroy
4262 * them whether or not the write is successful. This
4263 * will prevent memory from filling up with these
4264 * pages and destroying them is the only alternative
4265 * if they can't be written out.
4266 *
4267 * Don't do this if this is an async thread because
4268 * when the pages are unlocked in pvn_write_done,
4269 * some other thread could have come along, locked
4270 * them, and queued for an async thread. It would be
4271 * possible for all of the async threads to be tied
4272 * up waiting to lock the pages again and they would
4273 * all already be locked and waiting for an async
4274 * thread to handle them. Deadlock.
4275 */
4279 }
4287 }
4289 }
4292 }
4294 /* ARGSUSED */
4295 static int
4299 {
4320 /*
4321 * If there is cached data and if close-to-open consistency
4322 * checking is not turned off and if the file system is not
4323 * mounted readonly, then force an over the wire getattr.
4324 * Otherwise, just invoke nfsgetattr to get a copy of the
4325 * attributes. The attribute cache will be used unless it
4326 * is timed out and if it is, then an over the wire getattr
4327 * will be issued.
4328 */
4333 else
4338 /*
4339 * Check to see if the vnode is currently marked as not cachable.
4340 * This means portions of the file are locked (through fop_frlock).
4341 * In this case the map request must be refused. We use
4342 * rp->r_lkserlock to avoid a race with concurrent lock requests.
4343 */
4346 /*
4347 * Atomically increment r_inmap after acquiring r_rwlock. The
4348 * idea here is to acquire r_rwlock to block read/write and
4349 * not to protect r_inmap. r_inmap will inform nfs_read/write()
4350 * that we are in nfs_map(). Now, r_rwlock is acquired in order
4351 * and we can prevent the deadlock that would have occurred
4352 * when nfs_addmap() would have acquired it out of order.
4353 *
4354 * Since we are not protecting r_inmap by any lock, we do not
4355 * hold any lock when we decrement it. We atomically decrement
4356 * r_inmap after we release r_lkserlock.
4357 */
4367 }
4371 }
4373 /*
4374 * Don't allow concurrent locks and mapping if mandatory locking is
4375 * enabled.
4376 */
4381 }
4388 }
4404 done:
4408 }
4410 /* ARGSUSED */
4411 static int
4415 {
4427 }
4429 /* ARGSUSED */
4430 static int
4433 {
4434 netobj lm_fh;
4440 /* check for valid cmd parameter */
4446 /* Verify l_type. */
4462 }
4464 /* check the validity of the lock range */
4470 /*
4471 * If the filesystem is mounted using local locking, pass the
4472 * request off to the local locking code.
4473 */
4478 /*
4479 * For complete safety, we should be holding
4480 * r_lkserlock. However, we can't call
4481 * lm_safelock and then fs_frlock while
4482 * holding r_lkserlock, so just invoke
4483 * lm_safelock and expect that this will
4484 * catch enough of the cases.
4485 */
4488 }
4490 }
4494 /*
4495 * Check whether the given lock request can proceed, given the
4496 * current file mappings.
4497 */
4504 }
4505 }
4507 /*
4508 * Flush the cache after waiting for async I/O to finish. For new
4509 * locks, this is so that the process gets the latest bits from the
4510 * server. For unlocks, this is so that other clients see the
4511 * latest bits once the file has been unlocked. If currently dirty
4512 * pages can't be flushed, then don't allow a lock to be set. But
4513 * allow unlocks to succeed, to avoid having orphan locks on the
4514 * server.
4515 */
4530 }
4535 }
4546 }
4550 }
4551 }
4552 }
4557 /*
4558 * Call the lock manager to do the real work of contacting
4559 * the server and obtaining the lock.
4560 */
4566 done:
4569 }
4571 /*
4572 * Free storage space associated with the specified vnode. The portion
4573 * to be freed is specified by bfp->l_start and bfp->l_len (already
4574 * normalized to a "whence" of 0).
4575 *
4576 * This is an experimental facility whose continued existence is not
4577 * guaranteed. Currently, we only support the special case
4578 * of l_len == 0, meaning free to end of file.
4579 */
4580 /* ARGSUSED */
4581 static int
4584 {
4607 /*
4608 * ftruncate should not change the ctime and
4609 * mtime if we truncate the file to its
4610 * previous size.
4611 */
4624 }
4627 }
4629 /* ARGSUSED */
4630 static int
4632 {
4635 }
4637 /*
4638 * Setup and add an address space callback to do the work of the delmap call.
4639 * The callback will (and must be) deleted in the actual callback function.
4640 *
4641 * This is done in order to take care of the problem that we have with holding
4642 * the address space's a_lock for a long period of time (e.g. if the NFS server
4643 * is down). Callbacks will be executed in the address space code while the
4644 * a_lock is not held. Holding the address space's a_lock causes things such
4645 * as ps and fork to hang because they are trying to acquire this lock as well.
4646 */
4647 /* ARGSUSED */
4648 static int
4652 {
4661 /*
4662 * A process may not change zones if it has NFS pages mmap'ed
4663 * in, so we can't legitimately get here from the wrong zone.
4664 */
4669 /*
4670 * The way that the address space of this process deletes its mapping
4671 * of this file is via the following call chains:
4672 * - as_free()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs_delmap()
4673 * - as_unmap()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs_delmap()
4674 *
4675 * With the use of address space callbacks we are allowed to drop the
4676 * address space lock, a_lock, while executing the NFS operations that
4677 * need to go over the wire. Returning EAGAIN to the caller of this
4678 * function is what drives the execution of the callback that we add
4679 * below. The callback will be executed by the address space code
4680 * after dropping the a_lock. When the callback is finished, since
4681 * we dropped the a_lock, it must be re-acquired and segvn_unmap()
4682 * is called again on the same segment to finish the rest of the work
4683 * that needs to happen during unmapping.
4684 *
4685 * This action of calling back into the segment driver causes
4686 * nfs_delmap() to get called again, but since the callback was
4687 * already executed at this point, it already did the work and there
4688 * is nothing left for us to do.
4689 *
4690 * To Summarize:
4691 * - The first time nfs_delmap is called by the current thread is when
4692 * we add the caller associated with this delmap to the delmap caller
4693 * list, add the callback, and return EAGAIN.
4694 * - The second time in this call chain when nfs_delmap is called we
4695 * will find this caller in the delmap caller list and realize there
4696 * is no more work to do thus removing this caller from the list and
4697 * returning the error that was set in the callback execution.
4698 */
4701 /*
4702 * 'error' is from the actual delmap operations. To avoid
4703 * hangs, we need to handle the return of EAGAIN differently
4704 * since this is what drives the callback execution.
4705 * In this case, we don't want to return EAGAIN and do the
4706 * callback execution because there are none to execute.
4707 */
4710 else
4712 }
4714 /* current caller was not in the list */
4737 }
4739 /*
4740 * Remove some pages from an mmap'd vnode. Just update the
4741 * count of pages. If doing close-to-open, then flush all
4742 * of the pages associated with this file. Otherwise, start
4743 * an asynchronous page flush to write out any dirty pages.
4744 * This will also associate a credential with the rnode which
4745 * can be used to write the pages.
4746 */
4747 /* ARGSUSED */
4748 static void
4750 {
4762 /*
4763 * Initiate a page flush if there are pages, the file system
4764 * was not mounted readonly, the segment was mapped shared, and
4765 * the pages themselves were writeable.
4766 */
4772 /*
4773 * If this is a cross-zone access a sync putpage won't work, so
4774 * the best we can do is try an async putpage. That seems
4775 * better than something more draconian such as discarding the
4776 * dirty pages.
4777 */
4782 else
4790 }
4801 }
4803 /* ARGSUSED */
4804 static int
4807 {
4812 /*
4813 * This looks a little weird because it's written in a general
4814 * manner but we make little use of cases. If cntl() ever gets
4815 * widely used, the outer switch will make more sense.
4816 */
4820 /*
4821 * Large file spec - need to base answer new query with
4822 * hardcoded constant based on the protocol.
4823 */
4852 /*
4853 * if we got here, error is really a boolean which
4854 * indicates whether cmd is set or not.
4855 */
4860 /*
4861 * if we got here, error is really a boolean which
4862 * indicates whether cmd is set or not.
4863 */
4867 }
4869 }
4895 }
4896 }
4905 }
4906 }
4908 /*
4909 * Called by async thread to do synchronous pageio. Do the i/o, wait
4910 * for it to complete, and cleanup the page list when done.
4911 */
4912 static int
4915 {
4922 else
4925 }
4927 /* ARGSUSED */
4928 static int
4931 {
4949 nfs_sync_pageio);
4957 }
4959 /* ARGSUSED */
4960 static int
4963 {
4975 }
4978 }
4980 /* ARGSUSED */
4981 static int
4984 {
4996 }
4999 }
5001 /* ARGSUSED */
5002 static int
5005 {
5009 netobj lm_fh;
5014 /*
5015 * check for valid cmd parameter
5016 */
5020 /*
5021 * Check access permissions
5022 */
5028 /*
5029 * If the filesystem is mounted using local locking, pass the
5030 * request off to the local share code.
5031 */
5041 /*
5042 * If passed an owner that is too large to fit in an
5043 * nfs_owner it is likely a recursive call from the
5044 * lock manager client and pass it straight through. If
5045 * it is not a nfs_owner then simply return an error.
5046 */
5049 NFS_OWNER_MAGIC)
5054 }
5056 }
5057 /*
5058 * Remote share reservations owner is a combination of
5059 * a magic number, hostname, and the local owner
5060 */
5075 }
5080 /*
5081 * NFS client can't store remote locks itself
5082 */
5090 }
5093 }