| blob | ef07aa3b2a3878654f3fd7d5462d4dbdadf914f6 |
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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25 /*
26 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
27 */
29 /*
30 * Copyright 1983,1984,1985,1986,1987,1988,1989 AT&T.
31 * All Rights Reserved
32 */
34 /*
35 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
36 */
38 #include <sys/param.h>
39 #include <sys/types.h>
40 #include <sys/systm.h>
41 #include <sys/cred.h>
42 #include <sys/time.h>
43 #include <sys/vnode.h>
44 #include <sys/vfs.h>
45 #include <sys/vfs_opreg.h>
46 #include <sys/file.h>
47 #include <sys/filio.h>
48 #include <sys/uio.h>
49 #include <sys/buf.h>
50 #include <sys/mman.h>
51 #include <sys/pathname.h>
52 #include <sys/dirent.h>
53 #include <sys/debug.h>
54 #include <sys/vmsystm.h>
55 #include <sys/fcntl.h>
56 #include <sys/flock.h>
57 #include <sys/swap.h>
58 #include <sys/errno.h>
59 #include <sys/strsubr.h>
60 #include <sys/sysmacros.h>
61 #include <sys/kmem.h>
62 #include <sys/cmn_err.h>
63 #include <sys/pathconf.h>
64 #include <sys/utsname.h>
65 #include <sys/dnlc.h>
66 #include <sys/acl.h>
67 #include <sys/systeminfo.h>
68 #include <sys/policy.h>
69 #include <sys/sdt.h>
70 #include <sys/list.h>
71 #include <sys/stat.h>
72 #include <sys/zone.h>
74 #include <rpc/types.h>
75 #include <rpc/auth.h>
76 #include <rpc/clnt.h>
78 #include <nfs/nfs.h>
79 #include <nfs/nfs_clnt.h>
80 #include <nfs/nfs_acl.h>
81 #include <nfs/lm.h>
82 #include <nfs/nfs4.h>
83 #include <nfs/nfs4_kprot.h>
84 #include <nfs/rnode4.h>
85 #include <nfs/nfs4_clnt.h>
87 #include <vm/hat.h>
88 #include <vm/as.h>
89 #include <vm/page.h>
90 #include <vm/pvn.h>
91 #include <vm/seg.h>
92 #include <vm/seg_map.h>
93 #include <vm/seg_kpm.h>
94 #include <vm/seg_vn.h>
96 #include <fs/fs_subr.h>
98 #include <sys/ddi.h>
99 #include <sys/int_fmtio.h>
100 #include <sys/fs/autofs.h>
105 hrtime_t di_time_call;
109 NFS4_ACL_GET,
110 NFS4_ACL_SET
122 cred_t *);
124 stable_how4 *);
128 vsecattr_t *);
139 caller_context_t *);
151 cred_t *);
163 cred_t *);
165 cred_t *);
171 u_offset_t);
180 nfs4_lock_owner_t *);
190 /*
191 * Routines that implement the setting of v4 args for the misc. ops
192 */
197 nfs4_stateid_types_t *);
200 bitmap4);
205 /*
206 * These are the vnode ops functions that implement the vnode interface to
207 * the networked file system. See more comments below at nfs4_vnodeops.
208 */
211 caller_context_t *);
213 caller_context_t *);
215 caller_context_t *);
217 caller_context_t *);
219 caller_context_t *);
222 caller_context_t *);
226 vsecattr_t *);
246 caller_context_t *);
261 caller_context_t *);
263 caller_context_t *);
264 /*
265 * These vnode ops are required to be called from outside this source file,
266 * e.g. by ephemeral mount stub vnode ops, and so may not be declared
267 * as static.
268 */
270 caller_context_t *);
280 caller_context_t *);
282 caller_context_t *);
284 caller_context_t *);
286 /*
287 * Used for nfs4_commit_vp() to indicate if we should
288 * wait on pending writes.
289 */
290 #define NFS4_WRITE_NOWAIT 0
291 #define NFS4_WRITE_WAIT 1
295 /*
296 * Error flags used to pass information about certain special errors
297 * which need to be handled specially.
298 */
299 #define NFS_EOF -98
300 #define NFS_VERF_MISMATCH -97
302 /*
303 * Flags used to differentiate between which operation drove the
304 * potential CLOSE OTW. (see nfs4_close_otw_if_necessary)
305 */
306 #define NFS4_CLOSE_OP 0x1
307 #define NFS4_DELMAP_OP 0x2
308 #define NFS4_INACTIVE_OP 0x3
310 #define ISVDEV(t) ((t == VBLK) || (t == VCHR) || (t == VFIFO))
312 /* ALIGN64 aligns the given buffer and adjust buffer size to 64 bit */
313 #define ALIGN64(x, ptr, sz) \
314 x = ((uintptr_t)(ptr)) & (sizeof (uint64_t) - 1); \
315 if (x) { \
316 x = sizeof (uint64_t) - (x); \
317 sz -= (x); \
318 ptr += (x); \
319 }
321 #ifdef DEBUG
362 #endif
364 /*
365 * How long to wait before trying again if OPEN_CONFIRM gets ETIMEDOUT
366 * or NFS4ERR_RESOURCE.
367 */
372 /*
373 * number of pages to read ahead
374 * optimized for 100 base-T.
375 */
382 /*
383 * These are the vnode ops routines which implement the vnode interface to
384 * the networked file system. These routines just take their parameters,
385 * make them look networkish by putting the right info into interface structs,
386 * and then calling the appropriate remote routine(s) to do the work.
387 *
388 * Note on directory name lookup cacheing: If we detect a stale fhandle,
389 * we purge the directory cache relative to that vnode. This way, the
390 * user won't get burned by the cache repeatedly. See <nfs/rnode4.h> for
391 * more details on rnode locking.
392 */
429 /* no separate nfs4_dump */
438 NULL, NULL
439 };
441 /*
442 * The following are subroutines and definitions to set args or get res
443 * for the different nfsv4 ops
444 */
446 void
448 {
458 }
459 }
460 }
462 static void
464 {
474 }
475 }
476 }
478 static void
480 {
485 }
486 }
488 static void
492 {
497 /*
498 * The stateid is set to 0 if client is not modifying the size
499 * and otherwise to whatever nfs4_get_stateid() returns.
500 *
501 * XXX Note: nfs4_get_stateid() returns 0 if no lockowner and/or no
502 * state struct could be found for the process/file pair. We may
503 * want to change this in the future (by OPENing the file). See
504 * bug # 4474852.
505 */
517 }
522 }
524 static void
526 {
528 }
530 static int
532 bitmap4 supp)
533 {
547 }
553 }
555 static void
557 {
567 }
568 }
570 static void
573 {
583 }
585 void
587 {
591 }
595 }
596 }
598 /*
599 * XXX: This is referenced in modstubs.s
600 */
603 {
605 }
607 /*
608 * The OPEN operation opens a regular file.
609 */
610 /*ARGSUSED3*/
611 static int
613 {
625 /*
626 * Check to see if opening something besides a regular file;
627 * if so skip the OTW call
628 */
632 }
634 /*
635 * XXX - would like a check right here to know if the file is
636 * executable or not, so as to skip OTW
637 */
649 }
651 /*
652 * See if this file has just been CREATEd.
653 * If so, clear the flag and update the dnlc, which was previously
654 * skipped in nfs4_create.
655 * XXX need better serilization on this.
656 * XXX move this into the nf4open_otw call, after we have
657 * XXX acquired the open owner seqid sync.
658 */
665 /* This is needed so we don't bump the open ref count */
670 }
672 /*
673 * If caller specified O_TRUNC/FTRUNC, then be sure to set
674 * FWRITE (to drive successful setattr(size=0) after open)
675 */
680 just_been_created);
687 /* release the hold from vtodv */
690 /* exchange the shadow for the master vnode, if needed */
696 }
698 /*
699 * See if there's a "lost open" request to be saved and recovered.
700 */
701 static void
705 {
715 }
722 /*
723 * The vp (if it is not NULL) and dvp are held and rele'd via
724 * the recovery code. See nfs4_save_lost_rqst.
725 */
742 }
747 }
750 uint32 seconds;
751 uint32 nseconds;
752 };
754 /*
755 * The OPEN operation creates and/or opens a regular file
756 *
757 * ARGSUSED
758 */
759 static int
763 {
772 COMPOUND4args_clnt args;
773 COMPOUND4res_clnt res;
792 nfs4_recov_state_t recov_state;
793 nfs4_lost_rqst_t lost_rqst;
795 hrtime_t t;
806 /*
807 * Make sure we properly deal with setting the right gid on
808 * a newly created file to reflect the parent's setgid bit
809 */
813 /*
814 * If there is grpid mount flag used or
815 * the parent's directory has the setgid bit set
816 * _and_ the client was able to get a valid mapping
817 * for the parent dir's owner_group, we want to
818 * append NVERIFY(owner_group == dva.va_gid) and
819 * SETATTR to the CREATE compound.
820 */
828 }
830 }
832 /*
833 * Normal/non-create compound:
834 * PUTFH(dfh) + OPEN(create) + GETFH + GETATTR(new)
835 *
836 * Open(create) compound no setgid:
837 * PUTFH(dfh) + SAVEFH + OPEN(create) + GETFH + GETATTR(new) +
838 * RESTOREFH + GETATTR
839 *
840 * Open(create) setgid:
841 * PUTFH(dfh) + OPEN(create) + GETFH + GETATTR(new) +
842 * SAVEFH + PUTFH(dfh) + GETATTR(dvp) + RESTOREFH +
843 * NVERIFY(grp) + SETATTR
844 */
857 }
869 /*
870 * We are to create a file. Initialize the passed in vnode
871 * pointer.
872 */
875 /*
876 * Check to see if the client owns a read delegation and is
877 * trying to open for write. If so, then return the delegation
878 * to avoid the server doing a cb_recall and returning DELAY.
879 * NB - we don't use the statev4_lock here because we'd have
880 * to drop the lock anyway and the result would be stale.
881 */
886 /*
887 * If the file has a delegation, then do an access check up
888 * front. This avoids having to an access check later after
889 * we've already done start_op, which could deadlock.
890 */
898 }
899 }
907 recov_retry:
917 }
923 /* putfh directory fh */
927 /* OPEN: either op 1 or op 2 depending upon create/setgid flags */
932 /* name of file */
938 /* CREATE a file */
947 timestruc_t now;
952 }
953 /*
954 * Since the server will use this value for the
955 * mtime, make sure that it can't overflow. Zero
956 * out the MSB. The actual value does not matter
957 * here, only its uniqeness.
958 */
961 }
963 /* Now copy over verifier to OPEN4args. */
967 bitmap4 supp_attrs;
977 /* GUARDED4 or UNCHECKED4 */
979 supp_attrs);
989 }
990 }
992 /* NO CREATE */
994 }
1001 /* XXX should we just fail here? */
1003 }
1005 /*
1006 * This increments oop's ref count or creates a temporary 'just_created'
1007 * open owner that will become valid when this OPEN/OPEN_CONFIRM call
1008 * completes.
1009 */
1012 /* See if a permanent or just created open owner exists */
1015 /*
1016 * This open owner does not exist so create a temporary
1017 * just created one.
1018 */
1021 }
1024 /* this length never changes, do alloc before seqid sync */
1037 }
1039 }
1041 /* Check to see if we need to do the OTW call */
1046 /*
1047 * The OTW open is not necessary. Either
1048 * the open can succeed without it (eg.
1049 * delegation, error == 0) or the open
1050 * must fail due to an access failure
1051 * (error != 0). In either case, tidy
1052 * up and return.
1053 */
1063 }
1064 }
1080 /*
1081 * getfh w/sanity check for idx_open/idx_fattr
1082 */
1086 /* getattr */
1092 vattr_t _v;
1094 bitmap4 supp_attrs;
1101 /*
1102 * For setgid case, we need to:
1103 * 4:savefh(new) 5:putfh(dir) 6:getattr(dir) 7:restorefh(new)
1104 */
1116 /*
1117 * nverify
1118 */
1122 supp_attrs))) {
1124 /*
1125 * setattr
1126 *
1127 * We _know_ we're not messing with AT_SIZE or
1128 * AT_XTIME, so no need for stateid or flags.
1129 * Also we specify NULL rp since we're only
1130 * interested in setting owner_group attributes.
1131 */
1136 }
1139 /*
1140 * XXX - Revisit the last argument to nfs4_end_op()
1141 * once 5020486 is fixed.
1142 */
1151 }
1160 }
1188 num_bseqid_retry--;
1189 }
1197 /* give up if we keep getting BAD_SEQID */
1202 }
1210 }
1216 }
1221 }
1223 }
1225 /*
1226 * Will check and update lease after checking the rflag for
1227 * OPEN_CONFIRM in the successful OPEN call.
1228 */
1231 /*
1232 * XXX what if we're crossing mount points from server1:/drp
1233 * to server2:/drp/rp.
1234 */
1236 /* Signal our end of use of the open seqid */
1239 /*
1240 * This will destroy the open owner if it was just created,
1241 * and no one else has put a reference on it.
1242 */
1253 }
1256 /*
1257 * If the reply is NFS4ERR_ACCESS, it may be because
1258 * we are root (no root net access). If the real uid
1259 * is not root, then retry with the real uid instead.
1260 */
1264 }
1269 }
1272 }
1277 #ifdef DEBUG
1278 /*
1279 * verify attrset bitmap
1280 */
1283 /* make sure attrset returned is what we asked for */
1284 /* XXX Ignore this 'error' for now */
1287 }
1288 #endif
1294 }
1301 /*
1302 * The open stateid has been updated on the server but not
1303 * on the client yet. There is a path: makenfs4node->nfs4_attr_cache->
1304 * flush_pages->VOP_PUTPAGE->...->nfs4write where we will issue an OTW
1305 * WRITE call. That, however, will use the old stateid, so go ahead
1306 * and upate the open stateid now, before any call to makenfs4node.
1307 */
1317 }
1319 /*
1320 * We must determine if the file handle given by the otw open
1321 * is the same as the file handle which was passed in with
1322 * *vpp. This case can be reached if the file we are trying
1323 * to open has been removed and another file has been created
1324 * having the same file name. The passed in vnode is released
1325 * later.
1326 */
1329 }
1341 /*
1342 * For the newly created vp case, make sure the rnode
1343 * isn't bad before using it.
1344 */
1356 }
1359 needrecov);
1367 }
1370 }
1373 /*
1374 * It seems odd to get a full set of attrs and then not update
1375 * the object's attrcache in the non-create case. Create case uses
1376 * the attrs since makenfs4node checks to see if the attrs need to
1377 * be updated (and then updates them). The non-create case should
1378 * update attrs also.
1379 */
1382 }
1386 /* This does not do recovery for vp explicitly. */
1396 }
1399 needrecov);
1402 /* rele the makenfs4node */
1404 }
1408 }
1411 "nfs4open_otw: retry the open since OPEN "
1417 "createmode from GUARDED4 to "
1420 }
1422 }
1429 }
1432 }
1433 }
1443 /* Doesn't matter if 'oo_just_created' already was set as this */
1451 /* returns with 'os_sync_lock' held */
1465 }
1476 }
1486 /*
1487 * Need to reset this bitfield for the possible case where we were
1488 * going to OTW CLOSE the file, got a non-recoverable error, and before
1489 * we could retry the CLOSE, OPENed the file again.
1490 */
1494 #ifdef DEBUG
1499 #endif
1510 }
1512 /* get rid of our reference to find oop */
1517 /* accept delegation, if any */
1526 /*
1527 * If doing an exclusive create, then generate
1528 * a SETATTR to set the initial attributes.
1529 * Try to set the mtime and the atime to the
1530 * server's current time. It is somewhat
1531 * expected that these fields will be used to
1532 * store the exclusive create cookie. If not,
1533 * server implementors will need to know that
1534 * a SETATTR will follow an exclusive create
1535 * and the cookie should be destroyed if
1536 * appropriate.
1537 *
1538 * The AT_GID and AT_SIZE bits are turned off
1539 * so that the SETATTR request will not attempt
1540 * to process these. The gid will be set
1541 * separately if appropriate. The size is turned
1542 * off because it is assumed that a new file will
1543 * be created empty and if the file wasn't empty,
1544 * then the exclusive create will have failed
1545 * because the file must have existed already.
1546 * Therefore, no truncate operation is needed.
1547 */
1553 /*
1554 * Couldn't correct the attributes of
1555 * the newly created file and the
1556 * attributes are wrong. Remove the
1557 * file and return an error to the
1558 * application.
1559 */
1560 /* XXX will this take care of client state ? */
1562 "nfs4open_otw: EXCLUSIVE4: error %d on SETATTR:"
1566 /*
1567 * Since we've reled the vnode and removed
1568 * the file we now need to return the error.
1569 * At this point we don't want to update the
1570 * dircaches, call nfs4_waitfor_purge_complete
1571 * or set vpp to vp so we need to skip these
1572 * as well.
1573 */
1575 }
1576 }
1578 /*
1579 * If we created or found the correct vnode, due to create_flag or
1580 * fh_differs being set, then update directory cache attribute, readdir
1581 * and dnlc caches.
1582 */
1586 /*
1587 * Make sure getattr succeeded before using results.
1588 * note: op 7 is getattr(dir) for both flavors of
1589 * open(create).
1590 */
1599 }
1602 dinfop);
1603 }
1605 /*
1606 * If the page cache for this file was flushed from actions
1607 * above, it was done asynchronously and if that is true,
1608 * there is a need to wait here for it to complete. This must
1609 * be done outside of start_fop/end_fop.
1610 */
1613 /*
1614 * It is implicit that we are in the open case (create_flag == 0) since
1615 * fh_differs can only be set to a non-zero value in the open case.
1616 */
1620 /*
1621 * Be sure to set *vpp to the correct value before returning.
1622 */
1625 skip_update_dircaches:
1631 }
1638 }
1640 /*
1641 * Reopen an open instance. cf. nfs4open_otw().
1642 *
1643 * Errors are returned by the nfs4_error_t parameter.
1644 * - ep->error contains an errno value or zero.
1645 * - if it is zero, ep->stat is set to an NFS status code, if any.
1646 * If the file could not be reopened, but the caller should continue, the
1647 * file is marked dead and no error values are returned. If the caller
1648 * should stop recovering open files and start over, either the ep->error
1649 * value or ep->stat will indicate an error (either something that requires
1650 * recovery or EAGAIN). Note that some recovery (e.g., expired volatile
1651 * filehandles) may be handled silently by this routine.
1652 * - if it is EINTR, ETIMEDOUT, or NFS4_FRC_UNMT_ERR, recovery for lost state
1653 * will be started, so the caller should not do it.
1654 *
1655 * Gotos:
1656 * - kill_file : reopen failed in such a fashion to constitute marking the
1657 * file dead and setting the open stream's 'os_failed_reopen' as 1. This
1658 * is for cases where recovery is not possible.
1659 * - failed_reopen : same as above, except that the file has already been
1660 * marked dead, so no need to do it again.
1661 * - bailout : reopen failed but we are able to recover and retry the reopen -
1662 * either within this function immediately or via the calling function.
1663 */
1665 void
1668 bool_t is_recov)
1669 {
1670 COMPOUND4args_clnt args;
1671 COMPOUND4res_clnt res;
1681 seqid4 seqid;
1685 nfs4_lost_rqst_t lost_rqst;
1687 bool_t abort;
1690 hrtime_t t;
1698 /* this is the cred used to find the open owner */
1703 }
1704 /* use this cred for OTW operations */
1707 top:
1711 /* File system has been unmounted, quit */
1715 }
1723 }
1731 }
1733 /*
1734 * If the rnode has a delegation and the delegation has been
1735 * recovered and the server didn't request a recall and the caller
1736 * didn't specifically ask for CLAIM_PREVIOUS (nfs4frlock during
1737 * recovery) and the rnode hasn't been marked dead, then install
1738 * the delegation stateid in the open stream. Otherwise, proceed
1739 * with a CLAIM_PREVIOUS or CLAIM_NULL OPEN.
1740 */
1754 }
1757 /*
1758 * If the file failed recovery, just quit. This failure need not
1759 * affect other reopens, so don't return an error.
1760 */
1766 }
1769 /*
1770 * argop is empty here
1771 *
1772 * PUTFH, OPEN, GETATTR
1773 */
1785 /*
1786 * if this is a file mount then
1787 * use the mntinfo parentfh
1788 */
1793 /* putfh fh to reopen */
1795 }
1809 /* nothing allocated yet */
1811 }
1816 /*
1817 * We have two cases to deal with here:
1818 * 1) We're being called to reopen files in order to satisfy
1819 * a lock operation request which requires us to explicitly
1820 * reopen files which were opened under a delegation. If
1821 * we're in recovery, we *must* use CLAIM_PREVIOUS. In
1822 * that case, frc_use_claim_previous is TRUE and we must
1823 * use the rnode's current delegation type (r_deleg_type).
1824 * 2) We're reopening files during some form of recovery.
1825 * In this case, frc_use_claim_previous is FALSE and we
1826 * use the delegation type appropriate for recovery
1827 * (r_deleg_needs_recovery).
1828 */
1831 frc_use_claim_previous ?
1840 "failed for vp 0x%p for CLAIM_DELEGATE_CUR "
1844 /* nothing allocated yet */
1846 }
1854 }
1886 /* Construct the getfh part of the compound */
1889 /* Construct the getattr part of the compound */
1910 }
1922 }
1927 }
1938 }
1963 /*
1964 * Retry as a plain open. We don't need to worry about
1965 * checking the changeinfo: it is acceptable for a
1966 * client to re-open a file and continue processing
1967 * (in the absence of locks).
1968 */
1970 "nfs4_reopen: CLAIM_PREVIOUS: NFS4ERR_NO_GRACE; "
1975 }
1976 failed_msg =
2003 /* recover filehandle and retry */
2019 /*
2020 * Do not mark the file dead and let the calling
2021 * function initiate recovery.
2022 */
2040 }
2041 /* fall through */
2051 }
2058 /*
2059 * Check if the path we reopened really is the same
2060 * file. We could end up in a situation where the file
2061 * was removed and a new file created with the same name.
2062 */
2070 /* Oops, we don't have the same file */
2074 else
2084 /*
2085 * We have volatile file handles that don't compare.
2086 * If the fids are the same then we assume that the
2087 * file handle expired but the rnode still refers to
2088 * the same file object.
2089 *
2090 * First check that we have fids or not.
2091 * If we don't we have a dumb server so we will
2092 * just assume every thing is ok for now.
2093 */
2097 /*
2098 * We have fids, but they don't
2099 * compare. So kill the file.
2100 */
2101 failed_msg =
2102 "Couldn't reopen: file handle changed"
2110 /*
2111 * We have volatile file handles that refers
2112 * to the same file (at least they have the
2113 * same fid) or we don't have fids so we
2114 * can't tell. :(. We'll be a kind and accepting
2115 * client so we'll update the rnode's file
2116 * handle with the otw handle.
2117 *
2118 * We need to drop mi->mi_fh_lock since
2119 * sh4_update acquires it. Since there is
2120 * only one recovery thread there is no
2121 * race.
2122 */
2125 }
2126 }
2129 }
2133 /*
2134 * If the server wanted an OPEN_CONFIRM but that fails, just start
2135 * over. Presumably if there is a persistent error it will show up
2136 * when we resend the OPEN.
2137 */
2151 }
2152 }
2157 /*
2158 * Need to reset this bitfield for the possible case where we were
2159 * going to OTW CLOSE the file, got a non-recoverable error, and before
2160 * we could retry the CLOSE, OPENed the file again.
2161 */
2171 /* accept delegation, if any */
2187 kill_file:
2189 failed_reopen:
2196 bailout:
2200 }
2205 }
2207 /* for . and .. OPENs */
2208 /* ARGSUSED */
2209 static int
2211 {
2213 nfs4_ga_res_t gar;
2217 /*
2218 * If close-to-open consistency checking is turned off or
2219 * if there is no cached data, we can avoid
2220 * the over the wire getattr. Otherwise, force a
2221 * call to the server to get fresh attributes and to
2222 * check caches. This is required for close-to-open
2223 * consistency.
2224 */
2232 }
2234 /*
2235 * CLOSE a file
2236 */
2237 /* ARGSUSED */
2238 static int
2241 {
2248 /*
2249 * Remove client state for this (lockowner, file) pair.
2250 * Issue otw v4 call to have the server do the same.
2251 */
2255 /*
2256 * zone_enter(2) prevents processes from changing zones with NFS files
2257 * open; if we happen to get here from the wrong zone we can't do
2258 * anything over the wire.
2259 */
2261 /*
2262 * We could attempt to clean up locks, except we're sure
2263 * that the current process didn't acquire any locks on
2264 * the file: any attempt to lock a file belong to another zone
2265 * will fail, and one can't lock an NFS file and then change
2266 * zones, as that fails too.
2267 *
2268 * Returning an error here is the sane thing to do. A
2269 * subsequent call to VN_RELE() which translates to a
2270 * nfs4_inactive() will clean up state: if the zone of the
2271 * vnode's origin is still alive and kicking, the inactive
2272 * thread will handle the request (from the correct zone), and
2273 * everything (minus the OTW close call) should be OK. If the
2274 * zone is going away nfs4_async_inactive() will throw away
2275 * delegations, open streams and cached pages inline.
2276 */
2278 }
2280 /*
2281 * If we are using local locking for this filesystem, then
2282 * release all of the SYSV style record locks. Otherwise,
2283 * we are doing network locking and we need to release all
2284 * of the network locks. All of the locks held by this
2285 * process on this file are released no matter what the
2286 * incoming reference count is.
2287 */
2303 }
2305 }
2310 /*
2311 * If the file has been `unlinked', then purge the
2312 * DNLC so that this vnode will get reycled quicker
2313 * and the .nfs* file on the server will get removed.
2314 */
2318 /*
2319 * If the file was open for write and there are pages,
2320 * do a synchronous flush and commit of all of the
2321 * dirty and uncommitted pages.
2322 */
2332 /*
2333 * If this file type is one for which no explicit 'open' was
2334 * done, then bail now (ie. no need for protocol 'close'). If
2335 * there was an error w/the vm subsystem, return _that_ error,
2336 * otherwise, return any errors that may've been reported via
2337 * the rnode.
2338 */
2342 /*
2343 * The sync putpage commit may have failed above, but since
2344 * we're working w/a regular file, we need to do the protocol
2345 * 'close' (nfs4close_one will figure out if an otw close is
2346 * needed or not). Report any errors _after_ doing the protocol
2347 * 'close'.
2348 */
2352 /*
2353 * Error reporting prio (Hi -> Lo)
2354 *
2355 * i) nfs4_putpage_commit (error)
2356 * ii) rnode's (r_error)
2357 * iii) nfs4close_one (n4error)
2358 */
2360 }
2362 /*
2363 * Initialize *lost_rqstp.
2364 */
2366 static void
2370 {
2375 }
2381 /*
2382 * The vp is held and rele'd via the recovery code.
2383 * See nfs4_save_lost_rqst.
2384 */
2396 }
2398 /*
2399 * Assumes you already have the open seqid sync grabbed as well as the
2400 * 'os_sync_lock'. Note: this will release the open seqid sync and
2401 * 'os_sync_lock' if client recovery starts. Calling functions have to
2402 * be prepared to handle this.
2403 *
2404 * 'recov' is returned as 1 if the CLOSE operation detected client recovery
2405 * was needed and was started, and that the calling function should retry
2406 * this function; otherwise it is returned as 0.
2407 *
2408 * Errors are returned via the nfs4_error_t parameter.
2409 */
2410 static void
2414 {
2415 COMPOUND4args_clnt args;
2416 COMPOUND4res_clnt res;
2422 seqid4 seqid;
2425 nfs4_lost_rqst_t lost_rqst;
2426 hrtime_t t;
2434 /* Only set this to 1 if recovery is started */
2437 /* do the OTW call to close the file */
2443 else
2453 /* putfh target fh */
2479 }
2483 /*
2484 * if there was an error and no recovery is to be done
2485 * then then set up the file to flush its cache if
2486 * needed for the next caller.
2487 */
2493 }
2496 bool_t abort;
2508 "nfs4close_otw: initiating recovery. error %d "
2511 /*
2512 * Drop the 'os_sync_lock' here so we don't hit
2513 * a potential recursive mutex_enter via an
2514 * 'open_stream_hold()'.
2515 */
2523 /* drop open seq sync, and let the calling function regrab it */
2529 /*
2530 * For signals, the caller wants to quit, so don't say to
2531 * retry. For forced unmount, if it's a user thread, it
2532 * wants to quit. If it's a recovery thread, the retry
2533 * will happen higher-up on the call stack. Either way,
2534 * don't say to retry.
2535 */
2541 else
2547 }
2552 }
2562 /*
2563 * This removes the reference obtained at OPEN; ie, when the
2564 * open stream structure was created.
2565 *
2566 * We don't have to worry about calling 'open_stream_rele'
2567 * since we our currently holding a reference to the open
2568 * stream which means the count cannot go to 0 with this
2569 * decrement.
2570 */
2583 }
2585 /* ARGSUSED */
2586 static int
2589 {
2591 u_offset_t off;
2592 offset_t diff;
2593 uint_t on;
2594 uint_t n;
2595 caddr_t base;
2596 uint_t flags;
2624 else
2630 /*
2631 * Bypass VM if caching has been disabled (e.g., locking) or if
2632 * using client-side direct I/O and the file is not mmap'd and
2633 * there are no cached pages.
2634 */
2642 }
2659 }
2660 }
2669 /*
2670 * Copy data.
2671 */
2676 S_READ);
2679 }
2682 /*
2683 * If read a whole block or read to eof,
2684 * won't need this buffer again soon.
2685 */
2690 else
2697 }
2703 }
2704 }
2708 }
2710 /* ARGSUSED */
2711 static int
2714 {
2717 u_offset_t off;
2718 caddr_t base;
2719 uint_t flags;
2725 u_offset_t offset;
2727 uint_t bsize;
2748 else
2757 /*
2758 * Must serialize if appending.
2759 */
2765 }
2772 }
2782 /*
2783 * Check to make sure that the process will not exceed
2784 * its limit on file size. It is okay to write up to
2785 * the limit, but not beyond. Thus, the write which
2786 * reaches the limit will be short and the next write
2787 * will return an error.
2788 */
2802 }
2803 }
2805 /* update the change attribute, if we have a write delegation */
2816 /*
2817 * Bypass VM if caching has been disabled (e.g., locking) or if
2818 * using client-side direct I/O and the file is not mmap'd and
2819 * there are no cached pages.
2820 */
2826 u_offset_t org_offset;
2827 stable_how4 stab_comm;
2828 nfs4_fwrite:
2833 /*
2834 * A close may have cleared r_error, if so,
2835 * propagate ESTALE error return properly
2836 */
2840 }
2847 else
2862 }
2863 }
2867 }
2881 /*
2882 * A close may have cleared r_error, if so,
2883 * propagate ESTALE error return properly
2884 */
2888 }
2890 /*
2891 * Don't create dirty pages faster than they
2892 * can be cleaned so that the system doesn't
2893 * get imbalanced. If the async queue is
2894 * maxed out, then wait for it to drain before
2895 * creating more dirty pages. Also, wait for
2896 * any threads doing pagewalks in the vop_getattr
2897 * entry points so that they don't block for
2898 * long periods.
2899 */
2915 }
2920 }
2923 /*
2924 * Touch the page and fault it in if it is not in core
2925 * before segmap_getmapflt or vpm_data_copy can lock it.
2926 * This is to avoid the deadlock if the buffer is mapped
2927 * to the same file through mmap which we want to write.
2928 */
2932 /*
2933 * It will use kpm mappings, so no need to
2934 * pass an address.
2935 */
2953 pagecreate);
2959 }
2960 }
2967 /*
2968 * Have written a whole block.
2969 * Start an asynchronous write
2970 * and mark the buffer to
2971 * indicate that it won't be
2972 * needed again soon.
2973 */
2981 }
2986 }
2992 }
2993 /*
2994 * In the event that we got an access error while
2995 * faulting in a page for a write-only file just
2996 * force a write.
2997 */
3000 }
3003 bottom:
3014 }
3016 }
3021 }
3023 /*
3024 * Flags are composed of {B_ASYNC, B_INVAL, B_FREE, B_DONTNEED}
3025 */
3026 static int
3029 {
3033 uchar_t fsdata;
3034 stable_how4 stab_comm;
3040 /*
3041 * pageio_setup should have set b_addr to 0. This
3042 * is correct since we want to do I/O on a page
3043 * boundary. bp_mapin will use this addr to calculate
3044 * an offset, and then set b_addr to the kernel virtual
3045 * address it allocated for us.
3046 */
3059 else
3069 else
3078 }
3080 /*
3081 */
3082 static int
3084 {
3098 /* returns with 'os_sync_lock' held */
3103 }
3110 }
3112 /*
3113 * Determine whether a reopen is needed. If this
3114 * is a delegation open stream, then the os_delegation bit
3115 * should be set.
3116 */
3131 }
3133 }
3137 }
3139 /*
3140 * Write to file. Writes to remote server in largest size
3141 * chunks that the server can handle. Write is synchronous.
3142 */
3143 static int
3146 {
3148 COMPOUND4args_clnt args;
3149 COMPOUND4res_clnt res;
3155 stable_how4 stable;
3158 bool_t needrecov;
3159 nfs4_recov_state_t recov_state;
3160 nfs4_stateid_types_t sid_types;
3177 /* Is curthread the recovery thread? */
3182 recov_retry:
3192 }
3194 /* 0. putfh target fh */
3198 /* 1. write */
3210 }
3216 else
3225 }
3233 }
3237 }
3239 /*
3240 * Do handling of OLD_STATEID outside
3241 * of the normal recovery framework.
3242 *
3243 * If write receives a BAD stateid error while using a
3244 * delegation stateid, retry using the open stateid (if it
3245 * exists). If it doesn't have an open stateid, reopen the
3246 * file first, then retry.
3247 */
3269 }
3273 /* hold needed for nfs4delegreturn_thread */
3279 }
3282 bool_t abort;
3285 "nfs4write: client got error %d, res.status %d"
3295 }
3301 }
3310 }
3325 }
3333 "nfs4write: server %s did not commit "
3340 }
3341 }
3351 tsize;
3353 }
3360 }
3364 }
3375 needrecov);
3378 }
3380 /*
3381 * Read from a file. Reads data in largest chunks our interface can handle.
3382 */
3383 static int
3386 {
3388 COMPOUND4args_clnt args;
3389 COMPOUND4res_clnt res;
3396 bool_t is_eof;
3398 nfs4_recov_state_t recov_state;
3399 nfs4_stateid_types_t sid_types;
3418 recov_retry:
3424 /* putfh target fh */
3428 /* read */
3439 }
3450 else
3463 else
3468 #ifdef DEBUG
3472 }
3473 #endif
3479 }
3486 }
3488 /*
3489 * Do proper retry for OLD and BAD stateid errors outside
3490 * of the normal recovery framework. There are two differences
3491 * between async and sync reads. The first is that we allow
3492 * retry on BAD_STATEID for async reads, but not sync reads.
3493 * The second is that we mark the file dead for a failed
3494 * attempt with a special stateid for sync reads, but just
3495 * return EIO for async reads.
3496 *
3497 * If a sync read receives a BAD stateid error while using a
3498 * delegation stateid, retry using the open stateid (if it
3499 * exists). If it doesn't have an open stateid, reopen the
3500 * file first, then retry.
3501 */
3510 }
3533 }
3536 /* hold needed for nfs4delegreturn_thread */
3542 }
3544 bool_t abort;
3553 /*
3554 * Do not retry if we got OLD_STATEID using a special
3555 * stateid. This avoids looping with a broken server.
3556 */
3562 /*
3563 * Need to retry all possible stateids in
3564 * case the recovery error wasn't stateid
3565 * related or the stateids have become
3566 * stale (server reboot).
3567 */
3572 }
3578 }
3580 }
3588 }
3600 }
3612 }
3614 /* ARGSUSED */
3615 static int
3618 {
3626 }
3627 }
3629 /* ARGSUSED */
3630 int
3633 {
3639 /*
3640 * If it has been specified that the return value will
3641 * just be used as a hint, and we are only being asked
3642 * for size, fsid or rdevid, then return the client's
3643 * notion of these values without checking to make sure
3644 * that the attribute cache is up to date.
3645 * The whole point is to avoid an over the wire GETATTR
3646 * call.
3647 */
3659 }
3660 }
3662 /*
3663 * Only need to flush pages if asking for the mtime
3664 * and if there any dirty pages or any outstanding
3665 * asynchronous (write) requests for this file.
3666 */
3678 error =
3686 }
3690 }
3693 }
3694 }
3695 }
3697 }
3699 int
3701 {
3702 /*
3703 * If these are the only two bits cleared
3704 * on the server then return 0 (OK) else
3705 * return 1 (BAD).
3706 */
3710 else
3712 }
3714 /*ARGSUSED4*/
3715 static int
3718 {
3727 /*
3728 * Don't call secpolicy_vnode_setattr, the client cannot
3729 * use its cached attributes to make security decisions
3730 * as the server may be faking mode bits or mapping uid/gid.
3731 * Always just let the server to the checking.
3732 * If we provide the ability to remove basic priviledges
3733 * to setattr (e.g. basic without chmod) then we will
3734 * need to add a check here before calling the server.
3735 */
3742 }
3744 /*
3745 * To replace the "guarded" version 3 setattr, we use two types of compound
3746 * setattr requests:
3747 * 1. The "normal" setattr, used when the size of the file isn't being
3748 * changed - { Putfh <fh>; Setattr; Getattr }/
3749 * 2. If the size is changed, precede Setattr with: Getattr; Verify
3750 * with only ctime as the argument. If the server ctime differs from
3751 * what is cached on the client, the verify will fail, but we would
3752 * already have the ctime from the preceding getattr, so just set it
3753 * and retry. Thus the compound here is - { Putfh <fh>; Getattr; Verify;
3754 * Setattr; Getattr }.
3755 *
3756 * The vsecattr_t * input parameter will be non-NULL if ACLs are being set in
3757 * this setattr and NULL if they are not.
3758 */
3759 static int
3762 {
3763 COMPOUND4args_clnt args;
3771 vattr_t va;
3775 mode_t omode;
3777 timestruc_t ctime;
3779 nfs4_recov_state_t recov_state;
3780 nfs4_stateid_types_t sid_types;
3781 stateid4 stateid;
3782 hrtime_t t;
3785 bitmap4 supp_attrs;
3791 /*
3792 * Only need to flush pages if there are any pages and
3793 * if the file is marked as dirty in some fashion. The
3794 * file must be flushed so that we can accurately
3795 * determine the size of the file and the cached data
3796 * after the SETATTR returns. A file is considered to
3797 * be dirty if it is either marked with R4DIRTY, has
3798 * outstanding i/o's active, or is mmap'd. In this
3799 * last case, we can't tell whether there are dirty
3800 * pages, so we flush just to be sure.
3801 */
3813 }
3814 }
3817 /*
3818 * Verification setattr compound for non-deleg AT_SIZE:
3819 * { Putfh; Getattr; Verify; Setattr; Getattr }
3820 * Set ctime local here (outside the do_again label)
3821 * so that subsequent retries (after failed VERIFY)
3822 * will use ctime from GETATTR results (from failed
3823 * verify compound) as VERIFY arg.
3824 * If file has delegation, then VERIFY(time_metadata)
3825 * is of little added value, so don't bother.
3826 */
3832 }
3834 }
3840 do_again:
3841 recov_retry:
3852 /* putfh target fh */
3857 /*
3858 * We only care about the ctime, but need to get mtime
3859 * and size for proper cache update.
3860 */
3861 /* getattr */
3866 /* verify - set later in loop */
3868 }
3870 /* setattr */
3880 /* req time field(s) overflow - return immediately */
3885 }
3888 /* getattr */
3891 /*
3892 * If we are setting the ACL (indicated only by vsap != NULL), request
3893 * the ACL in this getattr. The ACL returned from this getattr will be
3894 * used in updating the ACL cache.
3895 */
3898 FATTR4_ACL_MASK;
3901 /*
3902 * setattr iterates if the object size is set and the cached ctime
3903 * does not match the file ctime. In that case, verify the ctime first.
3904 */
3908 /*
3909 * Verify that the ctime match before doing setattr.
3910 */
3920 /* req time field(s) overflow - return */
3922 needrecov);
3924 }
3925 }
3933 /*
3934 * Purge the access cache and ACL cache if changing either the
3935 * owner of the file, the group owner, or the mode. These may
3936 * change the access permissions of the file, so purge old
3937 * information and start over again.
3938 */
3948 }
3949 }
3951 /*
3952 * If res.array_len == numops, then everything succeeded,
3953 * except for possibly the final getattr. If only the
3954 * last getattr failed, give up, and don't try recovery.
3955 */
3958 needrecov);
3962 }
3964 /*
3965 * if either rpc call failed or completely succeeded - done
3966 */
3972 needrecov);
3974 }
3975 }
3977 /*
3978 * Do proper retry for OLD_STATEID outside of the normal
3979 * recovery framework.
3980 */
3985 needrecov);
3992 }
3995 }
3998 bool_t abort;
4004 needrecov);
4005 /*
4006 * Do not retry if we failed with OLD_STATEID using
4007 * a special stateid. This is done to avoid looping
4008 * with a broken server.
4009 */
4017 OP_SETATTR);
4022 }
4028 }
4030 /*
4031 * Need to retry all possible stateids in
4032 * case the recovery error wasn't stateid
4033 * related or the stateids have become
4034 * stale (server reboot).
4035 */
4038 }
4040 }
4042 /*
4043 * Need to call nfs4_end_op before nfs4getattr to
4044 * avoid potential nfs4_start_op deadlock. See RFE
4045 * 4777612. Calls to nfs4_invalidate_pages() and
4046 * nfs4_purge_stale_fh() might also generate over the
4047 * wire calls which my cause nfs4_start_op() deadlock.
4048 */
4051 /*
4052 * Check to update lease.
4053 */
4057 }
4059 /*
4060 * Check if verify failed to see if try again
4061 */
4063 /*
4064 * can't continue...
4065 */
4071 /*
4072 * When the verify request fails, the client ctime is
4073 * not in sync with the server. This is the same as
4074 * the version 3 "not synchronized" error, and we
4075 * handle it in a similar manner (XXX do we need to???).
4076 * Use the ctime returned in the first getattr for
4077 * the input to the next verify.
4078 * If we couldn't get the attributes, then we give up
4079 * because we can't complete the operation as required.
4080 */
4082 }
4087 /*
4088 * retry with a new verify value
4089 */
4093 }
4100 }
4103 }
4107 /*
4108 * If we are here, rfs4call has an irrecoverable error - return
4109 */
4115 }
4119 }
4123 /*
4124 * If changing the size of the file, invalidate
4125 * any local cached data which is no longer part
4126 * of the file. We also possibly invalidate the
4127 * last page in the file. We could use
4128 * pvn_vpzero(), but this would mark the page as
4129 * modified and require it to be written back to
4130 * the server for no particularly good reason.
4131 * This way, if we access it, then we bring it
4132 * back in. A read should be cheaper than a
4133 * write.
4134 */
4137 }
4139 /* either no error or one of the postop getattr failed */
4141 /*
4142 * XXX Perform a simplified version of wcc checking. Instead of
4143 * have another getattr to get pre-op, just purge cache if
4144 * any of the ops prior to and including the getattr failed.
4145 * If the getattr succeeded then update the attrcache accordingly.
4146 */
4150 /*
4151 * Last getattr
4152 */
4155 }
4156 /*
4157 * In certain cases, nfs4_update_attrcache() will purge the attrcache,
4158 * rather than filling it. See the function itself for details.
4159 */
4167 /*
4168 * The ACL was supposed to be set and to be
4169 * returned in the last getattr of this
4170 * compound, but for some reason the getattr
4171 * result doesn't contain the ACL. In this
4172 * case, purge the ACL cache.
4173 */
4181 }
4182 }
4183 }
4184 }
4187 /*
4188 * Set the size, rather than relying on getting it updated
4189 * via a GETATTR. With delegations the client tries to
4190 * suppress GETATTR calls.
4191 */
4195 }
4197 /*
4198 * Can free up request args and res
4199 */
4205 }
4208 /*
4209 * Some servers will change the mode to clear the setuid
4210 * and setgid bits when changing the uid or gid. The
4211 * client needs to compensate appropriately.
4212 */
4224 /*
4225 * We asked the mode to be changed and what
4226 * we just got from the server in getattr is
4227 * not what we wanted it to be, so set it now.
4228 */
4232 /*
4233 * We did not ask the mode to be changed,
4234 * Check to see that the server just cleared
4235 * I_SUID and I_GUID from it. If not then
4236 * set mode to omode with UID/GID cleared.
4237 */
4242 }
4243 }
4247 }
4248 }
4251 }
4253 /* ARGSUSED */
4254 static int
4256 {
4257 COMPOUND4args_clnt args;
4258 COMPOUND4res_clnt res;
4263 nfs4_access_type_t cacc;
4268 nfs4_recov_state_t recov_state;
4270 hrtime_t t;
4286 }
4290 else
4292 }
4298 }
4304 else
4306 ACCESS4_EXECUTE;
4311 /*
4312 * ncr and ncrfree both initially
4313 * point to the memory area returned
4314 * by crnetadjust();
4315 * ncrfree not NULL when exiting means
4316 * that we need to release it
4317 */
4321 tryagain:
4327 }
4329 /*
4330 * If the cred can be adjusted, try again
4331 * with the new cred.
4332 */
4337 }
4341 }
4343 recov_retry:
4344 /*
4345 * Don't take with r_statev4_lock here. r_deleg_type could
4346 * change as soon as lock is released. Since it is an int,
4347 * there is no atomicity issue.
4348 */
4362 }
4364 /* putfh target fh */
4368 /* access */
4372 /* getattr */
4377 }
4401 }
4402 }
4410 /*
4411 * This might generate over the wire calls throught
4412 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
4413 * here to avoid a deadlock.
4414 */
4417 }
4426 }
4430 /*
4431 * we just cached results with cred; if cred is the
4432 * adjusted credentials from crnetadjust, we do not want
4433 * to release them before exiting: hence setting ncrfree
4434 * to NULL
4435 */
4438 /* XXX check the supported bits too? */
4440 /*
4441 * The following code implements the semantic
4442 * that a setuid root program has *at least* the
4443 * permissions of the user that is running the
4444 * program. See rfs3call() for more portions
4445 * of the implementation of this functionality.
4446 */
4447 /* XXX-LP */
4454 }
4456 }
4457 }
4459 out:
4467 }
4469 /* ARGSUSED */
4470 static int
4472 {
4473 COMPOUND4args_clnt args;
4474 COMPOUND4res_clnt res;
4481 uint_t len;
4484 nfs4_recov_state_t recov_state;
4485 hrtime_t t;
4490 /*
4491 * Can't readlink anything other than a symbolic link.
4492 */
4507 }
4509 }
4513 recov_retry:
4521 }
4523 /* 0. putfh symlink fh */
4527 /* 1. readlink */
4530 /* 2. getattr */
4557 needrecov);
4559 }
4560 }
4567 /*
4568 * There is an path in the code below which calls
4569 * nfs4_purge_stale_fh(), which may generate otw calls through
4570 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
4571 * here to avoid nfs4_start_op() deadlock.
4572 */
4575 /*
4576 * either Putfh or Link failed
4577 */
4582 }
4587 /*
4588 * treat symlink names as data
4589 */
4593 /* len includes null byte, which we won't uiomove */
4605 }
4608 }
4609 }
4613 }
4618 /*
4619 * The over the wire error for attempting to readlink something
4620 * other than a symbolic link is ENXIO. However, we need to
4621 * return EINVAL instead of ENXIO, so we map it here.
4622 */
4624 }
4626 /*
4627 * Flush local dirty pages to stable storage on the server.
4628 *
4629 * If FNODSYNC is specified, then there is nothing to do because
4630 * metadata changes are not cached on the client before being
4631 * sent to the server.
4632 */
4633 /* ARGSUSED */
4634 static int
4636 {
4647 }
4649 /*
4650 * Weirdness: if the file was removed or the target of a rename
4651 * operation while it was open, it got renamed instead. Here we
4652 * remove the renamed file.
4653 */
4654 /* ARGSUSED */
4655 void
4657 {
4667 }
4669 /*
4670 * If this is coming from the wrong zone, we let someone in the right
4671 * zone take care of it asynchronously. We can get here due to
4672 * VN_RELE() being called from pageout() or fsflush(). This call may
4673 * potentially turn into an expensive no-op if, for instance, v_count
4674 * gets incremented in the meantime, but it's still correct.
4675 */
4679 }
4681 /*
4682 * Some of the cleanup steps might require over-the-wire
4683 * operations. Since VOP_INACTIVE can get called as a result of
4684 * other over-the-wire operations (e.g., an attribute cache update
4685 * can lead to a DNLC purge), doing those steps now would lead to a
4686 * nested call to the recovery framework, which can deadlock. So
4687 * do any over-the-wire cleanups asynchronously, in a separate
4688 * thread.
4689 */
4701 }
4710 }
4718 }
4724 }
4726 /*
4727 * nfs4_inactive_otw - nfs4_inactive, plus over-the-wire calls to free up
4728 * various bits of state. The caller must not refer to vp after this call.
4729 */
4731 void
4733 {
4735 nfs4_recov_state_t recov_state;
4740 COMPOUND4args_clnt args;
4744 #ifdef DEBUG
4746 #endif
4751 #ifdef DEBUG
4756 #endif
4763 /* Check to see if recovery failed */
4773 }
4778 }
4779 }
4780 }
4782 redo:
4786 }
4788 /*
4789 * Save the vnode pointer for the directory where the
4790 * unlinked-open file got renamed, then set it to NULL
4791 * to prevent another thread from getting here before
4792 * we're done with the remove. While we have the
4793 * statelock, make local copies of the pertinent rnode
4794 * fields. If we weren't to do this in an atomic way, the
4795 * the unl* fields could become inconsistent with respect
4796 * to each other due to a race condition between this
4797 * code and nfs_remove(). See bug report 1034328.
4798 */
4804 }
4814 /*
4815 * If there are any dirty pages left, then flush
4816 * them. This is unfortunate because they just
4817 * may get thrown away during the remove operation,
4818 * but we have to do this for correctness.
4819 */
4829 }
4830 }
4834 recov_retry_remove:
4835 /*
4836 * Do the remove operation on the renamed file
4837 */
4840 /*
4841 * Remove ops: putfh dir; remove
4842 */
4851 /*
4852 * Try again; this time around r_unldvp will be NULL, so we'll
4853 * just call rp4_addfree() and return.
4854 */
4856 }
4858 /* putfh directory */
4862 /* remove */
4870 /*
4871 * Can't do this yet. We may be being called from
4872 * dnlc_purge_XXX while that routine is holding a
4873 * mutex lock to the nc_rele list. The calls to
4874 * nfs3_cache_wcc_data may result in calls to
4875 * dnlc_purge_XXX. This will result in a deadlock.
4876 */
4884 /*
4885 * This code is inactive right now
4886 * but if made active there should
4887 * be a nfs4_end_op() call before
4888 * nfs4_purge_stale_fh to avoid start_op()
4889 * deadlock. See BugId: 4948726
4890 */
4898 /*
4899 * Update directory cache attribute,
4900 * readdir and dnlc caches.
4901 */
4903 }
4904 #else
4908 #endif
4919 }
4920 }
4923 /*
4924 * Release stuff held for the remove
4925 */
4933 }
4935 /*
4936 * Remote file system operations having to do with directory manipulation.
4937 */
4938 /* ARGSUSED3 */
4939 int
4943 {
4951 /*
4952 * if LOOKUP_XATTR, must replace dvp (object) with
4953 * object's attrdir before continuing with lookup
4954 */
4962 /*
4963 * If lookup is for "", just return dvp now. The attrdir
4964 * has already been activated (from nfs4lookup_xattr), and
4965 * the caller will RELE the original dvp -- not
4966 * the attrdir. So, set vpp and return.
4967 * Currently, when the LOOKUP_XATTR flag is
4968 * passed to VOP_LOOKUP, the name is always empty, and
4969 * shortcircuiting here avoids 3 unneeded lock/unlock
4970 * pairs.
4971 *
4972 * If a non-empty name was provided, then it is the
4973 * attribute name, and it will be looked up below.
4974 */
4978 }
4980 /*
4981 * The vfs layer never sends a name when asking for the
4982 * attrdir, so we should never get here (unless of course
4983 * name is passed at some time in future -- at which time
4984 * we'll blow up here).
4985 */
4987 }
4996 /*
4997 * If vnode is a device, create special vnode.
4998 */
5003 }
5006 }
5008 /* ARGSUSED */
5009 static int
5011 {
5027 /*
5028 * If the server doesn't support xattrs just return EINVAL
5029 */
5034 }
5036 /*
5037 * If there is a cached xattr directory entry,
5038 * use it as long as the attributes are valid. If the
5039 * attributes are not valid, take the simple approach and
5040 * free the cached value and re-fetch a new value.
5041 *
5042 * We don't negative entry cache for now, if we did we
5043 * would need to check if the file has changed on every
5044 * lookup. But xattrs don't exist very often and failing
5045 * an openattr is not much more expensive than and NVERIFY or GETATTR
5046 * so do an openattr over the wire for now.
5047 */
5055 }
5058 }
5066 }
5068 static int
5070 {
5076 /*
5077 * If lookup is for "", just return dvp. Don't need
5078 * to send it over the wire, look it up in the dnlc,
5079 * or perform any access checks.
5080 */
5085 }
5087 /*
5088 * Can't do lookups in non-directories.
5089 */
5093 /*
5094 * If lookup is for ".", just return dvp. Don't need
5095 * to send it over the wire or look it up in the dnlc,
5096 * just need to check access.
5097 */
5105 }
5112 }
5115 /*
5116 * Lookup this name in the DNLC. If there is no entry
5117 * lookup over the wire.
5118 */
5122 /*
5123 * We need to go over the wire to lookup the name.
5124 */
5126 }
5128 /*
5129 * We hit on the dnlc
5130 */
5133 /*
5134 * But our attrs may not be valid.
5135 */
5142 }
5144 /*
5145 * If after the purge completes, check to make sure
5146 * our attrs are still valid.
5147 */
5149 /*
5150 * If we waited for a purge we may have
5151 * lost our vnode so look it up again.
5152 */
5159 /*
5160 * The access cache should almost always hit
5161 */
5168 }
5173 }
5175 }
5176 }
5177 }
5181 /*
5182 * We may have gotten here we have one of the following cases:
5183 * 1) vpp != DNLC_NO_VNODE, our attrs have timed out so we
5184 * need to validate them.
5185 * 2) vpp == DNLC_NO_VNODE, a negative entry that we always
5186 * must validate.
5187 *
5188 * Go to the server and check if the directory has changed, if
5189 * it hasn't we are done and can use the dnlc entry.
5190 */
5192 }
5194 /*
5195 * Go to the server and check if the directory has changed, if
5196 * it hasn't we are done and can use the dnlc entry. If it
5197 * has changed we get a new copy of its attributes and check
5198 * the access for VEXEC, then relookup the filename and
5199 * get its filehandle and attributes.
5200 *
5201 * PUTFH dfh NVERIFY GETATTR ACCESS LOOKUP GETFH GETATTR
5202 * if the NVERIFY failed we must
5203 * purge the caches
5204 * cache new attributes (will set r_time_attr_inval)
5205 * cache new access
5206 * recheck VEXEC access
5207 * add name to dnlc, possibly negative
5208 * if LOOKUP succeeded
5209 * cache new attributes
5210 * else
5211 * set a new r_time_attr_inval for dvp
5212 * check to make sure we have access
5213 *
5214 * The vpp returned is the vnode passed in if the directory is valid,
5215 * a new vnode if successful lookup, or NULL on error.
5216 */
5217 static int
5219 {
5220 COMPOUND4args_clnt args;
5221 COMPOUND4res_clnt res;
5223 fattr4_change dchange;
5229 nfs4_recov_state_t recov_state;
5230 hrtime_t t;
5235 nfs4_access_type_t cacc;
5252 /*
5253 * If dvp were a stub, it should have triggered and caused
5254 * a mount for us to get this far.
5255 */
5260 }
5268 /* Save the original mount point security information */
5271 recov_retry:
5279 }
5283 /* PUTFH dfh NVERIFY GETATTR ACCESS LOOKUP GETFH GETATTR */
5287 /* 0. putfh file */
5291 /* 1. nverify the change info */
5300 /* 2. getattr directory */
5305 /* 3. access directory */
5310 /* 4. lookup name */
5316 }
5318 /* 5. resulting file handle */
5321 /* 6. resulting file attributes */
5340 }
5343 /*
5344 * For WRONGSEC of a non-dotdot case, send secinfo directly
5345 * from this thread, do not go thru the recovery thread since
5346 * we need the nm information.
5347 *
5348 * Not doing dotdot case because there is no specification
5349 * for (PUTFH, SECINFO "..") yet.
5350 */
5355 else
5366 }
5376 }
5377 }
5382 /*
5383 * If e.error isn't set, then reply has no ops (or we couldn't
5384 * be here). The only legal way to reply without an op array
5385 * is via NFS4ERR_MINOR_VERS_MISMATCH. An ops array should
5386 * be in the reply for all other status values.
5387 *
5388 * For valid replies without an ops array, return ENOTSUP
5389 * (geterrno4 xlation of VERS_MISMATCH). For illegal replies,
5390 * return EIO -- don't trust status.
5391 */
5400 }
5405 /*
5406 * The NVERIFY "failed" so the directory has changed
5407 * First make sure PUTFH succeeded and NVERIFY "failed"
5408 * cleanly.
5409 */
5416 }
5418 /*
5419 * We know the NVERIFY "failed" so we must:
5420 * purge the caches (access and indirectly dnlc if needed)
5421 */
5429 }
5431 /*
5432 * Install new cached attributes for the directory
5433 */
5444 }
5446 /*
5447 * Now we know the directory is valid,
5448 * cache new directory access
5449 */
5454 /*
5455 * recheck VEXEC access
5456 */
5459 /*
5460 * Directory permissions might have been revoked
5461 */
5467 }
5469 /*
5470 * Somehow we must not have asked for enough
5471 * so try a singleton ACCESS, should never happen.
5472 */
5478 }
5479 }
5483 /*
5484 * The lookup failed, probably no entry
5485 */
5489 /*
5490 * Might be some other error, so remove
5491 * the dnlc entry to make sure we start all
5492 * over again, next time.
5493 */
5495 }
5499 }
5502 /*
5503 * The file exists but we can't get its fh for
5504 * some unknown reason. Remove it from the dnlc
5505 * and error out to be safe.
5506 */
5511 }
5514 /*
5515 * The file exists but a bogus fh
5516 * some unknown reason. Remove it from the dnlc
5517 * and error out to be safe.
5518 */
5524 }
5530 /*
5531 * Make the new rnode
5532 */
5540 }
5541 /*
5542 * XXX if nfs4_make_dotdot uses an existing rnode
5543 * XXX it doesn't update the attributes.
5544 * XXX for now just save them again to save an OTW
5545 */
5550 /*
5551 * If v_type == VNON, then garp was NULL because
5552 * the last op in the compound failed and makenfs4node
5553 * could not find the vnode for sfhp. It created
5554 * a new vnode, so we have nothing to purge here.
5555 */
5557 vattr_t vattr;
5560 /*
5561 * N.B. We've already called nfs4_end_fop above.
5562 */
5570 }
5572 }
5573 }
5587 hrtime_t now;
5592 /*
5593 * Because the NVERIFY "succeeded" we know that the
5594 * directory attributes are still valid
5595 * so update r_time_attr_inval
5596 */
5605 }
5610 /*
5611 * Even though we have a valid directory attr cache
5612 * and dnlc entry, we may not have access.
5613 * This should almost always hit the cache.
5614 */
5619 }
5625 }
5626 }
5628 exit:
5633 }
5635 /*
5636 * We need to go over the wire to lookup the name, but
5637 * while we are there verify the directory has not
5638 * changed but if it has, get new attributes and check access
5639 *
5640 * PUTFH dfh SAVEFH LOOKUP nm GETFH GETATTR RESTOREFH
5641 * NVERIFY GETATTR ACCESS
5642 *
5643 * With the results:
5644 * if the NVERIFY failed we must purge the caches, add new attributes,
5645 * and cache new access.
5646 * set a new r_time_attr_inval
5647 * add name to dnlc, possibly negative
5648 * if LOOKUP succeeded
5649 * cache new attributes
5650 */
5651 static int
5653 {
5654 COMPOUND4args_clnt args;
5655 COMPOUND4res_clnt res;
5657 fattr4_change dchange;
5664 nfs4_recov_state_t recov_state;
5665 hrtime_t t;
5670 nfs4_access_type_t cacc;
5686 /*
5687 * If dvp were a stub, it should have triggered and caused
5688 * a mount for us to get this far.
5689 */
5694 }
5702 /* Save the original mount point security information */
5705 recov_retry:
5711 }
5715 /* PUTFH SAVEFH LOOKUP GETFH GETATTR RESTOREFH NVERIFY GETATTR ACCESS */
5719 /* 0. putfh file */
5723 /* 1. savefh for the nverify */
5726 /* 2. lookup name */
5732 }
5734 /* 3. resulting file handle */
5737 /* 4. resulting file attributes */
5742 /* 5. restorefh back the directory for the nverify */
5745 /* 6. nverify the change info */
5754 /* 7. getattr directory */
5759 /* 8. access directory */
5778 }
5781 /*
5782 * For WRONGSEC of a non-dotdot case, send secinfo directly
5783 * from this thread, do not go thru the recovery thread since
5784 * we need the nm information.
5785 *
5786 * Not doing dotdot case because there is no specification
5787 * for (PUTFH, SECINFO "..") yet.
5788 */
5793 else
5802 }
5812 }
5813 }
5818 /*
5819 * If e.error isn't set, then reply has no ops (or we couldn't
5820 * be here). The only legal way to reply without an op array
5821 * is via NFS4ERR_MINOR_VERS_MISMATCH. An ops array should
5822 * be in the reply for all other status values.
5823 *
5824 * For valid replies without an ops array, return ENOTSUP
5825 * (geterrno4 xlation of VERS_MISMATCH). For illegal replies,
5826 * return EIO -- don't trust status.
5827 */
5835 }
5839 /*
5840 * The PUTFH and SAVEFH may have failed.
5841 */
5846 }
5848 /*
5849 * Check if the file exists, if it does delay entering
5850 * into the dnlc until after we update the directory
5851 * attributes so we don't cause it to get purged immediately.
5852 */
5854 /*
5855 * The lookup failed, probably no entry
5856 */
5860 }
5863 /*
5864 * The file exists but we can't get its fh for
5865 * some unknown reason. Error out to be safe.
5866 */
5868 }
5872 /*
5873 * The file exists but a bogus fh
5874 * some unknown reason. Error out to be safe.
5875 */
5878 }
5884 }
5887 /*
5888 * The RESTOREFH may have failed
5889 */
5894 }
5897 /*
5898 * First make sure the NVERIFY failed as we expected,
5899 * if it didn't then be conservative and error out
5900 * as we can't trust the directory.
5901 */
5906 }
5908 /*
5909 * We know the NVERIFY "failed" so the directory has changed,
5910 * so we must:
5911 * purge the caches (access and indirectly dnlc if needed)
5912 */
5918 }
5928 }
5930 /*
5931 * Now we know the directory is valid,
5932 * cache new directory access
5933 */
5938 /*
5939 * recheck VEXEC access
5940 */
5943 /*
5944 * Directory permissions might have been revoked
5945 */
5950 }
5952 /*
5953 * Somehow we must not have asked for enough
5954 * so try a singleton ACCESS should never happen
5955 */
5960 }
5961 }
5965 hrtime_t now;
5970 /*
5971 * Because the NVERIFY "succeeded" we know that the
5972 * directory attributes are still valid
5973 * so update r_time_attr_inval
5974 */
5983 }
5987 /*
5988 * Even though we have a valid directory attr cache,
5989 * we may not have access.
5990 * This should almost always hit the cache.
5991 */
5996 }
5997 }
5999 /*
6000 * Now we have successfully completed the lookup, if the
6001 * directory has changed we now have the valid attributes.
6002 * We also know we have directory access.
6003 * Create the new rnode and insert it in the dnlc.
6004 */
6010 }
6011 /*
6012 * XXX if nfs4_make_dotdot uses an existing rnode
6013 * XXX it doesn't update the attributes.
6014 * XXX for now just save them again to save an OTW
6015 */
6020 }
6033 exit:
6038 }
6040 #ifdef DEBUG
6041 void
6043 {
6085 }
6086 }
6087 }
6088 #endif
6090 /*
6091 * nfs4lookup_setup - constructs a multi-lookup compound request.
6092 *
6093 * Given the path "nm1/nm2/.../nmn", the following compound requests
6094 * may be created:
6095 *
6096 * Note: Getfh is not be needed because filehandle attr is mandatory, but it
6097 * is faster, for now.
6098 *
6099 * l4_getattrs indicates the type of compound requested.
6100 *
6101 * LKP4_NO_ATTRIBUTE - no attributes (used by secinfo):
6102 *
6103 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Lookup {nmn} }
6104 *
6105 * total number of ops is n + 1.
6106 *
6107 * LKP4_LAST_NAMED_ATTR - multi-component path for a named
6108 * attribute: create lookups plus one OPENATTR/GETFH/GETATTR
6109 * before the last component, and only get attributes
6110 * for the last component. Note that the second-to-last
6111 * pathname component is XATTR_RPATH, which does NOT go
6112 * over-the-wire as a lookup.
6113 *
6114 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Lookup {nmn-2};
6115 * Openattr; Getfh; Getattr; Lookup {nmn}; Getfh; Getattr }
6116 *
6117 * and total number of ops is n + 5.
6118 *
6119 * LKP4_LAST_ATTRDIR - multi-component path for the hidden named
6120 * attribute directory: create lookups plus an OPENATTR
6121 * replacing the last lookup. Note that the last pathname
6122 * component is XATTR_RPATH, which does NOT go over-the-wire
6123 * as a lookup.
6124 *
6125 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Getfh; Getattr;
6126 * Openattr; Getfh; Getattr }
6127 *
6128 * and total number of ops is n + 5.
6129 *
6130 * LKP4_ALL_ATTRIBUTES - create lookups and get attributes for intermediate
6131 * nodes too.
6132 *
6133 * compound { Put*fh; Lookup {nm1}; Getfh; Getattr;
6134 * Lookup {nm2}; ... Lookup {nmn}; Getfh; Getattr }
6135 *
6136 * and total number of ops is 3*n + 1.
6137 *
6138 * All cases: returns the index in the arg array of the final LOOKUP op, or
6139 * -1 if no LOOKUPs were used.
6140 */
6141 int
6143 {
6153 /* set lookuparg response result to 0 */
6156 /* skip leading "/" or "." e.g. ".//./" if there is */
6161 /* ".." is counted as 1 component */
6164 }
6166 /*
6167 * Find n = number of components - nm must be null terminated
6168 * Skip "." components.
6169 */
6176 n++;
6177 }
6178 else
6181 /*
6182 * nga is number of components that need Getfh+Getattr
6183 */
6190 /*
6191 * Always have at least 1 getfh, getattr pair
6192 */
6194 nga++;
6200 }
6202 /*
6203 * If change to use the filehandle attr instead of getfh
6204 * the following line can be deleted.
6205 */
6208 /*
6209 * calculate number of ops in request as
6210 * header + trailer + lookups + getattrs
6211 */
6221 /*
6222 * loop and create a lookup op and possibly getattr/getfh for
6223 * each component. Skip "." components.
6224 */
6226 /*
6227 * Set up a pathname struct for each component if needed
6228 */
6230 s++;
6235 ;
6242 }
6245 /* getfh XXX may not be needed in future */
6247 argop++;
6248 argcnt++;
6250 /* getattr */
6256 argop++;
6257 argcnt++;
6259 /* openattr */
6263 /* openattr */
6265 argop++;
6266 argcnt++;
6268 /* getfh XXX may not be needed in future */
6270 argop++;
6271 argcnt++;
6273 /* getattr */
6279 argop++;
6280 argcnt++;
6284 /* lookupp */
6287 /* lookup */
6291 }
6293 argop++;
6294 argcnt++;
6299 /* getfh XXX may not be needed in future */
6301 argop++;
6302 argcnt++;
6304 /* getattr */
6310 argop++;
6311 argcnt++;
6312 }
6313 }
6318 /* stick in a post-lookup getfh */
6320 argcnt++;
6321 argop++;
6322 }
6323 /* post-lookup getattr */
6328 argcnt++;
6329 }
6334 #ifdef DEBUG
6337 #endif
6340 }
6342 static int
6344 {
6345 COMPOUND4args_clnt args;
6346 COMPOUND4res_clnt res;
6351 hrtime_t t;
6352 nfs4_error_t e;
6358 nfs4_recov_state_t recov_state;
6366 recov_retry:
6367 /* COMPOUND: putfh, openattr, getfh, getattr */
6378 /* putfh */
6382 /* openattr */
6386 /* getfh */
6389 /* getattr */
6404 bool_t abort;
6416 }
6420 }
6425 }
6428 /*
6429 * If OTW errro is NOTSUPP, then it should be
6430 * translated to EINVAL. All Solaris file system
6431 * implementations return EINVAL to the syscall layer
6432 * when the attrdir cannot be created due to an
6433 * implementation restriction or noxattr mount option.
6434 */
6446 }
6451 needrecov);
6453 }
6454 }
6469 }
6492 /*
6493 * Invalidate pathconf4 cache because r_xattr_dir is no longer
6494 * NULL. xattrs could be created at any time, and we have no
6495 * way to update pc4_xattr_exists in the base object if/when
6496 * it happens.
6497 */
6507 }
6509 /* ARGSUSED */
6510 static int
6514 {
6529 }
6531 /* . and .. have special meaning in the protocol, reject them. */
6541 top:
6542 /*
6543 * We make a copy of the attributes because the caller does not
6544 * expect us to change what va points to.
6545 */
6548 /*
6549 * If the pathname is "", then dvp is the root vnode of
6550 * a remote file mounted over a local directory.
6551 * All that needs to be done is access
6552 * checking and truncation. Note that we avoid doing
6553 * open w/ create because the parent directory might
6554 * be in pseudo-fs and the open would fail.
6555 */
6562 /*
6563 * We need to go over the wire, just to be sure whether the
6564 * file exists or not. Using the DNLC can be dangerous in
6565 * this case when making a decision regarding existence.
6566 */
6568 }
6572 else
6575 /*
6576 * error would be set if the file does not exist on the
6577 * server, so lets go create it.
6578 */
6581 }
6583 /*
6584 * File does exist on the server
6585 */
6591 /*
6592 * If vnode is a device, create special vnode.
6593 */
6598 }
6603 /*
6604 * Check here for large file handled
6605 * by LF-unaware process (as
6606 * ufs_create() does)
6607 */
6613 }
6615 /* if error is set then we need to return */
6620 }
6625 NULL);
6627 /*
6628 * we know we have a regular file that already
6629 * exists and we may end up truncating the file
6630 * as a result of the open_otw, so flush out
6631 * any dirty pages for this file first.
6632 */
6645 error;
6648 }
6649 }
6656 }
6657 }
6658 }
6659 }
6671 }
6674 /*
6675 * existing file got truncated, notify.
6676 */
6678 }
6681 }
6684 create_otw:
6689 /*
6690 * If not a regular file let nfs4mknod() handle it.
6691 */
6696 }
6698 /*
6699 * It _is_ a regular file.
6700 */
6705 }
6707 /*
6708 * If this happens to be a mknod of a regular file, then flags will
6709 * have neither FREAD or FWRITE. However, we must set at least one
6710 * for the call to nfs4open_otw. If it's open(O_CREAT) driving
6711 * nfs4_create, then either FREAD, FWRITE, or FRDWR has already been
6712 * set (based on openmode specified by app).
6713 */
6720 /* if create was successful, throw away the file's pages */
6723 cr);
6724 /* release the lookup hold */
6727 }
6729 /*
6730 * validate that we opened a regular file. This handles a misbehaving
6731 * server that returns an incorrect FH.
6732 */
6736 }
6738 /*
6739 * If this is not an exclusive create, then the CREATE
6740 * request will be made with the GUARDED mode set. This
6741 * means that the server will return EEXIST if the file
6742 * exists. The file could exist because of a retransmitted
6743 * request. In this case, we recover by starting over and
6744 * checking to see whether the file exists. This second
6745 * time through it should and a CREATE request will not be
6746 * sent.
6747 *
6748 * This handles the problem of a dangling CREATE request
6749 * which contains attributes which indicate that the file
6750 * should be truncated. This retransmitted request could
6751 * possibly truncate valid data in the file if not caught
6752 * by the duplicate request mechanism on the server or if
6753 * not caught by other means. The scenario is:
6754 *
6755 * Client transmits CREATE request with size = 0
6756 * Client times out, retransmits request.
6757 * Response to the first request arrives from the server
6758 * and the client proceeds on.
6759 * Client writes data to the file.
6760 * The server now processes retransmitted CREATE request
6761 * and truncates file.
6762 *
6763 * The use of the GUARDED CREATE request prevents this from
6764 * happening because the retransmitted CREATE would fail
6765 * with EEXIST and would not truncate the file.
6766 */
6768 #ifdef DEBUG
6769 nfs4_create_misses++;
6770 #endif
6772 }
6777 /*
6778 * existing file got truncated, notify.
6779 */
6785 }
6787 }
6789 /*
6790 * Create compound (for mkdir, mknod, symlink):
6791 * { Putfh <dfh>; Create; Getfh; Getattr }
6792 * It's okay if setattr failed to set gid - this is not considered
6793 * an error, but purge attrs in that case.
6794 */
6795 static int
6798 {
6800 COMPOUND4args_clnt args;
6813 nfs4_recov_state_t recov_state;
6815 hrtime_t t;
6820 bitmap4 supp_attrs;
6827 /*
6828 * Make sure we properly deal with setting the right gid
6829 * on a new directory to reflect the parent's setgid bit
6830 */
6839 /*
6840 * If the parent's directory has the setgid bit set
6841 * _and_ the client was able to get a valid mapping
6842 * for the parent dir's owner_group, we want to
6843 * append NVERIFY(owner_group == dva.va_gid) and
6844 * SETTATTR to the CREATE compound.
6845 */
6852 }
6853 }
6854 }
6855 }
6857 /*
6858 * Create ops:
6859 * 0:putfh(dir) 1:savefh(dir) 2:create 3:getfh(new) 4:getattr(new)
6860 * 5:restorefh(dir) 6:getattr(dir)
6861 *
6862 * if (setgid)
6863 * 0:putfh(dir) 1:create 2:getfh(new) 3:getattr(new)
6864 * 4:savefh(new) 5:putfh(dir) 6:getattr(dir) 7:restorefh(new)
6865 * 8:nverify 9:setattr
6866 */
6875 }
6880 }
6887 recov_retry:
6892 else
6902 }
6906 /* 0: putfh directory */
6910 /* 1/2: Create object */
6915 /*
6916 * symlink, treat name as data
6917 */
6921 }
6926 }
6941 }
6943 /* 2/3: getfh fh of created object */
6947 /* 3/4: getattr of new object */
6953 vattr_t _v;
6966 /*
6967 * nverify
6968 *
6969 * XXX - Revisit the last argument to nfs4_end_op()
6970 * once 5020486 is fixed.
6971 */
6975 supp_attrs)) {
6981 }
6983 /*
6984 * setattr
6985 *
6986 * We _know_ we're not messing with AT_SIZE or AT_XTIME,
6987 * so no need for stateid or flags. Also we specify NULL
6988 * rp since we're only interested in setting owner_group
6989 * attributes.
6990 */
7001 }
7010 }
7023 }
7029 needrecov);
7035 }
7038 }
7039 }
7050 /*
7051 * This check is left over from when create was implemented
7052 * using a setattr op (instead of createattrs). If the
7053 * putfh/create/getfh failed, the error was returned. If
7054 * setattr/getattr failed, we keep going.
7055 *
7056 * It might be better to get rid of the GETFH also, and just
7057 * do PUTFH/CREATE/GETATTR since the FH attr is mandatory.
7058 * Then if any of the operations failed, we could return the
7059 * error now, and remove much of the error code below.
7060 */
7062 /*
7063 * Either Putfh, Create or Getfh failed.
7064 */
7066 /*
7067 * nfs4_purge_stale_fh() may generate otw calls through
7068 * nfs4_invalidate_pages. Hence the need to call
7069 * nfs4_end_op() here to avoid nfs4_start_op() deadlock.
7070 */
7072 needrecov);
7076 }
7077 }
7091 /*
7092 * Need to call nfs4_end_op before nfs4getattr to avoid
7093 * potential nfs4_start_op deadlock. See RFE 4777612.
7094 */
7096 needrecov);
7103 }
7105 }
7112 }
7114 /*
7115 * If compound succeeded, then update dir attrs
7116 */
7125 /* Update directory cache attribute, readdir and dnlc caches */
7128 out:
7136 }
7144 }
7146 /* ARGSUSED */
7147 static int
7150 {
7153 nfs_ftype4 type;
7176 }
7181 }
7183 /*
7184 * This might not be needed any more; special case to deal
7185 * with problematic v2/v3 servers. Since create was unable
7186 * to set group correctly, not sure what hope setattr has.
7187 */
7191 }
7193 /*
7194 * If vnode is a device create special vnode
7195 */
7201 }
7203 }
7205 /*
7206 * Remove requires that the current fh be the target directory.
7207 * After the operation, the current fh is unchanged.
7208 * The compound op structure is:
7209 * PUTFH(targetdir), REMOVE
7210 *
7211 * Weirdness: if the vnode to be removed is open
7212 * we rename it instead of removing it and nfs_inactive
7213 * will remove the new name.
7214 */
7215 /* ARGSUSED */
7216 static int
7218 {
7219 COMPOUND4args_clnt args;
7231 nfs4_recov_state_t recov_state;
7234 dirattr_info_t dinfo;
7246 }
7252 }
7254 /*
7255 * First just remove the entry from the name cache, as it
7256 * is most likely the only entry for this vp.
7257 */
7262 /*
7263 * For regular file types, check to see if the file is open by looking
7264 * at the open streams.
7265 * For all other types, check the reference count on the vnode. Since
7266 * they are not opened OTW they never have an open stream.
7267 *
7268 * If the file is open, rename it to .nfsXXXX.
7269 */
7271 /*
7272 * If the file has a v_count > 1 then there may be more than one
7273 * entry in the name cache due multiple links or an open file,
7274 * but we don't have the real reference count so flush all
7275 * possible entries.
7276 */
7280 /*
7281 * Now we have the real reference count.
7282 */
7288 }
7311 }
7313 }
7317 }
7318 /*
7319 * Actually remove the file/dir
7320 */
7323 /*
7324 * We need to flush any dirty pages which happen to
7325 * be hanging around before removing the file.
7326 * This shouldn't happen very often since in NFSv4
7327 * we should be close to open consistent.
7328 */
7337 }
7338 }
7346 recov_retry:
7347 /*
7348 * Remove ops: putfh dir; remove
7349 */
7359 }
7361 /* putfh directory */
7365 /* remove */
7369 /* getattr dir */
7391 needrecov);
7393 }
7394 }
7396 /*
7397 * Matching nfs4_end_op() for start_op() above.
7398 * There is a path in the code below which calls
7399 * nfs4_purge_stale_fh(), which may generate otw calls through
7400 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
7401 * here to avoid nfs4_start_op() deadlock.
7402 */
7420 /* Update directory attr, readdir and dnlc caches */
7423 }
7424 }
7437 }
7440 }
7442 /*
7443 * Link requires that the current fh be the target directory and the
7444 * saved fh be the source fh. After the operation, the current fh is unchanged.
7445 * Thus the compound op structure is:
7446 * PUTFH(file), SAVEFH, PUTFH(targetdir), LINK, RESTOREFH,
7447 * GETATTR(file)
7448 */
7449 /* ARGSUSED */
7450 static int
7453 {
7454 COMPOUND4args_clnt args;
7465 nfs4_recov_state_t recov_state;
7466 hrtime_t t;
7468 dirattr_info_t dinfo;
7480 }
7487 }
7494 recov_retry:
7499 /*
7500 * Link ops: putfh fl; savefh; putfh tdir; link; getattr(dir);
7501 * restorefh; getattr(fl)
7502 */
7511 }
7513 /* 0. putfh file */
7517 /* 1. save current fh to free up the space for the dir */
7520 /* 2. putfh targetdir */
7524 /* 3. link: current_fh is targetdir, saved_fh is source */
7528 /* 4. Get attributes of dir */
7533 /* 5. If link was successful, restore current vp to file */
7536 /* 6. Get attributes of linked object */
7554 }
7557 bool_t abort;
7563 needrecov);
7576 }
7577 /* fall through for res.status case */
7578 }
7579 }
7585 /* If link succeeded, then don't return error */
7588 /*
7589 * Either Putfh, Savefh, Putfh dir, or Link failed
7590 */
7597 }
7598 /* Remap EISDIR to EPERM for non-root user for SVVS */
7599 /* XXX-LP */
7603 }
7604 }
7606 /* either no error or one of the postop getattr failed */
7608 /*
7609 * XXX - if LINK succeeded, but no attrs were returned for link
7610 * file, purge its cache.
7611 *
7612 * XXX Perform a simplified version of wcc checking. Instead of
7613 * have another getattr to get pre-op, just purge cache if
7614 * any of the ops prior to and including the getattr failed.
7615 * If the getattr succeeded then update the attrcache accordingly.
7616 */
7618 /*
7619 * update cache with link file postattrs.
7620 * Note: at this point resop points to link res.
7621 */
7629 /*
7630 * Call makenfs4node to create the new shadow vp for tnm.
7631 * We pass NULL attrs because we just cached attrs for
7632 * the src object. All we're trying to accomplish is to
7633 * to create the new shadow vnode.
7634 */
7638 /* Update target cache attribute, readdir and dnlc caches */
7652 /*
7653 * Notify the source file of this link operation.
7654 */
7660 }
7661 out:
7669 }
7671 /* ARGSUSED */
7672 static int
7675 {
7684 }
7686 /*
7687 * nfs4rename does the real work of renaming in NFS Version 4.
7688 *
7689 * A file handle is considered volatile for renaming purposes if either
7690 * of the volatile bits are turned on. However, the compound may differ
7691 * based on the likelihood of the filehandle to change during rename.
7692 */
7693 static int
7696 {
7729 }
7736 }
7737 }
7739 /*
7740 * Lookup the target file. If it exists, it needs to be
7741 * checked to see whether it is a mount point and whether
7742 * it is active (open).
7743 */
7749 /*
7750 * If this file has been mounted on, then just
7751 * return busy because renaming to it would remove
7752 * the mounted file system from the name space.
7753 */
7759 }
7761 /*
7762 * First just remove the entry from the name cache, as it
7763 * is most likely the only entry for this vp.
7764 */
7770 /*
7771 * Purge the name cache of all references to this vnode
7772 * so that we can check the reference count to infer
7773 * whether it is active or not.
7774 */
7783 }
7785 /*
7786 * If the vnode is active and is not a directory,
7787 * arrange to rename it to a
7788 * temporary file so that it will continue to be
7789 * accessible. This implements the "unlink-open-file"
7790 * semantics for the target of a rename operation.
7791 * Before doing this though, make sure that the
7792 * source and target files are not already the same.
7793 */
7795 /*
7796 * Lookup the source name.
7797 */
7800 /*
7801 * The source name *should* already exist.
7802 */
7808 }
7812 /*
7813 * Compare the two vnodes. If they are the same,
7814 * just release all held vnodes and return success.
7815 */
7822 }
7824 /*
7825 * Can't mix and match directories and non-
7826 * directories in rename operations. We already
7827 * know that the target is not a directory. If
7828 * the source is a directory, return an error.
7829 */
7836 }
7837 link_call:
7838 /*
7839 * The target file exists, is not the same as
7840 * the source file, and is active. We first
7841 * try to Link it to a temporary filename to
7842 * avoid having the server removing the file
7843 * completely (which could cause data loss to
7844 * the user's POV in the event the Rename fails
7845 * -- see bug 1165874).
7846 */
7847 /*
7848 * The do_link and did_link booleans are
7849 * introduced in the event we get NFS4ERR_FILE_OPEN
7850 * returned for the Rename. Some servers can
7851 * not Rename over an Open file, so they return
7852 * this error. The client needs to Remove the
7853 * newly created Link and do two Renames, just
7854 * as if the server didn't support LINK.
7855 */
7862 }
7869 }
7877 }
7892 }
7894 }
7899 }
7902 /*
7903 * When renaming directories to be a subdirectory of a
7904 * different parent, the dnlc entry for ".." will no
7905 * longer be valid, so it must be removed.
7906 *
7907 * We do a lookup here to determine whether we are renaming
7908 * a directory and we need to check if we are renaming
7909 * an unlinked file. This might have already been done
7910 * in previous code, so we check ovp == NULL to avoid
7911 * doing it twice.
7912 */
7914 /*
7915 * The source name *should* already exist.
7916 */
7922 }
7924 }
7927 }
7929 /*
7930 * Is the object being renamed a dir, and if so, is
7931 * it being renamed to a child of itself? The underlying
7932 * fs should ultimately return EINVAL for this case;
7933 * however, buggy beta non-Solaris NFSv4 servers at
7934 * interop testing events have allowed this behavior,
7935 * and it caused our client to panic due to a recursive
7936 * mutex_enter in fn_move.
7937 *
7938 * The tedious locking in fn_move could be changed to
7939 * deal with this case, and the client could avoid the
7940 * panic; however, the client would just confuse itself
7941 * later and misbehave. A better way to handle the broken
7942 * server is to detect this condition and return EINVAL
7943 * without ever sending the the bogus rename to the server.
7944 * We know the rename is invalid -- just fail it now.
7945 */
7952 }
7954 }
7958 /*
7959 * If FH4_VOL_RENAME or FH4_VOLATILE_ANY bits are set, it is
7960 * possible for the filehandle to change due to the rename.
7961 * If neither of these bits is set, but FH4_VOL_MIGRATION is set,
7962 * the fh will not change because of the rename, but we still need
7963 * to update its rnode entry with the new name for
7964 * an eventual fh change due to migration. The FH4_NOEXPIRE_ON_OPEN
7965 * has no effect on these for now, but for future improvements,
7966 * we might want to use it too to simplify handling of files
7967 * that are open with that flag on. (XXX)
7968 */
7973 else
7983 /*
7984 * Before the 'link_call' code, we did a nfs4_lookup
7985 * that puts a VN_HOLD on nvp. After the nfs4_link
7986 * call we call VN_RELE to match that hold. We need
7987 * to place an additional VN_HOLD here since we will
7988 * be hitting that VN_RELE again.
7989 */
7994 /* Undo the unlinked file naming stuff we just did */
8002 /* rp->r_unlanme points to tmpname */
8006 }
8011 }
8013 }
8021 }
8023 }
8025 /*
8026 * when renaming directories to be a subdirectory of a
8027 * different parent, the dnlc entry for ".." will no
8028 * longer be valid, so it must be removed
8029 */
8036 }
8037 }
8039 /*
8040 * If we are renaming the unlinked file, update the
8041 * r_unldvp and r_unlname as needed.
8042 */
8052 }
8053 }
8054 }
8057 /*
8058 * Notify the rename vnevents to source vnode, and to the target
8059 * vnode if it already existed.
8060 */
8064 /*
8065 * Notify the vnode. Each links is represented by
8066 * a different vnode, in nfsv4.
8067 */
8074 }
8076 /*
8077 * if the source and destination directory are not the
8078 * same notify the destination directory.
8079 */
8086 }
8093 }
8097 }
8104 }
8106 /*
8107 * When the parent directory has changed, sv_dfh must be updated
8108 */
8109 static void
8111 {
8119 }
8121 /*
8122 * nfs4rename_persistent does the otw portion of renaming in NFS Version 4,
8123 * when it is known that the filehandle is persistent through rename.
8124 *
8125 * Rename requires that the current fh be the target directory and the
8126 * saved fh be the source directory. After the operation, the current fh
8127 * is unchanged.
8128 * The compound op structure for persistent fh rename is:
8129 * PUTFH(sourcdir), SAVEFH, PUTFH(targetdir), RENAME
8130 * Rather than bother with the directory postop args, we'll simply
8131 * update that a change occurred in the cache, so no post-op getattrs.
8132 */
8133 static int
8136 {
8137 COMPOUND4args_clnt args;
8146 bool_t needrecov;
8147 nfs4_recov_state_t recov_state;
8156 /*
8157 * Rename ops: putfh sdir; savefh; putfh tdir; rename; getattr tdir
8158 *
8159 * If source/target are different dirs, then append putfh(src); getattr
8160 */
8165 recov_retry:
8168 /* No need to Lookup the file, persistent fh */
8176 }
8178 /* 0: putfh source directory */
8182 /* 1: Save source fh to free up current for target */
8185 /* 2: putfh targetdir */
8189 /* 3: current_fh is targetdir, saved_fh is sourcedir */
8194 /* 4: getattr (targetdir) */
8201 /* 5: putfh (sourcedir) */
8205 /* 6: getattr (sourcedir) */
8209 }
8224 }
8234 }
8235 }
8239 /*
8240 * as long as OP_RENAME
8241 */
8246 /*
8247 * System V defines rename to return EEXIST, not
8248 * ENOTEMPTY if the target directory is not empty.
8249 * Over the wire, the error is NFSERR_ENOTEMPTY
8250 * which geterrno4 maps to ENOTEMPTY.
8251 */
8260 /*
8261 * Update target attribute, readdir and dnlc
8262 * caches.
8263 */
8274 /*
8275 * Update source attribute, readdir and dnlc caches
8276 *
8277 */
8288 }
8291 nnm);
8292 }
8293 }
8301 }
8303 /*
8304 * nfs4rename_volatile_fh does the otw part of renaming in NFS Version 4, when
8305 * it is possible for the filehandle to change due to the rename.
8306 *
8307 * The compound req in this case includes a post-rename lookup and getattr
8308 * to ensure that we have the correct fh and attributes for the object.
8309 *
8310 * Rename requires that the current fh be the target directory and the
8311 * saved fh be the source directory. After the operation, the current fh
8312 * is unchanged.
8313 *
8314 * We need the new filehandle (hence a LOOKUP and GETFH) so that we can
8315 * update the filehandle for the renamed object. We also get the old
8316 * filehandle for historical reasons; this should be taken out sometime.
8317 * This results in a rather cumbersome compound...
8318 *
8319 * PUTFH(sourcdir), SAVEFH, LOOKUP(src), GETFH(old),
8320 * PUTFH(targetdir), RENAME, LOOKUP(trgt), GETFH(new), GETATTR
8321 *
8322 */
8323 static int
8326 {
8327 COMPOUND4args_clnt args;
8339 bool_t needrecov;
8340 nfs4_recov_state_t recov_state;
8341 hrtime_t t;
8350 recov_retry:
8353 /*
8354 * There is a window between the RPC and updating the path and
8355 * filehandle stored in the rnode. Lock out the FHEXPIRED recovery
8356 * code, so that it doesn't try to use the old path during that
8357 * window.
8358 */
8370 }
8373 }
8384 /*
8385 * Rename ops:
8386 * PUTFH(sourcdir), SAVEFH, LOOKUP(src), GETFH(old),
8387 * PUTFH(targetdir), RENAME, GETATTR(targetdir)
8388 * LOOKUP(trgt), GETFH(new), GETATTR,
8389 *
8390 * if (odvp != ndvp)
8391 * add putfh(sourcedir), getattr(sourcedir) }
8392 */
8404 }
8406 /* 0: putfh source directory */
8410 /* 1: Save source fh to free up current for target */
8413 /* 2: Lookup pre-rename fh of renamed object */
8417 /* 3: getfh fh of renamed object (before rename) */
8420 /* 4: putfh targetdir */
8424 /* 5: current_fh is targetdir, saved_fh is sourcedir */
8429 /* 6: getattr of target dir (post op attrs) */
8434 /* 7: Lookup post-rename fh of renamed object */
8438 /* 8: getfh fh of renamed object (after rename) */
8441 /* 9: getattr of renamed object */
8446 /*
8447 * If source/target dirs are different, then get new post-op
8448 * attrs for source dir also.
8449 */
8451 /* 10: putfh (sourcedir) */
8455 /* 11: getattr (sourcedir) */
8459 }
8476 }
8479 }
8482 bool_t abort;
8503 }
8504 /* fall through for res.status case */
8505 }
8506 }
8509 /*
8510 * If OP_RENAME (or any prev op) failed, then return an error.
8511 * OP_RENAME is index 5, so if array len <= 6 we return an error.
8512 */
8514 /*
8515 * Error in an op other than last Getattr
8516 */
8520 /*
8521 * System V defines rename to return EEXIST, not
8522 * ENOTEMPTY if the target directory is not empty.
8523 * Over the wire, the error is NFSERR_ENOTEMPTY
8524 * which geterrno4 maps to ENOTEMPTY.
8525 */
8529 needrecov);
8531 }
8533 /* rename results */
8537 /* Update target attribute, readdir and dnlc caches */
8545 /* Update source cache attribute, readdir and dnlc caches */
8548 /* Update source cache attribute, readdir and dnlc caches */
8552 /*
8553 * If dinfop is non-NULL, then compound succeded, so
8554 * set di_garp to attrs for source dir. dinfop is only
8555 * set to NULL when compound fails.
8556 */
8561 dinfop);
8562 }
8564 /*
8565 * Update the rnode with the new component name and args,
8566 * and if the file handle changed, also update it with the new fh.
8567 * This is only necessary if the target object has an rnode
8568 * entry and there is no need to create one for it.
8569 */
8573 /*
8574 * Update the path and filehandle for the renamed object.
8575 */
8585 }
8587 out:
8597 }
8599 /* ARGSUSED */
8600 static int
8603 {
8609 /*
8610 * As ".." has special meaning and rather than send a mkdir
8611 * over the wire to just let the server freak out, we just
8612 * short circuit it here and return EEXIST
8613 */
8617 /*
8618 * Decision to get the right gid and setgid bit of the
8619 * new directory is now made in call_nfs4_create_req.
8620 */
8628 }
8631 /*
8632 * rmdir is using the same remove v4 op as does remove.
8633 * Remove requires that the current fh be the target directory.
8634 * After the operation, the current fh is unchanged.
8635 * The compound op structure is:
8636 * PUTFH(targetdir), REMOVE
8637 */
8638 /*ARGSUSED4*/
8639 static int
8642 {
8644 COMPOUND4args_clnt args;
8654 nfs4_recov_state_t recov_state;
8660 /*
8661 * As ".." has special meaning and rather than send a rmdir
8662 * over the wire to just let the server freak out, we just
8663 * short circuit it here and return EEXIST
8664 */
8672 /*
8673 * Attempt to prevent a rmdir(".") from succeeding.
8674 */
8679 }
8684 }
8686 /*
8687 * Since nfsv4 remove op works on both files and directories,
8688 * check that the removed object is indeed a directory.
8689 */
8694 }
8696 /*
8697 * First just remove the entry from the name cache, as it
8698 * is most likely an entry for this vp.
8699 */
8702 /*
8703 * If there vnode reference count is greater than one, then
8704 * there may be additional references in the DNLC which will
8705 * need to be purged. First, trying removing the entry for
8706 * the parent directory and see if that removes the additional
8707 * reference(s). If that doesn't do it, then use dnlc_purge_vp
8708 * to completely remove any references to the directory which
8709 * might still exist in the DNLC.
8710 */
8715 }
8721 recov_retry:
8724 /*
8725 * Rmdir ops: putfh dir; remove
8726 */
8734 }
8737 /* putfh directory */
8741 /* remove */
8745 /* getattr (postop attrs for dir that contained removed dir) */
8759 }
8769 needrecov);
8772 }
8773 }
8778 /*
8779 * Only return error if first 2 ops (OP_REMOVE or earlier)
8780 * failed.
8781 */
8789 /*
8790 * System V defines rmdir to return EEXIST, not
8791 * ENOTEMPTY if the directory is not empty. Over
8792 * the wire, the error is NFSERR_ENOTEMPTY which
8793 * geterrno4 maps to ENOTEMPTY.
8794 */
8810 /* Update dir attribute, readdir and dnlc caches */
8812 dinfop);
8814 /* destroy rddir cache for dir that was removed */
8817 }
8818 }
8836 }
8841 }
8843 /* ARGSUSED */
8844 static int
8847 {
8880 }
8881 }
8882 }
8886 }
8889 /*
8890 * Read directory entries.
8891 * There are some weird things to look out for here. The uio_loffset
8892 * field is either 0 or it is the offset returned from a previous
8893 * readdir. It is an opaque value used by the server to find the
8894 * correct directory block to read. The count field is the number
8895 * of blocks to read on the server. This is advisory only, the server
8896 * may return only one block's worth of entries. Entries may be compressed
8897 * on the server.
8898 */
8899 /* ARGSUSED */
8900 static int
8903 {
8905 uint_t count;
8916 /*
8917 * Make sure that the directory cache is valid.
8918 */
8921 /*
8922 * Setting nfs_disable_rddir_cache in /etc/system
8923 * allows interoperability with servers that do not
8924 * properly update the attributes of directories.
8925 * Any cached information gets purged before an
8926 * access is made to it.
8927 */
8929 }
8934 }
8938 /*
8939 * Short circuit last readdir which always returns 0 bytes.
8940 * This can be done after the directory has been read through
8941 * completely at least once. This will set r_direof which
8942 * can be used to find the value of the last cookie.
8943 */
8948 #ifdef DEBUG
8949 nfs4_readdir_cache_shorts++;
8950 #endif
8954 }
8956 /*
8957 * Look for a cache entry. Cache entries are identified
8958 * by the NFS cookie value and the byte count requested.
8959 */
8962 /*
8963 * If rdc is NULL then the lookup resulted in an unrecoverable error.
8964 */
8968 }
8970 /*
8971 * Check to see if we need to fill this entry in.
8972 */
8978 /*
8979 * Do the readdir.
8980 */
8983 /*
8984 * Reacquire the lock, so that we can continue
8985 */
8987 /*
8988 * The entry is now complete
8989 */
8991 }
8995 /*
8996 * If an error occurred while attempting
8997 * to fill the cache entry, mark the entry invalid and
8998 * just return the error.
8999 */
9006 }
9008 /*
9009 * The cache entry is complete and good,
9010 * copyout the dirent structs to the calling
9011 * thread.
9012 */
9015 /*
9016 * If no error occurred during the copyout,
9017 * update the offset in the uio struct to
9018 * contain the value of the next NFS 4 cookie
9019 * and set the eof value appropriately.
9020 */
9025 }
9027 /*
9028 * Decide whether to do readahead. Don't if we
9029 * have already read to the end of directory.
9030 */
9032 /*
9033 * Make the entry the direof only if it is cached
9034 */
9040 }
9042 /* Determine if a readdir readahead should be done */
9047 }
9049 /*
9050 * Now look for a readahead entry.
9051 *
9052 * Check to see whether we found an entry for the readahead.
9053 * If so, we don't need to do anything further, so free the new
9054 * entry if one was allocated. Otherwise, allocate a new entry, add
9055 * it to the cache, and then initiate an asynchronous readdir
9056 * operation to fill it.
9057 */
9060 /*
9061 * A readdir cache entry could not be obtained for the readahead. In
9062 * this case we skip the readahead and return.
9063 */
9068 }
9070 /*
9071 * Check to see if we need to fill this entry in.
9072 */
9078 #ifdef DEBUG
9079 nfs4_readdir_readahead++;
9080 #endif
9081 /*
9082 * Do the readdir.
9083 */
9086 }
9092 }
9094 static int
9096 {
9104 /*
9105 * Obtain the readdir results for the caller.
9106 */
9110 /*
9111 * The entry is now complete
9112 */
9122 }
9124 /*
9125 * Read directory entries.
9126 * There are some weird things to look out for here. The uio_loffset
9127 * field is either 0 or it is the offset returned from a previous
9128 * readdir. It is an opaque value used by the server to find the
9129 * correct directory block to read. The count field is the number
9130 * of blocks to read on the server. This is advisory only, the server
9131 * may return only one block's worth of entries. Entries may be compressed
9132 * on the server.
9133 *
9134 * Generates the following compound request:
9135 * 1. If readdir offset is zero and no dnlc entry for parent exists,
9136 * must include a Lookupp as well. In this case, send:
9137 * { Putfh <fh>; Readdir; Lookupp; Getfh; Getattr }
9138 * 2. Otherwise just do: { Putfh <fh>; Readdir }
9139 *
9140 * Get complete attributes and filehandles for entries if this is the
9141 * first read of the directory. Otherwise, just get fileid's.
9142 */
9143 static void
9145 {
9146 COMPOUND4args_clnt args;
9147 COMPOUND4res_clnt res;
9150 bitmap4 rd_bitsval;
9161 nfs4_recov_state_t recov_state;
9162 hrtime_t t;
9169 /*
9170 * If rp were a stub, it should have triggered and caused
9171 * a mount for us to get this far.
9172 */
9177 /*
9178 * Since nfsv4 readdir may not return entries for "." and "..",
9179 * the client must recreate them:
9180 * To find the correct nodeid, do the following:
9181 * For current node, get nodeid from dnlc.
9182 * - if current node is rootvp, set pnodeid to nodeid.
9183 * - else if parent is in the dnlc, get its nodeid from there.
9184 * - else add LOOKUPP+GETATTR to compound.
9185 */
9192 /* parent in dnlc cache - no need for otw */
9195 /*
9196 * parent not in dnlc cache,
9197 * do lookupp to get its id
9198 */
9201 }
9204 }
9205 }
9209 /* Save the original mount point security flavor */
9212 recov_retry:
9220 /*
9221 * If readdir a node that is a stub for a crossed mount point,
9222 * keep the original secinfo flavor for the current file
9223 * system, not the crossed one.
9224 */
9228 }
9230 /*
9231 * Determine which attrs to request for dirents. This code
9232 * must be protected by nfs4_start/end_fop because of r_server
9233 * (which will change during failover recovery).
9234 *
9235 */
9237 /*
9238 * Get all vattr attrs plus filehandle and rdattr_error
9239 */
9241 FATTR4_RDATTR_ERROR_MASK |
9242 FATTR4_FILEHANDLE_MASK;
9248 }
9252 /*
9253 * Already read directory. Use readdir with
9254 * no attrs (except for mounted_on_fileid) for updates.
9255 */
9258 /*
9259 * request mounted on fileid if supported, else request
9260 * fileid. maybe we should verify that fileid is supported
9261 * and request something else if not.
9262 */
9267 }
9269 /* putfh directory fh */
9275 /*
9276 * 1 and 2 are reserved for client "." and ".." entry offset.
9277 * cookie 0 should be used over-the-wire to start reading at
9278 * the beginning of the directory excluding "." and "..".
9279 */
9290 }
9300 /*
9301 * If count < than the minimum required, we return no entries
9302 * and fail with EINVAL
9303 */
9307 }
9310 /*
9311 * Add lookupp and getattr for parent nodeid.
9312 */
9317 /* getattr parent */
9321 }
9329 }
9331 /* capture the time of this call */
9340 }
9344 /*
9345 * If RPC error occurred and it isn't an error that
9346 * triggers recovery, then go ahead and fail now.
9347 */
9351 }
9354 bool_t abort;
9370 }
9372 }
9377 }
9379 /* fall through for res.status case */
9380 }
9384 /*
9385 * If compound failed first 2 ops (PUTFH+READDIR), then return
9386 * failure here. Subsequent ops are for filling out dot-dot
9387 * dirent, and if they fail, we still want to give the caller
9388 * the dirents returned by (the successful) READDIR op, so we need
9389 * to silently ignore failure for subsequent ops (LOOKUPP+GETATTR).
9390 *
9391 * One example where PUTFH+READDIR ops would succeed but
9392 * LOOKUPP+GETATTR would fail would be a dir that has r perm
9393 * but lacks x. In this case, a POSIX server's VOP_READDIR
9394 * would succeed; however, VOP_LOOKUP(..) would fail since no
9395 * x perm. We need to come up with a non-vendor-specific way
9396 * for a POSIX server to return d_ino from dotdot's dirent if
9397 * client only requests mounted_on_fileid, and just say the
9398 * LOOKUPP succeeded and fill out the GETATTR. However, if
9399 * client requested any mandatory attrs, server would be required
9400 * to fail the GETATTR op because it can't call VOP_LOOKUP+VOP_GETATTR
9401 * for dotdot.
9402 */
9415 }
9416 /*
9417 * If readdir a node that is a stub for a
9418 * crossed mount point, keep the original
9419 * secinfo flavor for the current file system,
9420 * not the crossed one.
9421 */
9424 }
9425 }
9434 /*
9435 * For "." and ".." entries
9436 * e.g.
9437 * seek(cookie=0) -> "." entry with d_off = 1
9438 * seek(cookie=1) -> ".." entry with d_off = 2
9439 */
9445 }
9449 }
9452 /* LOOKUPP+GETATTR attemped */
9466 /*
9467 * First, take care of finishing the
9468 * readdir results.
9469 */
9471 /*
9472 * The d_ino of .. must be the inode number
9473 * of the mounted filesystem.
9474 */
9480 /*
9481 * Next, create the ".." dnlc entry
9482 */
9487 }
9489 }
9490 }
9497 }
9501 out:
9502 /*
9503 * If readdir a node that is a stub for a crossed mount point,
9504 * keep the original secinfo flavor for the current file system,
9505 * not the crossed one.
9506 */
9510 }
9513 static int
9515 {
9520 offset_t offset;
9531 read_again:
9532 /*
9533 * Releases the osp, if it is provided.
9534 * Puts a hold on the cred_otw and the new osp (if found).
9535 */
9544 /*
9545 * Didn't get it all because we hit EOF,
9546 * zero all the memory beyond the EOF.
9547 */
9548 /* bzero(rdaddr + */
9551 }
9555 /*
9556 * We didn't read anything at all as we are
9557 * past EOF. Return an error indicator back
9558 * but don't destroy the pages (yet).
9559 */
9561 }
9565 }
9568 write_again:
9569 /*
9570 * Releases the osp, if it is provided.
9571 * Puts a hold on the cred_otw and the new
9572 * osp (if found).
9573 */
9581 #ifdef DEBUG
9587 offset);
9595 }
9596 #endif
9602 }
9606 /*
9607 * Don't print EDQUOT errors on the console.
9608 * Don't print asynchronous EACCES errors.
9609 * Don't print EFBIG errors.
9610 * Print all other write errors.
9611 */
9617 /*
9618 * Update r_error and r_flags as appropriate.
9619 * If the error was ESTALE, then mark the
9620 * rnode as not being writeable and save
9621 * the error status. Otherwise, save any
9622 * errors which occur from asynchronous
9623 * page invalidations. Any errors occurring
9624 * from other operations should be saved
9625 * by the caller.
9626 */
9637 }
9639 }
9643 /*
9644 * A close may have cleared r_error, if so,
9645 * propagate ESTALE error return properly
9646 */
9649 }
9650 }
9661 }
9663 /* ARGSUSED */
9664 int
9666 {
9668 }
9670 /* ARGSUSED2 */
9671 int
9673 {
9679 }
9687 }
9691 }
9693 /* ARGSUSED */
9694 void
9696 {
9700 }
9702 /* ARGSUSED */
9703 static int
9705 {
9709 /*
9710 * Because we stuff the readdir cookie into the offset field
9711 * someone may attempt to do an lseek with the cookie which
9712 * we want to succeed.
9713 */
9719 }
9722 /*
9723 * Return all the pages from [off..off+len) in file
9724 */
9725 /* ARGSUSED */
9726 static int
9730 {
9747 /*
9748 * Now validate that the caches are up to date.
9749 */
9754 retry:
9757 /*
9758 * Don't create dirty pages faster than they
9759 * can be cleaned so that the system doesn't
9760 * get imbalanced. If the async queue is
9761 * maxed out, then wait for it to drain before
9762 * creating more dirty pages. Also, wait for
9763 * any threads doing pagewalks in the vop_getattr
9764 * entry points so that they don't block for
9765 * long periods.
9766 */
9772 }
9774 /*
9775 * If we are getting called as a side effect of an nfs_write()
9776 * operation the local file size might not be extended yet.
9777 * In this case we want to be able to return pages of zeroes.
9778 */
9786 }
9802 }
9805 }
9807 /*
9808 * Called from pvn_getpages to get a particular page.
9809 */
9810 /* ARGSUSED */
9811 static int
9815 {
9817 uint_t bsize;
9820 u_offset_t lbn;
9821 u_offset_t io_off;
9822 u_offset_t blkoff;
9823 u_offset_t rablkoff;
9825 uint_t blksize;
9840 reread:
9852 /*
9853 * Queueing up the readahead before doing the synchronous read
9854 * results in a significant increase in read throughput because
9855 * of the increased parallelism between the async threads and
9856 * the process context.
9857 */
9863 /*
9864 * Calculate the number of readaheads to do.
9865 * a) No readaheads at offset = 0.
9866 * b) Do maximum(nfs4_nra) readaheads when the readahead
9867 * window is closed.
9868 * c) Do readaheads between 1 to (nfs4_nra - 1) depending
9869 * upon how far the readahead window is open or close.
9870 * d) No readaheads if rp->r_nextr is not within the scope
9871 * of the readahead window (random i/o).
9872 */
9882 else
9893 }
9894 readahead--;
9896 /*
9897 * Indicate that we did a readahead so
9898 * readahead offset is not updated
9899 * by the synchronous read below.
9900 */
9903 /*
9904 * set readahead offset to
9905 * offset of last async readahead
9906 * request.
9907 */
9909 }
9911 }
9913 again:
9917 nfs4_readahead);
9919 /*
9920 * Block for this page is not allocated, or the offset
9921 * is beyond the current allocation size, or we're
9922 * allocating a swap slot and the page was not found,
9923 * so allocate it and return a zero page.
9924 */
9933 /*
9934 * Need to go to server to get a block
9935 */
9939 /*
9940 * If less than a block left in
9941 * file read less than a block.
9942 */
9944 /*
9945 * Trying to access beyond EOF,
9946 * set up to get at least one page.
9947 */
9962 /*
9963 * Some other thread has entered the page,
9964 * so just use it.
9965 */
9969 /*
9970 * Now round the request size up to page boundaries.
9971 * This ensures that the entire page will be
9972 * initialized to zeroes if EOF is encountered.
9973 */
9979 /*
9980 * pageio_setup should have set b_addr to 0. This
9981 * is correct since we want to do I/O on a page
9982 * boundary. bp_mapin will use this addr to calculate
9983 * an offset, and then set b_addr to the kernel virtual
9984 * address it allocated for us.
9985 */
9995 /*
9996 * If doing a write beyond what we believe is EOF,
9997 * don't bother trying to read the pages from the
9998 * server, we'll just zero the pages here. We
9999 * don't check that the rw flag is S_WRITE here
10000 * because some implementations may attempt a
10001 * read access to the buffer before copying data.
10002 */
10010 }
10012 /*
10013 * Unmap the buffer before freeing it.
10014 */
10024 /*
10025 * If doing a write system call just return
10026 * zeroed pages, else user tried to get pages
10027 * beyond EOF, return error. We don't check
10028 * that the rw flag is S_WRITE here because
10029 * some implementations may attempt a read
10030 * access to the buffer before copying data.
10031 */
10034 else
10036 }
10042 }
10043 }
10044 }
10046 out:
10054 }
10059 /*
10060 * Page exists in the cache, acquire the appropriate lock.
10061 * If this fails, start all over again.
10062 */
10064 #ifdef DEBUG
10065 nfs4_lostpage++;
10066 #endif
10068 }
10072 }
10078 }
10080 static void
10083 {
10086 u_offset_t io_off;
10099 /*
10100 * If less than a block left in file read less
10101 * than a block.
10102 */
10110 /*
10111 * The isra flag passed to the kluster function is 1, we may have
10112 * gotten a return value of NULL for a variety of reasons (# of free
10113 * pages < minfree, someone entered the page on the vnode etc). In all
10114 * cases, we want to punt on the readahead.
10115 */
10119 /*
10120 * Now round the request size up to page boundaries.
10121 * This ensures that the entire page will be
10122 * initialized to zeroes if EOF is encountered.
10123 */
10129 /*
10130 * pageio_setup should have set b_addr to 0. This is correct since
10131 * we want to do I/O on a page boundary. bp_mapin() will use this addr
10132 * to calculate an offset, and then set b_addr to the kernel virtual
10133 * address it allocated for us.
10134 */
10144 /*
10145 * If doing a write beyond what we believe is EOF, don't bother trying
10146 * to read the pages from the server, we'll just zero the pages here.
10147 * We don't check that the rw flag is S_WRITE here because some
10148 * implementations may attempt a read access to the buffer before
10149 * copying data.
10150 */
10161 }
10163 /*
10164 * Unmap the buffer before freeing it.
10165 */
10176 /*
10177 * In case of error set readahead offset
10178 * to the lowest offset.
10179 * pvn_read_done() calls VN_DISPOSE to destroy the pages
10180 */
10186 }
10187 }
10189 /*
10190 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
10191 * If len == 0, do from off to EOF.
10192 *
10193 * The normal cases should be len == 0 && off == 0 (entire vp list) or
10194 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
10195 * (from pageout).
10196 */
10197 /* ARGSUSED */
10198 static int
10201 {
10214 /*
10215 * XXX - Why should this check be made here?
10216 */
10234 }
10236 /*
10237 * Write out a single page, possibly klustering adjacent dirty pages.
10238 */
10239 int
10242 {
10243 u_offset_t io_off;
10244 u_offset_t lbn_off;
10245 u_offset_t lbn;
10247 uint_t bsize;
10264 /*
10265 * Find a kluster that fits in one block, or in
10266 * one page if pages are bigger than blocks. If
10267 * there is less file space allocated than a whole
10268 * page, we'll shorten the i/o request below.
10269 */
10273 /*
10274 * pvn_write_kluster shouldn't have returned a page with offset
10275 * behind the original page we were given. Verify that.
10276 */
10279 /*
10280 * Now pp will have the list of kept dirty pages marked for
10281 * write back. It will also handle invalidation and freeing
10282 * of pages that are not dirty. Check for page length rounding
10283 * problems.
10284 */
10288 }
10289 /*
10290 * The R4MODINPROGRESS flag makes sure that nfs4_bio() sees a
10291 * consistent value of r_size. R4MODINPROGRESS is set in writerp4().
10292 * When R4MODINPROGRESS is set it indicates that a uiomove() is in
10293 * progress and the r_size has not been made consistent with the
10294 * new size of the file. When the uiomove() completes the r_size is
10295 * updated and the R4MODINPROGRESS flag is cleared.
10296 *
10297 * The R4MODINPROGRESS flag makes sure that nfs4_bio() sees a
10298 * consistent value of r_size. Without this handshaking, it is
10299 * possible that nfs4_bio() picks up the old value of r_size
10300 * before the uiomove() in writerp4() completes. This will result
10301 * in the write through nfs4_bio() being dropped.
10302 *
10303 * More precisely, there is a window between the time the uiomove()
10304 * completes and the time the r_size is updated. If a VOP_PUTPAGE()
10305 * operation intervenes in this window, the page will be picked up,
10306 * because it is dirty (it will be unlocked, unless it was
10307 * pagecreate'd). When the page is picked up as dirty, the dirty
10308 * bit is reset (pvn_getdirty()). In nfs4write(), r_size is
10309 * checked. This will still be the old size. Therefore the page will
10310 * not be written out. When segmap_release() calls VOP_PUTPAGE(),
10311 * the page will be found to be clean and the write will be dropped.
10312 */
10319 /*
10320 * A write is in progress for this region of the file.
10321 * If we did not detect R4MODINPROGRESS here then this
10322 * path through nfs_putapage() would eventually go to
10323 * nfs4_bio() and may not write out all of the data
10324 * in the pages. We end up losing data. So we decide
10325 * to set the modified bit on each page in the page
10326 * list and mark the rnode with R4DIRTY. This write
10327 * will be restarted at some later time.
10328 */
10336 }
10344 }
10346 }
10350 nfs4_sync_putapage);
10359 }
10361 static int
10364 {
10383 }
10386 /*
10387 * If this was not an async thread, then try again to
10388 * write out the pages, but this time, also destroy
10389 * them whether or not the write is successful. This
10390 * will prevent memory from filling up with these
10391 * pages and destroying them is the only alternative
10392 * if they can't be written out.
10393 *
10394 * Don't do this if this is an async thread because
10395 * when the pages are unlocked in pvn_write_done,
10396 * some other thread could have come along, locked
10397 * them, and queued for an async thread. It would be
10398 * possible for all of the async threads to be tied
10399 * up waiting to lock the pages again and they would
10400 * all already be locked and waiting for an async
10401 * thread to handle them. Deadlock.
10402 */
10406 }
10414 }
10418 NFS4_WRITE_NOWAIT);
10419 }
10422 }
10424 #ifdef DEBUG
10426 #endif
10428 /* ARGSUSED */
10429 static int
10433 {
10451 /*
10452 * If the file is delegated to the client don't do anything.
10453 * If the file is not delegated, then validate the data cache.
10454 */
10463 }
10465 /*
10466 * Check to see if the vnode is currently marked as not cachable.
10467 * This means portions of the file are locked (through VOP_FRLOCK).
10468 * In this case the map request must be refused. We use
10469 * rp->r_lkserlock to avoid a race with concurrent lock requests.
10470 *
10471 * Atomically increment r_inmap after acquiring r_rwlock. The
10472 * idea here is to acquire r_rwlock to block read/write and
10473 * not to protect r_inmap. r_inmap will inform nfs4_read/write()
10474 * that we are in nfs4_map(). Now, r_rwlock is acquired in order
10475 * and we can prevent the deadlock that would have occurred
10476 * when nfs4_addmap() would have acquired it out of order.
10477 *
10478 * Since we are not protecting r_inmap by any lock, we do not
10479 * hold any lock when we decrement it. We atomically decrement
10480 * r_inmap after we release r_lkserlock.
10481 */
10491 }
10497 }
10499 /*
10500 * Don't allow concurrent locks and mapping if mandatory locking is
10501 * enabled.
10502 */
10512 }
10513 }
10515 /*
10516 * It is possible that the rnode has a lost lock request that we
10517 * are still trying to recover, and that the request conflicts with
10518 * this map request.
10519 *
10520 * An alternative approach would be for nfs4_safemap() to consider
10521 * queued lock requests when deciding whether to set or clear
10522 * VNOCACHE. This would require the frlock code path to call
10523 * nfs4_safemap() after enqueing a lost request.
10524 */
10528 }
10535 }
10538 /*
10539 * We need to retrieve the open stream
10540 */
10546 /* returns with 'os_sync_lock' held */
10549 }
10551 #ifdef DEBUG
10555 }
10556 #endif
10557 /* returns with 'os_sync_lock' held */
10561 "nfs4_map: we tried to OPEN the file "
10564 }
10565 }
10571 "nfs4_map: os_failed_reopen set on "
10576 }
10579 }
10595 done:
10599 }
10601 /*
10602 * We're most likely dealing with a kernel module that likes to READ
10603 * and mmap without OPENing the file (ie: lookup/read/mmap), so lets
10604 * officially OPEN the file to create the necessary client state
10605 * for bookkeeping of os_mmap_read/write counts.
10606 *
10607 * Since VOP_MAP only passes in a pointer to the vnode rather than
10608 * a double pointer, we can't handle the case where nfs4open_otw()
10609 * returns a different vnode than the one passed into VOP_MAP (since
10610 * VOP_DELMAP will not see the vnode nfs4open_otw used). In this case,
10611 * we return NULL and let nfs4_map() fail. Note: the only case where
10612 * this should happen is if the file got removed and replaced with the
10613 * same name on the server (in addition to the fact that we're trying
10614 * to VOP_MAP withouth VOP_OPENing the file in the first place).
10615 */
10616 static int
10618 {
10638 }
10644 }
10652 /* This is needed so we don't bump the open ref count */
10657 }
10662 just_created);
10668 }
10673 /*
10674 * If nfs4open_otw() returned a different vnode then "undo"
10675 * the open and return failure to the caller.
10676 */
10678 nfs4_error_t e;
10682 /*
10683 * If there's an error, ignore it,
10684 * and let VOP_INACTIVE handle it.
10685 */
10690 }
10696 nfs4_error_t e;
10700 /*
10701 * If there's an error, ignore it,
10702 * and let VOP_INACTIVE handle it.
10703 */
10707 }
10712 }
10714 /*
10715 * Please be aware that when this function is called, the address space write
10716 * a_lock is held. Do not put over the wire calls in this function.
10717 */
10718 /* ARGSUSED */
10719 static int
10723 {
10736 /*
10737 * Don't need to update the open stream first, since this
10738 * mmap can't add any additional share access that isn't
10739 * already contained in the open stream (for the case where we
10740 * open/mmap/only update rp->r_mapcnt/server reboots/reopen doesn't
10741 * take into account os_mmap_read[write] counts).
10742 */
10746 /*
10747 * We need to retrieve the open stream and update the counts.
10748 * If there is no open stream here, something is wrong.
10749 */
10755 /* returns with 'os_sync_lock' held */
10758 }
10761 "nfs4_addmap: we should have an osp"
10765 }
10770 /*
10771 * Update the map count in the open stream.
10772 * This is necessary in the case where we
10773 * open/mmap/close/, then the server reboots, and we
10774 * attempt to reopen. If the mmap doesn't add share
10775 * access then we send an invalid reopen with
10776 * access = NONE.
10777 *
10778 * We need to specifically check each PROT_* so a mmap
10779 * call of (PROT_WRITE | PROT_EXEC) will ensure us both
10780 * read and write access. A simple comparison of prot
10781 * to ~PROT_WRITE to determine read access is insufficient
10782 * since prot can be |= with PROT_USER, etc.
10783 */
10785 /*
10786 * Unless we're MAP_SHARED, no sense in adding os_mmap_write
10787 */
10794 /*
10795 * Ensure that os_mmap_read gets incremented, even if
10796 * maxprot were to look like PROT_NONE.
10797 */
10804 }
10806 out:
10807 /*
10808 * If we got an error, then undo our
10809 * incrementing of 'r_mapcnt'.
10810 */
10815 }
10817 }
10819 /* ARGSUSED */
10820 static int
10822 {
10825 }
10827 /* ARGSUSED */
10828 static int
10832 {
10837 nfs4_error_t e;
10842 /* check for valid cmd parameter */
10846 /* Verify l_type. */
10862 }
10864 /* check the validity of the lock range */
10870 /*
10871 * If the filesystem is mounted using local locking, pass the
10872 * request off to the local locking code.
10873 */
10876 /*
10877 * For complete safety, we should be holding
10878 * r_lkserlock. However, we can't call
10879 * nfs4_safelock and then fs_frlock while
10880 * holding r_lkserlock, so just invoke
10881 * nfs4_safelock and expect that this will
10882 * catch enough of the cases.
10883 */
10886 }
10888 }
10892 /*
10893 * Check whether the given lock request can proceed, given the
10894 * current file mappings.
10895 */
10902 }
10903 }
10905 /*
10906 * Flush the cache after waiting for async I/O to finish. For new
10907 * locks, this is so that the process gets the latest bits from the
10908 * server. For unlocks, this is so that other clients see the
10909 * latest bits once the file has been unlocked. If currently dirty
10910 * pages can't be flushed, then don't allow a lock to be set. But
10911 * allow unlocks to succeed, to avoid having orphan locks on the
10912 * server.
10913 */
10928 }
10933 }
10944 }
10948 }
10949 }
10950 }
10952 /*
10953 * Call the lock manager to do the real work of contacting
10954 * the server and obtaining the lock.
10955 */
10963 done:
10967 }
10969 /*
10970 * Free storage space associated with the specified vnode. The portion
10971 * to be freed is specified by bfp->l_start and bfp->l_len (already
10972 * normalized to a "whence" of 0).
10973 *
10974 * This is an experimental facility whose continued existence is not
10975 * guaranteed. Currently, we only support the special case
10976 * of l_len == 0, meaning free to end of file.
10977 */
10978 /* ARGSUSED */
10979 static int
10982 {
11005 }
11008 }
11010 /* ARGSUSED */
11011 int
11013 {
11019 }
11022 }
11024 /*
11025 * Setup and add an address space callback to do the work of the delmap call.
11026 * The callback will (and must be) deleted in the actual callback function.
11027 *
11028 * This is done in order to take care of the problem that we have with holding
11029 * the address space's a_lock for a long period of time (e.g. if the NFS server
11030 * is down). Callbacks will be executed in the address space code while the
11031 * a_lock is not held. Holding the address space's a_lock causes things such
11032 * as ps and fork to hang because they are trying to acquire this lock as well.
11033 */
11034 /* ARGSUSED */
11035 static int
11039 {
11049 /*
11050 * A process may not change zones if it has NFS pages mmap'ed
11051 * in, so we can't legitimately get here from the wrong zone.
11052 */
11057 /*
11058 * The way that the address space of this process deletes its mapping
11059 * of this file is via the following call chains:
11060 * - as_free()->SEGOP_UNMAP()/segvn_unmap()->VOP_DELMAP()/nfs4_delmap()
11061 * - as_unmap()->SEGOP_UNMAP()/segvn_unmap()->VOP_DELMAP()/nfs4_delmap()
11062 *
11063 * With the use of address space callbacks we are allowed to drop the
11064 * address space lock, a_lock, while executing the NFS operations that
11065 * need to go over the wire. Returning EAGAIN to the caller of this
11066 * function is what drives the execution of the callback that we add
11067 * below. The callback will be executed by the address space code
11068 * after dropping the a_lock. When the callback is finished, since
11069 * we dropped the a_lock, it must be re-acquired and segvn_unmap()
11070 * is called again on the same segment to finish the rest of the work
11071 * that needs to happen during unmapping.
11072 *
11073 * This action of calling back into the segment driver causes
11074 * nfs4_delmap() to get called again, but since the callback was
11075 * already executed at this point, it already did the work and there
11076 * is nothing left for us to do.
11077 *
11078 * To Summarize:
11079 * - The first time nfs4_delmap is called by the current thread is when
11080 * we add the caller associated with this delmap to the delmap caller
11081 * list, add the callback, and return EAGAIN.
11082 * - The second time in this call chain when nfs4_delmap is called we
11083 * will find this caller in the delmap caller list and realize there
11084 * is no more work to do thus removing this caller from the list and
11085 * returning the error that was set in the callback execution.
11086 */
11089 /*
11090 * 'error' is from the actual delmap operations. To avoid
11091 * hangs, we need to handle the return of EAGAIN differently
11092 * since this is what drives the callback execution.
11093 * In this case, we don't want to return EAGAIN and do the
11094 * callback execution because there are none to execute.
11095 */
11098 else
11100 }
11102 /* current caller was not in the list */
11125 }
11129 {
11137 }
11139 static void
11141 {
11143 }
11145 /*
11146 * Searches for the current delmap caller (based on curthread) in the list of
11147 * callers. If it is found, we remove it and free the delmap caller.
11148 * Returns:
11149 * 0 if the caller wasn't found
11150 * 1 if the caller was found, removed and freed. *errp will be set
11151 * to what the result of the delmap was.
11152 */
11153 static int
11155 {
11158 /*
11159 * If the list doesn't exist yet, we create it and return
11160 * that the caller wasn't found. No list = no callers.
11161 */
11164 /* The list does not exist */
11171 /* The list exists so search it */
11176 /* current caller is in the list */
11182 }
11183 }
11184 }
11187 }
11189 /*
11190 * Remove some pages from an mmap'd vnode. Just update the
11191 * count of pages. If doing close-to-open, then flush and
11192 * commit all of the pages associated with this file.
11193 * Otherwise, start an asynchronous page flush to write out
11194 * any dirty pages. This will also associate a credential
11195 * with the rnode which can be used to write the pages.
11196 */
11197 /* ARGSUSED */
11198 static void
11200 {
11212 /*
11213 * Initiate a page flush and potential commit if there are
11214 * pages, the file system was not mounted readonly, the segment
11215 * was mapped shared, and the pages themselves were writeable.
11216 */
11230 }
11243 }
11245 /* Check to see if we need to close the file */
11252 /*
11253 * Since it is possible that e.error == 0 and
11254 * e.stat != NFS4_OK (and vice versa),
11255 * we do the proper checking in order to get both
11256 * e.error and e.stat reporting the correct info.
11257 */
11266 }
11267 }
11271 }
11274 static uint_t
11276 {
11281 }
11285 }
11288 }
11291 }
11294 }
11297 }
11300 }
11302 }
11304 static int
11306 {
11317 }
11319 /* ARGSUSED */
11320 int
11323 {
11325 hrtime_t t;
11327 nfs4_ga_res_t gar;
11328 nfs4_ga_ext_res_t ger;
11337 }
11341 }
11345 /*
11346 * The existence of the xattr directory is not sufficient
11347 * for determining whether generic user attributes exists.
11348 * The attribute directory could only be a transient directory
11349 * used for Solaris sysattr support. Do a small readdir
11350 * to verify if the only entries are sysattrs or not.
11351 *
11352 * pc4_xattr_valid can be only be trusted when r_xattr_dir
11353 * is NULL. Once the xadir vp exists, we can create xattrs,
11354 * and we don't have any way to update the "base" object's
11355 * pc4_xattr_exists from the xattr or xadir. Maybe FEM
11356 * could help out.
11357 */
11361 }
11391 }
11393 #ifdef DEBUG
11394 nfs4_pathconf_cache_hits++;
11395 #endif
11397 }
11399 }
11400 }
11401 #ifdef DEBUG
11402 nfs4_pathconf_cache_misses++;
11403 #endif
11415 }
11417 /* interpret the max filesize */
11421 /* Store the attributes we just received */
11444 }
11448 }
11451 }
11453 /*
11454 * Called by async thread to do synchronous pageio. Do the i/o, wait
11455 * for it to complete, and cleanup the page list when done.
11456 */
11457 static int
11460 {
11468 else
11471 }
11473 /* ARGSUSED */
11474 static int
11477 {
11494 nfs4_sync_pageio);
11502 }
11504 /* ARGSUSED */
11505 static void
11508 {
11513 offset3 offset;
11514 count3 len;
11515 k_sigset_t smask;
11517 /*
11518 * We should get called with fl equal to either B_FREE or
11519 * B_INVAL. Any other value is illegal.
11520 *
11521 * The page that we are either supposed to free or destroy
11522 * should be exclusive locked and its io lock should not
11523 * be held.
11524 */
11530 /*
11531 * If the page doesn't need to be committed or we shouldn't
11532 * even bother attempting to commit it, then just make sure
11533 * that the p_fsdata byte is clear and then either free or
11534 * destroy the page as appropriate.
11535 */
11540 else
11543 }
11545 /*
11546 * If there is a page invalidation operation going on, then
11547 * if this is one of the pages being destroyed, then just
11548 * clear the p_fsdata byte and then either free or destroy
11549 * the page as appropriate.
11550 */
11557 else
11560 }
11562 /*
11563 * If we are freeing this page and someone else is already
11564 * waiting to do a commit, then just unlock the page and
11565 * return. That other thread will take care of commiting
11566 * this page. The page can be freed sometime after the
11567 * commit has finished. Otherwise, if the page is marked
11568 * as delay commit, then we may be getting called from
11569 * pvn_write_done, one page at a time. This could result
11570 * in one commit per page, so we end up doing lots of small
11571 * commits instead of fewer larger commits. This is bad,
11572 * we want do as few commits as possible.
11573 */
11579 }
11585 }
11586 }
11588 /*
11589 * Check to see if there is a signal which would prevent an
11590 * attempt to commit the pages from being successful. If so,
11591 * then don't bother with all of the work to gather pages and
11592 * generate the unsuccessful RPC. Just return from here and
11593 * let the page be committed at some later time.
11594 */
11601 }
11604 /*
11605 * We are starting to need to commit pages, so let's try
11606 * to commit as many as possible at once to reduce the
11607 * overhead.
11608 *
11609 * Set the `commit inprogress' state bit. We must
11610 * first wait until any current one finishes. Then
11611 * we initialize the c_pages list with this page.
11612 */
11617 }
11625 /*
11626 * Gather together all other pages which can be committed.
11627 * They will all be chained off r_commit.c_pages.
11628 */
11631 /*
11632 * Clear the `commit inprogress' status and disconnect
11633 * the list of pages to be committed from the rnode.
11634 * At this same time, we also save the starting offset
11635 * and length of data to be committed on the server.
11636 */
11651 }
11653 /*
11654 * Actually generate the COMMIT op over the wire operation.
11655 */
11658 /*
11659 * If we got an error during the commit, just unlock all
11660 * of the pages. The pages will get retransmitted to the
11661 * server during a putpage operation.
11662 */
11668 }
11670 }
11672 /*
11673 * We've tried as hard as we can to commit the data to stable
11674 * storage on the server. We just unlock the rest of the pages
11675 * and clear the commit required state. They will be put
11676 * onto the tail of the cachelist if they are nolonger
11677 * mapped.
11678 */
11684 }
11686 /*
11687 * It is possible that nfs4_commit didn't return error but
11688 * some other thread has modified the page we are going
11689 * to free/destroy.
11690 * In this case we need to rewrite the page. Do an explicit check
11691 * before attempting to free/destroy the page. If modified, needs to
11692 * be rewritten so unlock the page and return.
11693 */
11698 }
11700 /*
11701 * Now, as appropriate, either free or destroy the page
11702 * that we were called with.
11703 */
11707 else
11709 }
11711 /*
11712 * Commit requires that the current fh be the file written to.
11713 * The compound op structure is:
11714 * PUTFH(file), COMMIT
11715 */
11716 static int
11718 {
11719 COMPOUND4args_clnt args;
11720 COMPOUND4res_clnt res;
11729 nfs4_recov_state_t recov_state;
11742 get_commit_cred:
11743 /*
11744 * Releases the osp, if a valid open stream is provided.
11745 * Puts a hold on the cred_otw and the new osp (if found).
11746 */
11750 recov_retry:
11751 /*
11752 * Commit ops: putfh file; commit
11753 */
11764 }
11766 /* putfh directory */
11770 /* commit */
11781 needrecov);
11788 }
11799 }
11807 }
11808 /* fall through for res.status case */
11809 }
11819 }
11820 /*
11821 * Can't do a nfs4_purge_stale_fh here because this
11822 * can cause a deadlock. nfs4_commit can
11823 * be called from nfs4_dispose which can be called
11824 * indirectly via pvn_vplist_dirty. nfs4_purge_stale_fh
11825 * can call back to pvn_vplist_dirty.
11826 */
11839 }
11854 }
11859 }
11868 }
11870 static void
11872 {
11875 /* make sure we're looking at the master vnode, not a shadow */
11877 }
11879 /*
11880 * This function is used to gather a page list of the pages which
11881 * can be committed on the server.
11882 *
11883 * The calling thread must have set R4COMMIT. This bit is used to
11884 * serialize access to the commit structure in the rnode. As long
11885 * as the thread has set R4COMMIT, then it can manipulate the commit
11886 * structure without requiring any other locks.
11887 *
11888 * When this function is called from nfs4_dispose() the page passed
11889 * into nfs4_dispose() will be SE_EXCL locked, and so this function
11890 * will skip it. This is not a problem since we initially add the
11891 * page to the r_commit page list.
11892 *
11893 */
11894 static void
11896 {
11905 /* make sure we're looking at the master vnode, not a shadow */
11913 /*
11914 * If there are no pages associated with this vnode, then
11915 * just return.
11916 */
11920 }
11922 /*
11923 * Step through all of the pages associated with this vnode
11924 * looking for pages which need to be committed.
11925 */
11927 /* Skip marker pages. */
11931 /*
11932 * First short-cut everything (without the page_lock)
11933 * and see if this page does not need to be committed
11934 * or is modified if so then we'll just skip it.
11935 */
11939 /*
11940 * Attempt to lock the page. If we can't, then
11941 * someone else is messing with it or we have been
11942 * called from nfs4_dispose and this is the page that
11943 * nfs4_dispose was called with.. anyway just skip it.
11944 */
11948 /*
11949 * Lets check again now that we have the page lock.
11950 */
11954 }
11956 /* this had better not be a free page */
11959 /*
11960 * The page needs to be committed and we locked it.
11961 * Update the base and length parameters and add it
11962 * to r_pages.
11963 */
11975 }
11980 }
11982 /*
11983 * This routine is used to gather together a page list of the pages
11984 * which are to be committed on the server. This routine must not
11985 * be called if the calling thread holds any locked pages.
11986 *
11987 * The calling thread must have set R4COMMIT. This bit is used to
11988 * serialize access to the commit structure in the rnode. As long
11989 * as the thread has set R4COMMIT, then it can manipulate the commit
11990 * structure without requiring any other locks.
11991 */
11992 static void
11994 {
11998 u_offset_t end;
11999 u_offset_t off;
12006 /* make sure we're looking at the master vnode, not a shadow */
12011 /*
12012 * If there are no pages associated with this vnode, then
12013 * just return.
12014 */
12017 /*
12018 * Calculate the ending offset.
12019 */
12022 /*
12023 * Lookup each page by vp, offset.
12024 */
12027 /*
12028 * If this page does not need to be committed or is
12029 * modified, then just skip it.
12030 */
12034 }
12037 /*
12038 * The page needs to be committed and we locked it.
12039 * Update the base and length parameters and add it
12040 * to r_pages.
12041 */
12048 }
12050 }
12051 }
12053 /*
12054 * Called from nfs4_close(), nfs4_fsync() and nfs4_delmap().
12055 * Flushes and commits data to the server.
12056 */
12057 static int
12059 {
12061 verifier4 write_verf;
12066 /*
12067 * Flush the data portion of the file and then commit any
12068 * portions which need to be committed. This may need to
12069 * be done twice if the server has changed state since
12070 * data was last written. The data will need to be
12071 * rewritten to the server and then a new commit done.
12072 *
12073 * In fact, this may need to be done several times if the
12074 * server is having problems and crashing while we are
12075 * attempting to do this.
12076 */
12078 top:
12079 /*
12080 * Do a flush based on the poff and plen arguments. This
12081 * will synchronously write out any modified pages in the
12082 * range specified by (poff, plen). This starts all of the
12083 * i/o operations which will be waited for in the next
12084 * call to nfs4_putpage
12085 */
12095 /*
12096 * Do a flush based on the poff and plen arguments. This
12097 * will synchronously write out any modified pages in the
12098 * range specified by (poff, plen) and wait until all of
12099 * the asynchronous i/o's in that range are done as well.
12100 */
12111 }
12114 /*
12115 * Now commit any pages which might need to be committed.
12116 * If the error, NFS_VERF_MISMATCH, is returned, then
12117 * start over with the flush operation.
12118 */
12125 }
12127 /*
12128 * nfs4_commit_vp() will wait for other pending commits and
12129 * will either commit the whole file or a range, plen dictates
12130 * if we commit whole file. a value of zero indicates the whole
12131 * file. Called from nfs4_putpage_commit() or nfs4_sync_putapage()
12132 */
12133 static int
12136 {
12139 offset3 offset;
12140 count3 len;
12146 /*
12147 * before we gather commitable pages make
12148 * sure there are no outstanding async writes
12149 */
12154 }
12156 }
12158 /*
12159 * Set the `commit inprogress' state bit. We must
12160 * first wait until any current one finishes.
12161 */
12167 }
12171 /*
12172 * Gather all of the pages which need to be
12173 * committed.
12174 */
12177 else
12180 /*
12181 * Clear the `commit inprogress' bit and disconnect the
12182 * page list which was gathered by nfs4_get_commit.
12183 */
12193 /*
12194 * If any pages need to be committed, commit them and
12195 * then unlock them so that they can be freed some
12196 * time later.
12197 */
12201 /*
12202 * No error occurred during the flush portion
12203 * of this operation, so now attempt to commit
12204 * the data to stable storage on the server.
12205 *
12206 * This will unlock all of the pages on the list.
12207 */
12209 }
12211 static int
12214 {
12222 /*
12223 * If we got an error, then just unlock all of the pages
12224 * on the list.
12225 */
12231 }
12233 }
12234 /*
12235 * We've tried as hard as we can to commit the data to stable
12236 * storage on the server. We just unlock the pages and clear
12237 * the commit required state. They will get freed later.
12238 */
12244 }
12247 }
12249 static void
12252 {
12255 }
12257 /*ARGSUSED*/
12258 static int
12261 {
12264 vattr_t va;
12265 vsecattr_t nfsace4_vsap;
12271 /* if we have a delegation, return it */
12277 NFS4_ACL_SET);
12282 /*
12283 * These are aclent_t type entries.
12284 */
12290 /*
12291 * These are ace_t type entries.
12292 */
12294 FALSE);
12297 }
12302 }
12304 }
12306 /* ARGSUSED */
12307 int
12310 {
12313 nfs4_ga_res_t gar;
12323 /*
12324 * vsecattr->vsa_mask holds the original acl request mask.
12325 * This is needed when determining what to return.
12326 * (See: nfs4_create_getsecattr_return())
12327 */
12332 /*
12333 * If this is a referral stub, don't try to go OTW for an ACL
12334 */
12339 /*
12340 * Check if the data is cached and the cache is valid. If it
12341 * is we don't go over the wire.
12342 */
12353 }
12354 }
12356 }
12358 /*
12359 * The getattr otw call will always get both the acl, in
12360 * the form of a list of nfsace4's, and the number of acl
12361 * entries; independent of the value of gar.n4g_vsa.vsa_mask.
12362 */
12370 }
12373 /*
12374 * No error was returned, but according to the response
12375 * bitmap, neither was an acl.
12376 */
12380 }
12382 /*
12383 * Update the cache with the ACL.
12384 */
12395 }
12397 }
12400 }
12402 /*
12403 * The function returns:
12404 * - 0 (zero) if the passed in "acl_mask" is a valid request.
12405 * - EINVAL if the passed in "acl_mask" is an invalid request.
12406 *
12407 * In the case of getting an acl (op == NFS4_ACL_GET) the mask is invalid if:
12408 * - We have a mixture of ACE and ACL requests (e.g. VSA_ACL | VSA_ACE)
12409 *
12410 * In the case of setting an acl (op == NFS4_ACL_SET) the mask is invalid if:
12411 * - We have a mixture of ACE and ACL requests (e.g. VSA_ACL | VSA_ACE)
12412 * - We have a count field set without the corresponding acl field set. (e.g. -
12413 * VSA_ACECNT is set, but VSA_ACE is not)
12414 */
12415 static int
12417 {
12418 /* Shortcut the masks that are always valid. */
12425 /*
12426 * We can't have any VSA_ACL type stuff in the mask now.
12427 */
12429 VSA_DFACLCNT))
12435 }
12436 }
12439 /*
12440 * We can't have any VSA_ACE type stuff in the mask now.
12441 */
12452 }
12453 }
12455 }
12457 /*
12458 * The theory behind creating the correct getsecattr return is simply this:
12459 * "Don't return anything that the caller is not expecting to have to free."
12460 */
12461 static int
12464 {
12466 /* Save the mask since the translators modify it. */
12475 /*
12476 * If the caller only asked for the ace count (VSA_ACECNT)
12477 * don't give them the full acl (VSA_ACE), free it.
12478 */
12484 }
12485 }
12489 VSA_DFACLCNT)) {
12496 /*
12497 * If the caller only asked for the acl count (VSA_ACLCNT)
12498 * and/or the default acl count (VSA_DFACLCNT) don't give them
12499 * the acl (VSA_ACL) or default acl (VSA_DFACL), free it.
12500 */
12506 }
12507 }
12514 }
12515 }
12517 }
12519 }
12521 /* ARGSUSED */
12522 int
12525 {
12530 /*
12531 * check for valid cmd parameter
12532 */
12536 /*
12537 * Check access permissions
12538 */
12544 /*
12545 * If the filesystem is mounted using local locking, pass the
12546 * request off to the local share code.
12547 */
12554 /*
12555 * This will be properly implemented later,
12556 * see RFE: 4823948 .
12557 */
12562 /*
12563 * NFS client can't store remote locks itself
12564 */
12572 }
12575 }
12577 /*
12578 * Common code called by directory ops to update the attrcache
12579 */
12580 static int
12583 {
12589 /* getattr not done or failed */
12592 }
12598 }
12600 }
12602 /*
12603 * Update directory caches for directory modification ops (link, rename, etc.)
12604 * When dinfo is NULL, manage dircaches in the old way.
12605 */
12606 static void
12609 {
12614 /* Purge rddir cache for dir since it changed */
12618 /*
12619 * If caller provided dinfo, then use it to manage dir caches.
12620 */
12628 /*
12629 * XXX don't update if the created_v4 flag is
12630 * set
12631 */
12636 }
12637 }
12643 }
12645 /*
12646 * Caller didn't provide dinfo, then check change_info4 to update DNLC.
12647 * Since caller modified dir but didn't receive post-dirmod-op dir
12648 * attrs, the dir's attrs must be purged.
12649 *
12650 * XXX this check and dnlc update/purge should really be atomic,
12651 * XXX but can't use rnode statelock because it'll deadlock in
12652 * XXX dnlc_purge_vp, however, the risk is minimal even if a race
12653 * XXX does occur.
12654 *
12655 * XXX We also may want to check that atomic is true in the
12656 * XXX change_info struct. If it is not, the change_info may
12657 * XXX reflect changes by more than one clients which means that
12658 * XXX our cache may not be valid.
12659 */
12662 /* no changes took place in the directory prior to our link */
12669 /*
12670 * XXX dont' update if the created_v4 flag
12671 * is set
12672 */
12675 "nfs4_update_dircaches: don't"
12677 }
12678 }
12680 /* Another client modified directory - purge its dnlc cache */
12682 }
12683 }
12685 /*
12686 * The OPEN_CONFIRM operation confirms the sequence number used in OPENing a
12687 * file.
12688 *
12689 * The 'reopening_file' boolean should be set to TRUE if we are reopening this
12690 * file (ie: client recovery) and otherwise set to FALSE.
12691 *
12692 * 'nfs4_start/end_op' should have been called by the proper (ie: not recovery
12693 * initiated) calling functions.
12694 *
12695 * 'resend' is set to TRUE if this is a OPEN_CONFIRM issued as a result
12696 * of resending a 'lost' open request.
12697 *
12698 * 'num_bseqid_retryp' makes sure we don't loop forever on a broken
12699 * server that hands out BAD_SEQID on open confirm.
12700 *
12701 * Errors are returned via the nfs4_error_t parameter.
12702 */
12703 void
12707 {
12708 COMPOUND4args_clnt args;
12709 COMPOUND4res_clnt res;
12718 #if DEBUG
12722 #endif
12724 recov_retry_confirm:
12730 else
12736 /* putfh target fh */
12753 }
12777 }
12778 }
12788 }
12789 /* State may have changed so retry the entire OPEN op */
12792 else
12797 }
12802 }
12809 }
12811 /*
12812 * Return the credentials associated with a client state object. The
12813 * caller is responsible for freeing the credentials.
12814 */
12818 {
12821 /*
12822 * It's ok to not lock the open stream and open owner to get
12823 * the oo_cred since this is only written once (upon creation)
12824 * and will not change.
12825 */
12830 }
12832 /*
12833 * nfs4_find_sysid
12834 *
12835 * Find the sysid for the knetconfig associated with the given mi.
12836 */
12839 {
12842 /*
12843 * Switch from RDMA knconf to original mount knconf
12844 */
12847 }
12849 #ifdef DEBUG
12850 /*
12851 * Return a string version of the call type for easy reading.
12852 */
12855 {
12869 }
12870 }
12871 #endif
12873 /*
12874 * Map the frlock cmd and lock type to the NFSv4 over-the-wire lock type
12875 * Unlock requests don't have an over-the-wire locktype, so we just return
12876 * something non-threatening.
12877 */
12879 static nfs_lock_type4
12881 {
12890 else
12895 else
12897 }
12899 /*NOTREACHED*/
12900 }
12902 /*
12903 * Do some preliminary checks for nfs4frlock.
12904 */
12905 static int
12907 u_offset_t offset)
12908 {
12911 /*
12912 * If we are setting a lock, check that the file is opened
12913 * with the correct mode.
12914 */
12919 "nfs4frlock_validate_args: file was opened with "
12922 }
12923 }
12925 /* Convert the offset. It may need to be restored before returning. */
12929 error));
12931 }
12934 }
12936 /*
12937 * Set the flock64's lm_sysid for nfs4frlock.
12938 */
12939 static int
12941 {
12944 /* Find the lm_sysid */
12951 }
12956 }
12958 /*
12959 * Do the remaining preliminary setup for nfs4frlock.
12960 */
12961 static void
12965 {
12966 /*
12967 * set tick_delay to the base delay time.
12968 * (NFS4_BASE_WAIT_TIME is in secs)
12969 */
12973 /*
12974 * If lock is relative to EOF, we need the newest length of the
12975 * file. Therefore invalidate the ATTR_CACHE.
12976 */
12986 }
12988 /*
12989 * Initialize and allocate the data structures necessary for
12990 * the nfs4frlock call.
12991 * Allocates argsp's op array, frees up the saved_rqstpp if there is one.
12992 */
12993 static void
12998 {
13007 /* fill array with zero */
13016 /* initialize in case of error; will get real value down below */
13021 else
13023 }
13025 /*
13026 * Call the nfs4_start_fop() for nfs4frlock, if necessary. Assign
13027 * the proper nfs4_server_t for this instance of nfs4frlock.
13028 * Returns 0 (success) or an errno value.
13029 */
13030 static int
13034 {
13049 }
13054 /* If the file failed recovery, just quit. */
13058 }
13060 }
13063 }
13065 /*
13066 * Setup the LOCK4/LOCKU4 arguments for resending a lost lock request. A
13067 * resend nfs4frlock call is initiated by the recovery framework.
13068 * Acquires the lop and oop seqid synchronization.
13069 */
13070 static void
13075 {
13091 }
13093 /* Must resend this lost lock/locku request. */
13132 }
13159 }
13160 }
13161 }
13163 /*
13164 * Setup the LOCKT4 arguments.
13165 */
13166 static void
13170 {
13179 /*
13180 * The locktype will be READ_LT unless it's
13181 * a write lock. We do this because the Solaris
13182 * system call allows the combination of
13183 * F_UNLCK and F_GETLK* and so in that case the
13184 * unlock is mapped to a read.
13185 */
13188 else
13192 /* set the lock owner4 args */
13202 }
13204 /*
13205 * If the client is holding a delegation, and the open stream to be used
13206 * with this lock request is a delegation open stream, then re-open the stream.
13207 * Sets the nfs4_error_t to all zeros unless the open stream has already
13208 * failed a reopen or we couldn't find the open stream. NFS4ERR_DELAY
13209 * means the caller should retry (like a recovery retry).
13210 */
13211 static void
13213 {
13214 open_delegation_type4 dt;
13217 open_claim_type4 oclaim;
13236 }
13237 /* returns with 'os_sync_lock' held */
13243 }
13248 "nfs4frlock_check_deleg: os_failed_reopen set "
13256 }
13258 /*
13259 * Determine whether a reopen is needed. If this
13260 * is a delegation open stream, then send the open
13261 * to the server to give visibility to the open owner.
13262 * Even if it isn't a delegation open stream, we need
13263 * to check if the previous open CLAIM_DELEGATE_CUR
13264 * was sufficient.
13265 */
13277 /*
13278 * Always use CLAIM_PREVIOUS after server reboot.
13279 * The server will reject CLAIM_DELEGATE_CUR if
13280 * it is used during the grace period.
13281 */
13289 }
13296 }
13297 }
13300 }
13301 }
13303 /*
13304 * Setup the LOCKU4 arguments.
13305 * Returns errors via the nfs4_error_t.
13306 * NFS4_OK no problems. *go_otwp is TRUE if call should go
13307 * over-the-wire. The caller must release the
13308 * reference on *lopp.
13309 * NFS4ERR_DELAY caller should retry (like recovery retry)
13310 * (other) unrecoverable error.
13311 */
13312 static void
13318 {
13321 pid_t pid;
13335 else
13340 /*
13341 * XXX what should locku_args->locktype be?
13342 * setting to ALWAYS be READ_LT so at least
13343 * it is a valid locktype.
13344 */
13351 /*
13352 * Get the lock owner stateid. If no lock owner
13353 * exists, return success.
13354 */
13360 /*
13361 * No lock owner so no locks to unlock.
13362 * Return success. If there was a failed
13363 * reclaim earlier, the lock might still be
13364 * registered with the local locking code,
13365 * so notify it of the unlock.
13366 *
13367 * If the lockowner is using a special stateid,
13368 * then the original lock request (that created
13369 * this lockowner) was never successful, so we
13370 * have no lock to undo OTW.
13371 */
13373 "nfs4frlock_setup_locku_args: LOCKU: no lock owner "
13379 /*
13380 * Release our hold and NULL out so final_cleanup
13381 * doesn't try to end a lock seqid sync we
13382 * never started.
13383 */
13387 }
13391 }
13398 }
13405 /* leave the ref count on lop, rele after RPC call */
13413 }
13415 /*
13416 * Setup the LOCK4 arguments.
13417 *
13418 * Returns errors via the nfs4_error_t.
13419 * NFS4_OK no problems
13420 * NFS4ERR_DELAY caller should retry (like recovery retry)
13421 * (other) unrecoverable error
13422 */
13423 static void
13428 {
13433 pid_t pid;
13447 else
13452 /*
13453 * Get the lock owner. If no lock owner exists,
13454 * create a 'temporary' one and grab the open seqid
13455 * synchronization (which puts a hold on the open
13456 * owner and open stream).
13457 * This also grabs the lock seqid synchronization.
13458 */
13474 out:
13478 }
13480 /*
13481 * After we get the reply from the server, record the proper information
13482 * for possible resend lock requests.
13483 *
13484 * Allocates memory for the saved_rqstp if we have a lost lock to save.
13485 */
13486 static void
13491 {
13501 "nfs4frlock_save_lost_rqst: set lo_pending_rqsts to 1 "
13507 }
13512 /*
13513 * For lock/locku requests, we treat EINTR as ETIMEDOUT for
13514 * recovery purposes so that the lock request that was sent
13515 * can be saved and re-issued later. Ditto for EIO from a forced
13516 * unmount. This is done to have the client's local locking state
13517 * match the v4 server's state; that is, the request was
13518 * potentially received and accepted by the server but the client
13519 * thinks it was not.
13520 */
13525 "nfs4frlock_save_lost_rqst: got a lost %s lock for "
13533 }
13534 /*
13535 * Objects are held and rele'd via the recovery code.
13536 * See nfs4_save_lost_rqst.
13537 */
13555 }
13557 }
13558 }
13560 /*
13561 * Update lop's seqid. Also update the seqid stored in a resend request,
13562 * if any. (Some recovery errors increment the seqid, and we may have to
13563 * send the resend request again.)
13564 */
13566 static void
13569 {
13576 }
13580 }
13581 }
13583 /*
13584 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13585 * COMPOUND4 args/res for calls that need to retry.
13586 * Switches the *cred_otwp to base_cr.
13587 */
13588 static void
13594 {
13602 needrecov);
13604 }
13620 }
13622 /* need to free up the reference on osp for lock args */
13626 }
13628 /* need to free up the reference on oop for lock args */
13633 }
13638 }
13640 /*
13641 * Function to process the client's recovery for nfs4frlock.
13642 * Returns TRUE if we should retry the lock request; FALSE otherwise.
13643 *
13644 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13645 * COMPOUND4 args/res for calls that need to retry.
13646 *
13647 * Note: the rp's r_lkserlock is *not* dropped during this path.
13648 */
13649 static bool_t
13657 {
13677 nfs_opnum4 op;
13682 seqid4 seqid;
13688 else
13695 }
13699 }
13708 }
13710 /*
13711 * Return that we do not want to retry the request for 3 cases:
13712 * 1. If we received EINTR or are bailing out because of a forced
13713 * unmount, we came into this code path just for the sake of
13714 * initiating recovery, we now need to return the error.
13715 * 2. If we have aborted recovery.
13716 * 3. We received NFS4ERR_BAD_SEQID.
13717 */
13724 needrecov);
13726 }
13743 }
13748 }
13752 /* need to free up the reference on osp for lock args */
13756 }
13758 /* need to free up the reference on oop for lock args */
13763 }
13766 }
13768 /*
13769 * Handles the successful reply from the server for nfs4frlock.
13770 */
13771 static void
13775 {
13781 /*
13782 * We do not register lost locks locally in
13783 * the 'resend' case since the user/application
13784 * doesn't think we have the lock.
13785 */
13788 }
13789 }
13790 }
13792 /*
13793 * Handle the DENIED reply from the server for nfs4frlock.
13794 * Returns TRUE if we should retry the request; FALSE otherwise.
13795 *
13796 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13797 * COMPOUND4 args/res for calls that need to retry. Can also
13798 * drop and regrab the r_lkserlock.
13799 */
13800 static bool_t
13810 {
13819 /*
13820 * Blocking lock needs to sleep and retry from the request.
13821 *
13822 * Do not block and wait for 'resend' or 'reinstate'
13823 * lock requests, just return the error.
13824 *
13825 * Note: reclaim requests have cmd == F_SETLK, not F_SETLKW.
13826 */
13853 }
13858 }
13869 }
13874 /*
13875 * Make sure we are still safe to lock with
13876 * regards to mmapping.
13877 */
13881 }
13884 }
13898 /* according to NLM code */
13903 }
13905 }
13907 /*
13908 * Handles all NFS4 errors besides NFS4_OK and NFS4ERR_DENIED for nfs4frlock.
13909 */
13910 static void
13912 {
13946 "nfs4frlock_results_default: got unrecognizable "
13949 }
13950 }
13952 /*
13953 * The lock request was successful, so update the client's state.
13954 */
13955 static void
13960 {
13967 /* update the stateid with server's response */
13973 }
13977 /*
13978 * If the lock was the result of a resending a lost
13979 * request, we've synched up the stateid and seqid
13980 * with the server, but now the server might be out of sync
13981 * with what the application thinks it has for locks.
13982 * Clean that up here. It's unclear whether we should do
13983 * this even if the filesystem has been forcibly unmounted.
13984 * For most servers, it's probably wasted effort, but
13985 * RFC3530 lets servers require that unlocks exactly match
13986 * the locks that are held.
13987 */
13993 }
13999 /* Update the stateid with the server's response */
14002 /* Switch the lock type to express success, see fcntl */
14005 }
14006 }
14008 /*
14009 * Do final cleanup before exiting nfs4frlock.
14010 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
14011 * COMPOUND4 args/res for calls that haven't already.
14012 */
14013 static void
14022 {
14030 /*
14031 * The client recovery code wants the raw status information,
14032 * so don't map the NFS status code to an errno value for
14033 * non-normal call types.
14034 */
14040 needrecov);
14042 /*
14043 * We've established a new lock on the server, so invalidate
14044 * the pages associated with the vnode to get the most up to
14045 * date pages from the server after acquiring the lock. We
14046 * want to be sure that the read operation gets the newest data.
14047 * N.B.
14048 * We used to do this in nfs4frlock_results_ok but that doesn't
14049 * work since VOP_PUTPAGE can call nfs4_commit which calls
14050 * nfs4_start_fop. We flush the pages below after calling
14051 * nfs4_end_fop above
14052 * The flush of the page cache must be done after
14053 * nfs4_end_open_seqid_sync() to avoid a 4-way hang.
14054 */
14057 }
14068 }
14070 /* free the reference on the lock owner */
14074 }
14076 /* need to free up the reference on osp for lock args */
14080 /* need to free up the reference on oop for lock args */
14084 }
14093 /*
14094 * Record debug information in the event we get EINVAL.
14095 */
14101 "%s operation failed with "
14102 "EINVAL probably since the server, %s,"
14107 }
14108 }
14113 }
14115 /*
14116 * This calls the server and the local locking code.
14117 *
14118 * Client locks are registerred locally by oring the sysid with
14119 * LM_SYSID_CLIENT. The server registers locks locally using just the sysid.
14120 * We need to distinguish between the two to avoid collision in case one
14121 * machine is used as both client and server.
14122 *
14123 * Blocking lock requests will continually retry to acquire the lock
14124 * forever.
14125 *
14126 * The ctype is defined as follows:
14127 * NFS4_LCK_CTYPE_NORM: normal lock request.
14128 *
14129 * NFS4_LCK_CTYPE_RECLAIM: bypass the usual calls for synchronizing with client
14130 * recovery, get the pid from flk instead of curproc, and don't reregister
14131 * the lock locally.
14132 *
14133 * NFS4_LCK_CTYPE_RESEND: same as NFS4_LCK_CTYPE_RECLAIM, with the addition
14134 * that we will use the information passed in via resend_rqstp to setup the
14135 * lock/locku request. This resend is the exact same request as the 'lost
14136 * lock', and is initiated by the recovery framework. A successful resend
14137 * request can initiate one or more reinstate requests.
14138 *
14139 * NFS4_LCK_CTYPE_REINSTATE: same as NFS4_LCK_CTYPE_RESEND, except that it
14140 * does not trigger additional reinstate requests. This lock call type is
14141 * set for setting the v4 server's locking state back to match what the
14142 * client's local locking state is in the event of a received 'lost lock'.
14143 *
14144 * Errors are returned via the nfs4_error_t parameter.
14145 */
14146 void
14150 {
14166 nfs4_recov_state_t recov_state;
14168 nfs4_op_hint_t op_hint;
14169 nfs4_lost_rqst_t lost_rqst;
14176 #ifdef DEBUG
14178 #endif
14182 #ifdef DEBUG
14192 #endif
14204 recov_retry:
14216 /*
14217 * Leave the request for the recovery system to deal with.
14218 */
14236 }
14240 }
14242 /* putfh directory fh */
14246 /*
14247 * Set up the over-the-wire arguments and get references to the
14248 * open owner, etc.
14249 */
14274 else
14286 /* recov thread never gets this error */
14303 }
14310 }
14314 }
14316 /* XXX should we use the local reclock as a cache ? */
14317 /*
14318 * Unregister the lock with the local locking code before
14319 * contacting the server. This avoids a potential race where
14320 * another process gets notified that it has been granted a lock
14321 * before we can unregister ourselves locally.
14322 */
14327 }
14329 /*
14330 * Send the server the lock request. Continually loop with a delay
14331 * if get error NFS4ERR_DENIED (for blocking locks) or NFS4ERR_GRACE.
14332 */
14347 }
14349 /*
14350 * Do the OTW call.
14351 */
14365 /*
14366 * Check if one of these mutually exclusive error cases has
14367 * happened:
14368 * need to swap credentials due to access error
14369 * recovery is needed
14370 * different error (only known case is missing Kerberos ticket)
14371 */
14380 }
14383 /*
14384 * LOCKT requests don't need to recover from lost
14385 * requests since they don't create/modify state.
14386 */
14389 lockt_args)
14391 /*
14392 * Do not attempt recovery for requests initiated by
14393 * the recovery framework. Let the framework redrive them.
14394 */
14399 }
14415 }
14417 }
14419 /*
14420 * Bail out if have reached this point with ep->error set. Can
14421 * happen if (ep->error == EACCES && !needrecov && cred_otw == cr).
14422 * This happens if Kerberos ticket has expired or has been
14423 * destroyed.
14424 */
14428 /*
14429 * Process the reply.
14430 */
14435 resend_rqstp);
14436 /*
14437 * Have a successful lock operation, now update state.
14438 */
14456 }
14458 /*
14459 * If the server won't let us reclaim, fall-back to trying to lock
14460 * the file from scratch. Code elsewhere will check the changeinfo
14461 * to ensure the file hasn't been changed.
14462 */
14469 /* clean up before retrying */
14475 }
14476 /* FALLTHROUGH */
14481 }
14482 out:
14483 /*
14484 * Process and cleanup from error. Make interrupted unlock
14485 * requests look successful, since they will be handled by the
14486 * client recovery code.
14487 */
14496 }
14498 /*
14499 * nfs4_safelock:
14500 *
14501 * Return non-zero if the given lock request can be handled without
14502 * violating the constraints on concurrent mapping and locking.
14503 */
14505 static int
14507 {
14522 /*
14523 * If the file is already mapped and there are locks, then they
14524 * should be all safe locks. So adding or removing a lock is safe
14525 * as long as the new request is safe (i.e., whole-file, meaning
14526 * length and starting offset are both zero).
14527 */
14531 "cannot lock a memory mapped file unless locking the "
14535 }
14537 /* mandatory locking and mapping don't mix */
14544 }
14549 }
14552 }
14555 /*
14556 * Register the lock locally within Solaris.
14557 * As the client, we "or" the sysid with LM_SYSID_CLIENT when
14558 * recording locks locally.
14559 *
14560 * This should handle conflicts/cooperation with NFS v2/v3 since all locks
14561 * are registered locally.
14562 */
14563 void
14565 u_offset_t offset)
14566 {
14569 #ifdef DEBUG
14571 #endif
14575 #ifdef DEBUG
14583 #endif
14585 /* register the lock with local locking */
14589 #ifdef DEBUG
14592 "nfs4_register_lock_locally: could not register with"
14602 "blocked by pid %d sysid 0x%x type %d "
14606 }
14607 #endif
14609 }
14611 /*
14612 * nfs4_lockrelease:
14613 *
14614 * Release any locks on the given vnode that are held by the current
14615 * process. Also removes the lock owner (if one exists) from the rnode's
14616 * list.
14617 */
14618 static int
14620 {
14621 flock64_t ld;
14625 nfs4_recov_state_t recov_state;
14628 bool_t recovonly;
14636 /*
14637 * If we have not locked anything then we can
14638 * just return since we have no work to do.
14639 */
14642 }
14644 /*
14645 * We need to comprehend that another thread may
14646 * kick off recovery and the lock_owner we have stashed
14647 * in lop might be invalid so we should NOT cache it
14648 * locally!
14649 */
14659 }
14663 /*
14664 * Check if the lock owner might have a lock (request was sent but
14665 * no response was received). Also check if there are any remote
14666 * locks on the file. (In theory we shouldn't have to make this
14667 * second check if there's no lock owner, but for now we'll be
14668 * conservative and do it anyway.) If either condition is true,
14669 * send an unlock for the entire file to the server.
14670 *
14671 * Note that no explicit synchronization is needed here. At worst,
14672 * flk_has_remote_locks() will return a false positive, in which case
14673 * the unlock call wastes time but doesn't harm correctness.
14674 */
14681 }
14686 "nfs4_lockrelease: possible orphan %d, remote locks %d, for "
14700 /*
14701 * If VOP_FRLOCK fails, make sure we unregister
14702 * local locks before we continue.
14703 */
14707 "nfs4_lockrelease: lock release error on vp"
14709 }
14710 }
14721 }
14723 /*
14724 * So, here we're going to need to retrieve the lock-owner
14725 * again (in case recovery has done a switch-a-roo) and
14726 * remove it because we can.
14727 */
14733 }
14737 }
14739 /*
14740 * Wait for 'tick_delay' clock ticks.
14741 * Implement exponential backoff until hit the lease_time of this nfs4_server.
14742 * NOTE: lock_lease_time is in seconds.
14743 *
14744 * XXX For future improvements, should implement a waiting queue scheme.
14745 */
14746 static int
14748 {
14752 /* wait tick_delay clock ticks or siginteruptus */
14755 }
14757 "reissue the lock request: blocked for %ld clock ticks: %ld "
14760 /* get the lease time */
14763 /* drv_hztousec converts ticks to microseconds */
14769 }
14771 }
14774 void
14776 {
14777 }
14779 void
14781 {
14782 }
14784 /*
14785 * Return a reference to the directory (parent) vnode for a given vnode,
14786 * using the saved pathname information and the directory file handle. The
14787 * caller is responsible for disposing of the reference.
14788 * Returns zero or an errno value.
14789 *
14790 * Caller should set need_start_op to FALSE if it is the recovery
14791 * thread, or if a start_fop has already been done. Otherwise, TRUE.
14792 */
14793 int
14795 {
14806 nfs_fh4 fh;
14827 }
14835 }
14841 }
14849 }
14854 }
14862 }
14865 }
14867 /*
14868 * Copy the (final) component name of vp to fnamep. maxlen is the maximum
14869 * length that fnamep can accept, including the trailing null.
14870 * Returns 0 if okay, returns an errno value if there was a problem.
14871 */
14873 int
14875 {
14881 /*
14882 * If the file being opened has VROOT set, then this is
14883 * a "file" mount. sv_name will not be interesting, so
14884 * go back to the servinfo4 to get the original mount
14885 * path and strip off all but the final edge. Otherwise
14886 * just return the name from the shadow vnode.
14887 */
14897 else
14898 fn++;
14902 }
14907 else
14912 else
14916 }
14918 /*
14919 * Bookkeeping for a close that doesn't need to go over the wire.
14920 * *have_lockp is set to 0 if 'os_sync_lock' is released; otherwise
14921 * it is left at 1.
14922 */
14923 void
14925 {
14941 }
14943 /*
14944 * This removes the reference obtained at OPEN; ie,
14945 * when the open stream structure was created.
14946 *
14947 * We don't have to worry about calling 'open_stream_rele'
14948 * since we our currently holding a reference to this
14949 * open stream which means the count can not go to 0 with
14950 * this decrement.
14951 */
14959 }
14961 /*
14962 * Close all remaining open streams on the rnode. These open streams
14963 * could be here because:
14964 * - The close attempted at either close or delmap failed
14965 * - Some kernel entity did VOP_OPEN but never did VOP_CLOSE
14966 * - Someone did mknod on a regular file but never opened it
14967 */
14968 int
14970 {
14981 /*
14982 * At this point, all we know is that the last time
14983 * someone called vn_rele, the count was 1. Since then,
14984 * the vnode could have been re-activated. We want to
14985 * loop through the open streams and close each one, but
14986 * we have to be careful since once we release the rnode
14987 * hash bucket lock, someone else is free to come in and
14988 * re-activate the rnode and add new open streams. The
14989 * strategy is take the rnode hash bucket lock, verify that
14990 * the count is still 1, grab the open stream off the
14991 * head of the list and mark it invalid, then release the
14992 * rnode hash bucket lock and proceed with that open stream.
14993 * This is ok because nfs4close_one() will acquire the proper
14994 * open/create to close/destroy synchronization for open
14995 * streams, and will ensure that if someone has reopened
14996 * the open stream after we've dropped the hash bucket lock
14997 * then we'll just simply return without destroying the
14998 * open stream.
14999 * Repeat until the list is empty.
15000 */
15004 /* make sure vnode hasn't been reactivated */
15011 }
15012 /*
15013 * Grabbing r_os_lock before releasing v_lock prevents
15014 * a window where the rnode/open stream could get
15015 * reactivated (and os_force_close set to 0) before we
15016 * had a chance to set os_force_close to 1.
15017 */
15023 /* nothing left to CLOSE OTW, so return */
15027 }
15030 /* the file can't still be mem mapped */
15036 /*
15037 * Grab a ref on this open stream; nfs4close_one
15038 * will mark it as invalid
15039 */
15049 /* Update error if it isn't already non-zero */
15055 }
15057 #ifdef DEBUG
15058 nfs4close_all_cnt++;
15059 #endif
15060 /* Release the ref on osp acquired above. */
15063 /* Proceed to the next open stream, if any */
15064 }
15066 }
15068 /*
15069 * nfs4close_one - close one open stream for a file if needed.
15070 *
15071 * "close_type" indicates which close path this is:
15072 * CLOSE_NORM: close initiated via VOP_CLOSE.
15073 * CLOSE_DELMAP: close initiated via VOP_DELMAP.
15074 * CLOSE_FORCE: close initiated via VOP_INACTIVE. This path forces
15075 * the close and release of client state for this open stream
15076 * (unless someone else has the open stream open).
15077 * CLOSE_RESEND: indicates the request is a replay of an earlier request
15078 * (e.g., due to abort because of a signal).
15079 * CLOSE_AFTER_RESEND: close initiated to "undo" a successful resent OPEN.
15080 *
15081 * CLOSE_RESEND and CLOSE_AFTER_RESEND will not attempt to retry after client
15082 * recovery. Instead, the caller is expected to deal with retries.
15083 *
15084 * The caller can either pass in the osp ('provided_osp') or not.
15085 *
15086 * 'access_bits' represents the access we are closing/downgrading.
15087 *
15088 * 'len', 'prot', and 'mmap_flags' are used for CLOSE_DELMAP. 'len' is the
15089 * number of bytes we are unmapping, 'maxprot' is the mmap protection, and
15090 * 'mmap_flags' tells us the type of sharing (MAP_PRIVATE or MAP_SHARED).
15091 *
15092 * Errors are returned via the nfs4_error_t.
15093 */
15094 void
15098 uint_t mmap_flags)
15099 {
15106 nfs4_recov_state_t recov_state;
15131 /*
15132 * First get the open owner.
15133 */
15140 }
15144 "nfs4close_one: no oop, rp %p, mi %p, cr %p, osp %p, "
15149 }
15152 recov_retry:
15165 /*
15166 * Second synchronize with recovery.
15167 */
15175 /*
15176 * If we couldn't get start_fop, but have to
15177 * cleanup state, then at least acquire the
15178 * mi_recovlock so we can synchronize with
15179 * recovery.
15180 */
15187 }
15188 }
15190 /*
15191 * We cannot attempt to get the open seqid sync if nfs4_start_fop
15192 * set 'recovonly' to TRUE since most likely this is due to
15193 * reovery being active (MI4_RECOV_ACTIV). If recovery is active,
15194 * nfs4_start_open_seqid_sync() will fail with EAGAIN asking us
15195 * to retry, causing us to loop until recovery finishes. Plus we
15196 * don't need protection over the open seqid since we're not going
15197 * OTW, hence don't need to use the seqid.
15198 */
15200 /* need to grab the open owner sync before 'os_sync_lock' */
15210 }
15212 }
15214 /*
15215 * Third get an open stream and acquire 'os_sync_lock' to
15216 * sychronize the opening/creating of an open stream with the
15217 * closing/destroying of an open stream.
15218 */
15220 /* returns with 'os_sync_lock' held */
15225 }
15230 }
15235 /*
15236 * Fourth, do any special pre-OTW CLOSE processing
15237 * based on the specific close type.
15238 */
15246 }
15249 /* see if somebody reopened the open stream. */
15252 "nfs4close_one: skip CLOSE_FORCE as osp %p "
15257 }
15262 }
15264 /*
15265 * We can't depend on os_open_ref_count being 0 due to the
15266 * way executables are opened (VN_RELE to match a VOP_OPEN).
15267 */
15268 #ifdef NOTYET
15270 #endif
15273 "nfs4close_one: should panic here on an "
15274 "ASSERT(osp->os_open_ref_count == 0). Ignoring "
15278 }
15280 /*
15281 * There is the possibility that nfs4close_one()
15282 * for close_type == CLOSE_DELMAP couldn't find the
15283 * open stream, thus couldn't decrement its os_mapcnt;
15284 * therefore we can't use this ASSERT yet.
15285 */
15286 #ifdef NOTYET
15288 #endif
15290 }
15301 /* mirror the PROT_NONE check in nfs4_addmap() */
15307 }
15310 nfs4_lost_rqst_t lost_rqst;
15312 /* request should not already be in recovery queue */
15325 }
15327 /*
15328 * If a previous OTW call got NFS4ERR_BAD_SEQID, then
15329 * we stopped operating on the open owner's <old oo_name, old seqid>
15330 * space, which means we stopped operating on the open stream
15331 * too. So don't go OTW (as the seqid is likely bad, and the
15332 * stateid could be stale, potentially triggering a false
15333 * setclientid), and just clean up the client's internal state.
15334 */
15343 }
15345 /* If the file failed recovery, just quit. */
15349 }
15352 /*
15353 * If the force close path failed to obtain start_fop
15354 * then skip the OTW close and just remove the state.
15355 */
15359 /*
15360 * Fifth, check to see if there are still mapped pages or other
15361 * opens using this open stream. If there are then we can't
15362 * close yet but we can see if an OPEN_DOWNGRADE is necessary.
15363 */
15365 nfs4_lost_rqst_t new_lost_rqst;
15371 /*
15372 * If this open stream was never OPENed OTW then we
15373 * surely can't DOWNGRADE it (especially since the
15374 * osp->open_stateid is really a delegation stateid
15375 * when os_delegation is 1).
15376 */
15384 }
15389 bool_t abort;
15396 open_dg_seqid);
15417 }
15430 }
15432 }
15434 /*
15435 * If this open stream was created as the results of an open
15436 * while holding a delegation, then just release it; no need
15437 * to do an OTW close. Otherwise do a "normal" OTW close.
15438 */
15443 }
15445 /*
15446 * If this stream is not valid, we're done.
15447 */
15451 }
15453 /*
15454 * Last open or mmap ref has vanished, need to do an OTW close.
15455 * First check to see if a close is still necessary.
15456 */
15461 /*
15462 * Reopen of the open stream failed, hence the
15463 * stateid of the open stream is invalid/stale, and
15464 * sending this OTW would incorrectly cause another
15465 * round of recovery. In this case, we need to set
15466 * the 'os_valid' bit to 0 so another thread doesn't
15467 * come in and re-open this open stream before
15468 * this "closing" thread cleans up state (decrementing
15469 * the nfs4_server_t's state_ref_count and decrementing
15470 * the os_ref_count).
15471 */
15473 /*
15474 * This removes the reference obtained at OPEN; ie,
15475 * when the open stream structure was created.
15476 *
15477 * We don't have to worry about calling 'open_stream_rele'
15478 * since we our currently holding a reference to this
15479 * open stream which means the count can not go to 0 with
15480 * this decrement.
15481 */
15487 }
15491 /*
15492 * Sixth, try the CLOSE OTW.
15493 */
15498 /*
15499 * Let the recovery thread be responsible for
15500 * removing the state for CLOSE.
15501 */
15505 }
15507 /* See if we need to retry with a different cred */
15515 }
15524 }
15528 }
15537 "nfs4close_one: need to retry the close "
15540 }
15541 close_cleanup:
15542 /*
15543 * Seventh and lastly, process our results.
15544 */
15546 /*
15547 * It's ok to drop and regrab the 'os_sync_lock' since
15548 * nfs4close_notw() will recheck to make sure the
15549 * "close"/removal of state should happen.
15550 */
15554 }
15555 /*
15556 * This is last call, remove the ref on the open
15557 * stream created by open and clean everything up.
15558 */
15562 }
15573 }
15580 }
15582 }
15584 out:
15600 }
15601 }
15603 /*
15604 * Convert information returned by the server in the LOCK4denied
15605 * structure to the form required by fcntl.
15606 */
15607 static void
15609 {
15612 #ifdef DEBUG
15616 }
15617 #endif
15624 /*
15625 * If the blocking clientid matches our client id, then we can
15626 * interpret the lockowner (since we built it). If not, then
15627 * fabricate a sysid and pid. Note that the l_sysid field
15628 * in *flk already has the local sysid.
15629 */
15643 }
15648 /*
15649 * Construct a new sysid which should be different from
15650 * sysids of other systems.
15651 */
15655 }
15656 }
15658 static pid_t
15660 {
15676 }
15678 /*
15679 * Given a lock pointer, returns the length of that lock.
15680 * "end" is the last locked offset the "l_len" covers from
15681 * the start of the lock.
15682 */
15683 static off64_t
15685 {
15686 off64_t lock_end;
15690 else
15694 }
15696 /*
15697 * Given the end of a lock, it will return you the length "l_len" for that lock.
15698 */
15699 static off64_t
15701 {
15702 off64_t lock_len;
15707 else
15711 }
15713 /*
15714 * On given end for a lock it determines if it is the last locked offset
15715 * or not, if so keeps it as is, else adds one to return the length for
15716 * valid start.
15717 */
15718 static off64_t
15720 {
15723 else
15725 }
15727 /*
15728 * See if these two locks overlap, and if so return 1;
15729 * otherwise, return 0.
15730 */
15731 static int
15733 {
15744 }
15746 /*
15747 * Determine what the intersecting lock region is, and add that to the
15748 * 'nl_llpp' locklist in increasing order (by l_start).
15749 */
15750 static void
15753 {
15768 /* Find the starting point of the intersecting region */
15771 else
15774 /* Find the lenght of the intersecting region */
15777 else
15780 /*
15781 * Prepare the flock structure for the intersection found and insert
15782 * it into the new list in increasing l_start order. This list contains
15783 * intersections of locks registered by the client with the local host
15784 * and the lost lock.
15785 * The lock type of this lock is the same as that of the local_flp.
15786 */
15802 }
15804 /* first on the list */
15810 }
15817 }
15819 /*
15820 * Our local locking current state is potentially different than
15821 * what the NFSv4 server thinks we have due to a lost lock that was
15822 * resent and then received. We need to reset our "NFSv4" locking
15823 * state to match the current local locking state for this pid since
15824 * that is what the user/application sees as what the world is.
15825 *
15826 * We cannot afford to drop the open/lock seqid sync since then we can
15827 * get confused about what the current local locking state "is" versus
15828 * "was".
15829 *
15830 * If we are unable to fix up the locks, we send SIGLOST to the affected
15831 * process. This is not done if the filesystem has been forcibly
15832 * unmounted, in case the process has already exited and a new process
15833 * exists with the same pid.
15834 */
15835 static void
15838 {
15843 flock64_t ul_fl;
15848 /*
15849 * Find active locks for this vp from the local locking code.
15850 * Scan through this list and find out the locks that intersect with
15851 * the lost lock. Once we find the lock that intersects, add the
15852 * intersection area as a new lock to a new list "ri_llp". The lock
15853 * type of the intersection region lock added to ri_llp is the same
15854 * as that found in the active lock list, "list". The intersecting
15855 * region locks are added to ri_llp in increasing l_start order.
15856 */
15864 /*
15865 * Pick locks that belong to this pid/lockowner
15866 */
15871 }
15873 /*
15874 * Now we have the list of intersections with the lost lock. These are
15875 * the locks that were/are active before the server replied to the
15876 * last/lost lock. Issue these locks to the server here. Playing these
15877 * locks to the server will re-establish aur current local locking state
15878 * with the v4 server.
15879 * If we get an error, send SIGLOST to the application for that lock.
15880 */
15884 "nfs4_reinstitute_local_lock_state: need to issue "
15890 /*
15891 * No need to relock what we already have
15892 */
15897 }
15899 /*
15900 * Now keeping the start of the lost lock as our reference parse the
15901 * newly created ri_llp locklist to find the ranges that we have locked
15902 * with the v4 server but not in the current local locking. We need
15903 * to unlock these ranges.
15904 * These ranges can also be reffered to as those ranges, where the lost
15905 * lock does not overlap with the locks in the ri_llp but are locked
15906 * since the server replied to the lost lock.
15907 */
15922 }
15924 "nfs4_reinstitute_local_lock_state: "
15934 }
15936 /*
15937 * In the case where the lost lock ends after all intersecting locks,
15938 * unlock the last part of the lost lock range.
15939 */
15942 "nfs4_reinstitute_local_lock_state: UNLOCK end of the "
15947 /*
15948 * Is it an to-EOF lock? if so unlock till the end
15949 */
15952 else
15956 }
15961 /* Free up our newly created locklist */
15966 }
15968 /*
15969 * Now return back to the original calling nfs4frlock()
15970 * and let us naturally drop our seqid syncs.
15971 */
15972 }
15974 /*
15975 * Create a lost state record for the given lock reinstantiation request
15976 * and push it onto the lost state queue.
15977 */
15978 static void
15981 {
15982 nfs4_lost_rqst_t req;
15983 nfs_lock_type4 locktype;
15995 }