| blob | f1bb51bf5aea07aa1e917594dd7f91083f5e7e12 |
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 */
22 /*
23 * Copyright (c) 2016 STRATO AG. All rights reserved.
24 */
26 /*
27 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
28 */
30 /*
31 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
32 * Use is subject to license terms.
33 */
35 /*
36 * Copyright 1983,1984,1985,1986,1987,1988,1989 AT&T.
37 * All Rights Reserved
38 */
40 /*
41 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
42 */
44 #include <sys/param.h>
45 #include <sys/types.h>
46 #include <sys/systm.h>
47 #include <sys/cred.h>
48 #include <sys/time.h>
49 #include <sys/vnode.h>
50 #include <sys/vfs.h>
51 #include <sys/vfs_opreg.h>
52 #include <sys/file.h>
53 #include <sys/filio.h>
54 #include <sys/uio.h>
55 #include <sys/buf.h>
56 #include <sys/mman.h>
57 #include <sys/pathname.h>
58 #include <sys/dirent.h>
59 #include <sys/debug.h>
60 #include <sys/vmsystm.h>
61 #include <sys/fcntl.h>
62 #include <sys/flock.h>
63 #include <sys/swap.h>
64 #include <sys/errno.h>
65 #include <sys/strsubr.h>
66 #include <sys/sysmacros.h>
67 #include <sys/kmem.h>
68 #include <sys/cmn_err.h>
69 #include <sys/pathconf.h>
70 #include <sys/utsname.h>
71 #include <sys/dnlc.h>
72 #include <sys/acl.h>
73 #include <sys/systeminfo.h>
74 #include <sys/policy.h>
75 #include <sys/sdt.h>
76 #include <sys/list.h>
77 #include <sys/stat.h>
78 #include <sys/zone.h>
80 #include <rpc/types.h>
81 #include <rpc/auth.h>
82 #include <rpc/clnt.h>
84 #include <nfs/nfs.h>
85 #include <nfs/nfs_clnt.h>
86 #include <nfs/nfs_acl.h>
87 #include <nfs/lm.h>
88 #include <nfs/nfs4.h>
89 #include <nfs/nfs4_kprot.h>
90 #include <nfs/rnode4.h>
91 #include <nfs/nfs4_clnt.h>
93 #include <vm/hat.h>
94 #include <vm/as.h>
95 #include <vm/page.h>
96 #include <vm/pvn.h>
97 #include <vm/seg.h>
98 #include <vm/seg_map.h>
99 #include <vm/seg_kpm.h>
100 #include <vm/seg_vn.h>
102 #include <sys/fs_subr.h>
104 #include <sys/ddi.h>
105 #include <sys/int_fmtio.h>
106 #include <sys/fs/autofs.h>
111 hrtime_t di_time_call;
115 NFS4_ACL_GET,
116 NFS4_ACL_SET
128 cred_t *);
130 stable_how4 *);
134 vsecattr_t *);
145 caller_context_t *);
157 cred_t *);
169 cred_t *);
171 cred_t *);
177 uoff_t);
186 nfs4_lock_owner_t *);
196 /*
197 * Routines that implement the setting of v4 args for the misc. ops
198 */
203 nfs4_stateid_types_t *);
206 bitmap4);
211 /*
212 * These are the vnode ops functions that implement the vnode interface to
213 * the networked file system. See more comments below at nfs4_vnodeops.
214 */
217 caller_context_t *);
219 caller_context_t *);
221 caller_context_t *);
223 caller_context_t *);
225 caller_context_t *);
228 caller_context_t *);
232 vsecattr_t *);
252 caller_context_t *);
267 caller_context_t *);
269 caller_context_t *);
270 /*
271 * These vnode ops are required to be called from outside this source file,
272 * e.g. by ephemeral mount stub vnode ops, and so may not be declared
273 * as static.
274 */
276 caller_context_t *);
286 caller_context_t *);
288 caller_context_t *);
290 caller_context_t *);
292 /*
293 * Used for nfs4_commit_vp() to indicate if we should
294 * wait on pending writes.
295 */
296 #define NFS4_WRITE_NOWAIT 0
297 #define NFS4_WRITE_WAIT 1
301 /*
302 * Error flags used to pass information about certain special errors
303 * which need to be handled specially.
304 */
305 #define NFS_EOF -98
306 #define NFS_VERF_MISMATCH -97
308 /*
309 * Flags used to differentiate between which operation drove the
310 * potential CLOSE OTW. (see nfs4_close_otw_if_necessary)
311 */
312 #define NFS4_CLOSE_OP 0x1
313 #define NFS4_DELMAP_OP 0x2
314 #define NFS4_INACTIVE_OP 0x3
316 #define ISVDEV(t) ((t == VBLK) || (t == VCHR) || (t == VFIFO))
318 /* ALIGN64 aligns the given buffer and adjust buffer size to 64 bit */
319 #define ALIGN64(x, ptr, sz) \
320 x = ((uintptr_t)(ptr)) & (sizeof (uint64_t) - 1); \
321 if (x) { \
322 x = sizeof (uint64_t) - (x); \
323 sz -= (x); \
324 ptr += (x); \
325 }
327 #ifdef DEBUG
368 #endif
370 /*
371 * How long to wait before trying again if OPEN_CONFIRM gets ETIMEDOUT
372 * or NFS4ERR_RESOURCE.
373 */
378 /*
379 * number of pages to read ahead
380 * optimized for 100 base-T.
381 */
388 /*
389 * These are the vnode ops routines which implement the vnode interface to
390 * the networked file system. These routines just take their parameters,
391 * make them look networkish by putting the right info into interface structs,
392 * and then calling the appropriate remote routine(s) to do the work.
393 *
394 * Note on directory name lookup cacheing: If we detect a stale fhandle,
395 * we purge the directory cache relative to that vnode. This way, the
396 * user won't get burned by the cache repeatedly. See <nfs/rnode4.h> for
397 * more details on rnode locking.
398 */
435 /* no separate nfs4_dump */
444 NULL, NULL
445 };
447 /*
448 * The following are subroutines and definitions to set args or get res
449 * for the different nfsv4 ops
450 */
452 void
454 {
464 }
465 }
466 }
468 static void
470 {
480 }
481 }
482 }
484 static void
486 {
491 }
492 }
494 static void
498 {
503 /*
504 * The stateid is set to 0 if client is not modifying the size
505 * and otherwise to whatever nfs4_get_stateid() returns.
506 *
507 * XXX Note: nfs4_get_stateid() returns 0 if no lockowner and/or no
508 * state struct could be found for the process/file pair. We may
509 * want to change this in the future (by OPENing the file). See
510 * bug # 4474852.
511 */
523 }
528 }
530 static void
532 {
534 }
536 static int
538 bitmap4 supp)
539 {
553 }
559 }
561 static void
563 {
573 }
574 }
576 static void
579 {
589 }
591 void
593 {
597 }
601 }
602 }
604 /*
605 * XXX: This is referenced in modstubs.s
606 */
609 {
611 }
613 /*
614 * The OPEN operation opens a regular file.
615 */
616 /*ARGSUSED3*/
617 static int
619 {
631 /*
632 * Check to see if opening something besides a regular file;
633 * if so skip the OTW call
634 */
638 }
640 /*
641 * XXX - would like a check right here to know if the file is
642 * executable or not, so as to skip OTW
643 */
655 }
657 /*
658 * See if this file has just been CREATEd.
659 * If so, clear the flag and update the dnlc, which was previously
660 * skipped in nfs4_create.
661 * XXX need better serilization on this.
662 * XXX move this into the nf4open_otw call, after we have
663 * XXX acquired the open owner seqid sync.
664 */
671 /* This is needed so we don't bump the open ref count */
676 }
678 /*
679 * If caller specified O_TRUNC/FTRUNC, then be sure to set
680 * FWRITE (to drive successful setattr(size=0) after open)
681 */
686 just_been_created);
693 /* release the hold from vtodv */
696 /* exchange the shadow for the master vnode, if needed */
702 }
704 /*
705 * See if there's a "lost open" request to be saved and recovered.
706 */
707 static void
711 {
721 }
728 /*
729 * The vp (if it is not NULL) and dvp are held and rele'd via
730 * the recovery code. See nfs4_save_lost_rqst.
731 */
748 }
753 }
756 uint32 seconds;
757 uint32 nseconds;
758 };
760 /*
761 * The OPEN operation creates and/or opens a regular file
762 *
763 * ARGSUSED
764 */
765 static int
769 {
778 COMPOUND4args_clnt args;
779 COMPOUND4res_clnt res;
798 nfs4_recov_state_t recov_state;
799 nfs4_lost_rqst_t lost_rqst;
801 hrtime_t t;
812 /*
813 * Make sure we properly deal with setting the right gid on
814 * a newly created file to reflect the parent's setgid bit
815 */
819 /*
820 * If there is grpid mount flag used or
821 * the parent's directory has the setgid bit set
822 * _and_ the client was able to get a valid mapping
823 * for the parent dir's owner_group, we want to
824 * append NVERIFY(owner_group == dva.va_gid) and
825 * SETATTR to the CREATE compound.
826 */
834 }
836 }
838 /*
839 * Normal/non-create compound:
840 * PUTFH(dfh) + OPEN(create) + GETFH + GETATTR(new)
841 *
842 * Open(create) compound no setgid:
843 * PUTFH(dfh) + SAVEFH + OPEN(create) + GETFH + GETATTR(new) +
844 * RESTOREFH + GETATTR
845 *
846 * Open(create) setgid:
847 * PUTFH(dfh) + OPEN(create) + GETFH + GETATTR(new) +
848 * SAVEFH + PUTFH(dfh) + GETATTR(dvp) + RESTOREFH +
849 * NVERIFY(grp) + SETATTR
850 */
863 }
875 /*
876 * We are to create a file. Initialize the passed in vnode
877 * pointer.
878 */
881 /*
882 * Check to see if the client owns a read delegation and is
883 * trying to open for write. If so, then return the delegation
884 * to avoid the server doing a cb_recall and returning DELAY.
885 * NB - we don't use the statev4_lock here because we'd have
886 * to drop the lock anyway and the result would be stale.
887 */
892 /*
893 * If the file has a delegation, then do an access check up
894 * front. This avoids having to an access check later after
895 * we've already done start_op, which could deadlock.
896 */
904 }
905 }
913 recov_retry:
923 }
929 /* putfh directory fh */
933 /* OPEN: either op 1 or op 2 depending upon create/setgid flags */
938 /* name of file */
944 /* CREATE a file */
953 timestruc_t now;
958 }
959 /*
960 * Since the server will use this value for the
961 * mtime, make sure that it can't overflow. Zero
962 * out the MSB. The actual value does not matter
963 * here, only its uniqeness.
964 */
967 }
969 /* Now copy over verifier to OPEN4args. */
973 bitmap4 supp_attrs;
983 /* GUARDED4 or UNCHECKED4 */
985 supp_attrs);
995 }
996 }
998 /* NO CREATE */
1000 }
1007 /* XXX should we just fail here? */
1009 }
1011 /*
1012 * This increments oop's ref count or creates a temporary 'just_created'
1013 * open owner that will become valid when this OPEN/OPEN_CONFIRM call
1014 * completes.
1015 */
1018 /* See if a permanent or just created open owner exists */
1021 /*
1022 * This open owner does not exist so create a temporary
1023 * just created one.
1024 */
1027 }
1030 /* this length never changes, do alloc before seqid sync */
1043 }
1045 }
1047 /* Check to see if we need to do the OTW call */
1052 /*
1053 * The OTW open is not necessary. Either
1054 * the open can succeed without it (eg.
1055 * delegation, error == 0) or the open
1056 * must fail due to an access failure
1057 * (error != 0). In either case, tidy
1058 * up and return.
1059 */
1069 }
1070 }
1086 /*
1087 * getfh w/sanity check for idx_open/idx_fattr
1088 */
1092 /* getattr */
1098 vattr_t _v;
1100 bitmap4 supp_attrs;
1107 /*
1108 * For setgid case, we need to:
1109 * 4:savefh(new) 5:putfh(dir) 6:getattr(dir) 7:restorefh(new)
1110 */
1122 /*
1123 * nverify
1124 */
1128 supp_attrs))) {
1130 /*
1131 * setattr
1132 *
1133 * We _know_ we're not messing with AT_SIZE or
1134 * AT_XTIME, so no need for stateid or flags.
1135 * Also we specify NULL rp since we're only
1136 * interested in setting owner_group attributes.
1137 */
1142 }
1145 /*
1146 * XXX - Revisit the last argument to nfs4_end_op()
1147 * once 5020486 is fixed.
1148 */
1157 }
1166 }
1194 num_bseqid_retry--;
1195 }
1203 /* give up if we keep getting BAD_SEQID */
1208 }
1216 }
1222 }
1227 }
1229 }
1231 /*
1232 * Will check and update lease after checking the rflag for
1233 * OPEN_CONFIRM in the successful OPEN call.
1234 */
1237 /*
1238 * XXX what if we're crossing mount points from server1:/drp
1239 * to server2:/drp/rp.
1240 */
1242 /* Signal our end of use of the open seqid */
1245 /*
1246 * This will destroy the open owner if it was just created,
1247 * and no one else has put a reference on it.
1248 */
1259 }
1262 /*
1263 * If the reply is NFS4ERR_ACCESS, it may be because
1264 * we are root (no root net access). If the real uid
1265 * is not root, then retry with the real uid instead.
1266 */
1270 }
1275 }
1278 }
1283 #ifdef DEBUG
1284 /*
1285 * verify attrset bitmap
1286 */
1289 /* make sure attrset returned is what we asked for */
1290 /* XXX Ignore this 'error' for now */
1293 }
1294 #endif
1300 }
1307 /*
1308 * The open stateid has been updated on the server but not
1309 * on the client yet. There is a path: makenfs4node->nfs4_attr_cache->
1310 * flush_pages->fop_putpage->...->nfs4write where we will issue an OTW
1311 * WRITE call. That, however, will use the old stateid, so go ahead
1312 * and upate the open stateid now, before any call to makenfs4node.
1313 */
1323 }
1325 /*
1326 * We must determine if the file handle given by the otw open
1327 * is the same as the file handle which was passed in with
1328 * *vpp. This case can be reached if the file we are trying
1329 * to open has been removed and another file has been created
1330 * having the same file name. The passed in vnode is released
1331 * later.
1332 */
1335 }
1347 /*
1348 * For the newly created vp case, make sure the rnode
1349 * isn't bad before using it.
1350 */
1362 }
1365 needrecov);
1373 }
1376 }
1379 /*
1380 * It seems odd to get a full set of attrs and then not update
1381 * the object's attrcache in the non-create case. Create case uses
1382 * the attrs since makenfs4node checks to see if the attrs need to
1383 * be updated (and then updates them). The non-create case should
1384 * update attrs also.
1385 */
1388 }
1392 /* This does not do recovery for vp explicitly. */
1402 }
1405 needrecov);
1408 /* rele the makenfs4node */
1410 }
1414 }
1417 "nfs4open_otw: retry the open since OPEN "
1423 "createmode from GUARDED4 to "
1426 }
1428 }
1435 }
1438 }
1439 }
1449 /* Doesn't matter if 'oo_just_created' already was set as this */
1457 /* returns with 'os_sync_lock' held */
1471 }
1482 }
1492 /*
1493 * Need to reset this bitfield for the possible case where we were
1494 * going to OTW CLOSE the file, got a non-recoverable error, and before
1495 * we could retry the CLOSE, OPENed the file again.
1496 */
1500 #ifdef DEBUG
1505 #endif
1516 }
1518 /* get rid of our reference to find oop */
1523 /* accept delegation, if any */
1532 /*
1533 * If doing an exclusive create, then generate
1534 * a SETATTR to set the initial attributes.
1535 * Try to set the mtime and the atime to the
1536 * server's current time. It is somewhat
1537 * expected that these fields will be used to
1538 * store the exclusive create cookie. If not,
1539 * server implementors will need to know that
1540 * a SETATTR will follow an exclusive create
1541 * and the cookie should be destroyed if
1542 * appropriate.
1543 *
1544 * The AT_GID and AT_SIZE bits are turned off
1545 * so that the SETATTR request will not attempt
1546 * to process these. The gid will be set
1547 * separately if appropriate. The size is turned
1548 * off because it is assumed that a new file will
1549 * be created empty and if the file wasn't empty,
1550 * then the exclusive create will have failed
1551 * because the file must have existed already.
1552 * Therefore, no truncate operation is needed.
1553 */
1559 /*
1560 * Couldn't correct the attributes of
1561 * the newly created file and the
1562 * attributes are wrong. Remove the
1563 * file and return an error to the
1564 * application.
1565 */
1566 /* XXX will this take care of client state ? */
1568 "nfs4open_otw: EXCLUSIVE4: error %d on SETATTR:"
1572 /*
1573 * Since we've reled the vnode and removed
1574 * the file we now need to return the error.
1575 * At this point we don't want to update the
1576 * dircaches, call nfs4_waitfor_purge_complete
1577 * or set vpp to vp so we need to skip these
1578 * as well.
1579 */
1581 }
1582 }
1584 /*
1585 * If we created or found the correct vnode, due to create_flag or
1586 * fh_differs being set, then update directory cache attribute, readdir
1587 * and dnlc caches.
1588 */
1592 /*
1593 * Make sure getattr succeeded before using results.
1594 * note: op 7 is getattr(dir) for both flavors of
1595 * open(create).
1596 */
1605 }
1608 dinfop);
1609 }
1611 /*
1612 * If the page cache for this file was flushed from actions
1613 * above, it was done asynchronously and if that is true,
1614 * there is a need to wait here for it to complete. This must
1615 * be done outside of start_fop/end_fop.
1616 */
1619 /*
1620 * It is implicit that we are in the open case (create_flag == 0) since
1621 * fh_differs can only be set to a non-zero value in the open case.
1622 */
1626 /*
1627 * Be sure to set *vpp to the correct value before returning.
1628 */
1631 skip_update_dircaches:
1637 }
1644 }
1646 /*
1647 * Reopen an open instance. cf. nfs4open_otw().
1648 *
1649 * Errors are returned by the nfs4_error_t parameter.
1650 * - ep->error contains an errno value or zero.
1651 * - if it is zero, ep->stat is set to an NFS status code, if any.
1652 * If the file could not be reopened, but the caller should continue, the
1653 * file is marked dead and no error values are returned. If the caller
1654 * should stop recovering open files and start over, either the ep->error
1655 * value or ep->stat will indicate an error (either something that requires
1656 * recovery or EAGAIN). Note that some recovery (e.g., expired volatile
1657 * filehandles) may be handled silently by this routine.
1658 * - if it is EINTR, ETIMEDOUT, or NFS4_FRC_UNMT_ERR, recovery for lost state
1659 * will be started, so the caller should not do it.
1660 *
1661 * Gotos:
1662 * - kill_file : reopen failed in such a fashion to constitute marking the
1663 * file dead and setting the open stream's 'os_failed_reopen' as 1. This
1664 * is for cases where recovery is not possible.
1665 * - failed_reopen : same as above, except that the file has already been
1666 * marked dead, so no need to do it again.
1667 * - bailout : reopen failed but we are able to recover and retry the reopen -
1668 * either within this function immediately or via the calling function.
1669 */
1671 void
1674 bool_t is_recov)
1675 {
1676 COMPOUND4args_clnt args;
1677 COMPOUND4res_clnt res;
1687 seqid4 seqid;
1691 nfs4_lost_rqst_t lost_rqst;
1693 bool_t abort;
1696 hrtime_t t;
1704 /* this is the cred used to find the open owner */
1709 }
1710 /* use this cred for OTW operations */
1713 top:
1717 /* File system has been unmounted, quit */
1721 }
1729 }
1737 }
1739 /*
1740 * If the rnode has a delegation and the delegation has been
1741 * recovered and the server didn't request a recall and the caller
1742 * didn't specifically ask for CLAIM_PREVIOUS (nfs4frlock during
1743 * recovery) and the rnode hasn't been marked dead, then install
1744 * the delegation stateid in the open stream. Otherwise, proceed
1745 * with a CLAIM_PREVIOUS or CLAIM_NULL OPEN.
1746 */
1760 }
1763 /*
1764 * If the file failed recovery, just quit. This failure need not
1765 * affect other reopens, so don't return an error.
1766 */
1772 }
1775 /*
1776 * argop is empty here
1777 *
1778 * PUTFH, OPEN, GETATTR
1779 */
1791 /*
1792 * if this is a file mount then
1793 * use the mntinfo parentfh
1794 */
1799 /* putfh fh to reopen */
1801 }
1815 /* nothing allocated yet */
1817 }
1822 /*
1823 * We have two cases to deal with here:
1824 * 1) We're being called to reopen files in order to satisfy
1825 * a lock operation request which requires us to explicitly
1826 * reopen files which were opened under a delegation. If
1827 * we're in recovery, we *must* use CLAIM_PREVIOUS. In
1828 * that case, frc_use_claim_previous is TRUE and we must
1829 * use the rnode's current delegation type (r_deleg_type).
1830 * 2) We're reopening files during some form of recovery.
1831 * In this case, frc_use_claim_previous is FALSE and we
1832 * use the delegation type appropriate for recovery
1833 * (r_deleg_needs_recovery).
1834 */
1837 frc_use_claim_previous ?
1846 "failed for vp 0x%p for CLAIM_DELEGATE_CUR "
1850 /* nothing allocated yet */
1852 }
1860 }
1892 /* Construct the getfh part of the compound */
1895 /* Construct the getattr part of the compound */
1916 }
1928 }
1933 }
1944 }
1969 /*
1970 * Retry as a plain open. We don't need to worry about
1971 * checking the changeinfo: it is acceptable for a
1972 * client to re-open a file and continue processing
1973 * (in the absence of locks).
1974 */
1976 "nfs4_reopen: CLAIM_PREVIOUS: NFS4ERR_NO_GRACE; "
1981 }
1982 failed_msg =
2009 /* recover filehandle and retry */
2025 /*
2026 * Do not mark the file dead and let the calling
2027 * function initiate recovery.
2028 */
2046 }
2047 /* fall through */
2057 }
2064 /*
2065 * Check if the path we reopened really is the same
2066 * file. We could end up in a situation where the file
2067 * was removed and a new file created with the same name.
2068 */
2076 /* Oops, we don't have the same file */
2080 else
2090 /*
2091 * We have volatile file handles that don't compare.
2092 * If the fids are the same then we assume that the
2093 * file handle expired but the rnode still refers to
2094 * the same file object.
2095 *
2096 * First check that we have fids or not.
2097 * If we don't we have a dumb server so we will
2098 * just assume every thing is ok for now.
2099 */
2103 /*
2104 * We have fids, but they don't
2105 * compare. So kill the file.
2106 */
2107 failed_msg =
2108 "Couldn't reopen: file handle changed"
2116 /*
2117 * We have volatile file handles that refers
2118 * to the same file (at least they have the
2119 * same fid) or we don't have fids so we
2120 * can't tell. :(. We'll be a kind and accepting
2121 * client so we'll update the rnode's file
2122 * handle with the otw handle.
2123 *
2124 * We need to drop mi->mi_fh_lock since
2125 * sh4_update acquires it. Since there is
2126 * only one recovery thread there is no
2127 * race.
2128 */
2131 }
2132 }
2135 }
2139 /*
2140 * If the server wanted an OPEN_CONFIRM but that fails, just start
2141 * over. Presumably if there is a persistent error it will show up
2142 * when we resend the OPEN.
2143 */
2157 }
2158 }
2163 /*
2164 * Need to reset this bitfield for the possible case where we were
2165 * going to OTW CLOSE the file, got a non-recoverable error, and before
2166 * we could retry the CLOSE, OPENed the file again.
2167 */
2177 /* accept delegation, if any */
2193 kill_file:
2195 failed_reopen:
2202 bailout:
2206 }
2211 }
2213 /* for . and .. OPENs */
2214 /* ARGSUSED */
2215 static int
2217 {
2219 nfs4_ga_res_t gar;
2223 /*
2224 * If close-to-open consistency checking is turned off or
2225 * if there is no cached data, we can avoid
2226 * the over the wire getattr. Otherwise, force a
2227 * call to the server to get fresh attributes and to
2228 * check caches. This is required for close-to-open
2229 * consistency.
2230 */
2237 }
2239 /*
2240 * CLOSE a file
2241 */
2242 /* ARGSUSED */
2243 static int
2246 {
2253 /*
2254 * Remove client state for this (lockowner, file) pair.
2255 * Issue otw v4 call to have the server do the same.
2256 */
2260 /*
2261 * zone_enter(2) prevents processes from changing zones with NFS files
2262 * open; if we happen to get here from the wrong zone we can't do
2263 * anything over the wire.
2264 */
2266 /*
2267 * We could attempt to clean up locks, except we're sure
2268 * that the current process didn't acquire any locks on
2269 * the file: any attempt to lock a file belong to another zone
2270 * will fail, and one can't lock an NFS file and then change
2271 * zones, as that fails too.
2272 *
2273 * Returning an error here is the sane thing to do. A
2274 * subsequent call to VN_RELE() which translates to a
2275 * nfs4_inactive() will clean up state: if the zone of the
2276 * vnode's origin is still alive and kicking, the inactive
2277 * thread will handle the request (from the correct zone), and
2278 * everything (minus the OTW close call) should be OK. If the
2279 * zone is going away nfs4_async_inactive() will throw away
2280 * delegations, open streams and cached pages inline.
2281 */
2283 }
2285 /*
2286 * If we are using local locking for this filesystem, then
2287 * release all of the SYSV style record locks. Otherwise,
2288 * we are doing network locking and we need to release all
2289 * of the network locks. All of the locks held by this
2290 * process on this file are released no matter what the
2291 * incoming reference count is.
2292 */
2310 }
2312 }
2317 /*
2318 * If the file has been `unlinked', then purge the
2319 * DNLC so that this vnode will get reycled quicker
2320 * and the .nfs* file on the server will get removed.
2321 */
2325 /*
2326 * If the file was open for write and there are pages,
2327 * do a synchronous flush and commit of all of the
2328 * dirty and uncommitted pages.
2329 */
2339 /*
2340 * If this file type is one for which no explicit 'open' was
2341 * done, then bail now (ie. no need for protocol 'close'). If
2342 * there was an error w/the vm subsystem, return _that_ error,
2343 * otherwise, return any errors that may've been reported via
2344 * the rnode.
2345 */
2349 /*
2350 * The sync putpage commit may have failed above, but since
2351 * we're working w/a regular file, we need to do the protocol
2352 * 'close' (nfs4close_one will figure out if an otw close is
2353 * needed or not). Report any errors _after_ doing the protocol
2354 * 'close'.
2355 */
2359 /*
2360 * Error reporting prio (Hi -> Lo)
2361 *
2362 * i) nfs4_putpage_commit (error)
2363 * ii) rnode's (r_error)
2364 * iii) nfs4close_one (n4error)
2365 */
2367 }
2369 /*
2370 * Initialize *lost_rqstp.
2371 */
2373 static void
2377 {
2382 }
2388 /*
2389 * The vp is held and rele'd via the recovery code.
2390 * See nfs4_save_lost_rqst.
2391 */
2403 }
2405 /*
2406 * Assumes you already have the open seqid sync grabbed as well as the
2407 * 'os_sync_lock'. Note: this will release the open seqid sync and
2408 * 'os_sync_lock' if client recovery starts. Calling functions have to
2409 * be prepared to handle this.
2410 *
2411 * 'recov' is returned as 1 if the CLOSE operation detected client recovery
2412 * was needed and was started, and that the calling function should retry
2413 * this function; otherwise it is returned as 0.
2414 *
2415 * Errors are returned via the nfs4_error_t parameter.
2416 */
2417 static void
2421 {
2422 COMPOUND4args_clnt args;
2423 COMPOUND4res_clnt res;
2429 seqid4 seqid;
2432 nfs4_lost_rqst_t lost_rqst;
2433 hrtime_t t;
2441 /* Only set this to 1 if recovery is started */
2444 /* do the OTW call to close the file */
2450 else
2460 /* putfh target fh */
2486 }
2490 /*
2491 * if there was an error and no recovery is to be done
2492 * then then set up the file to flush its cache if
2493 * needed for the next caller.
2494 */
2500 }
2503 bool_t abort;
2515 "nfs4close_otw: initiating recovery. error %d "
2518 /*
2519 * Drop the 'os_sync_lock' here so we don't hit
2520 * a potential recursive mutex_enter via an
2521 * 'open_stream_hold()'.
2522 */
2530 /* drop open seq sync, and let the calling function regrab it */
2536 /*
2537 * For signals, the caller wants to quit, so don't say to
2538 * retry. For forced unmount, if it's a user thread, it
2539 * wants to quit. If it's a recovery thread, the retry
2540 * will happen higher-up on the call stack. Either way,
2541 * don't say to retry.
2542 */
2548 else
2554 }
2559 }
2569 /*
2570 * This removes the reference obtained at OPEN; ie, when the
2571 * open stream structure was created.
2572 *
2573 * We don't have to worry about calling 'open_stream_rele'
2574 * since we our currently holding a reference to the open
2575 * stream which means the count cannot go to 0 with this
2576 * decrement.
2577 */
2582 /*
2583 * Avoid a deadlock with the r_serial thread waiting for
2584 * os_sync_lock in nfs4_get_otw_cred_by_osp() which might be
2585 * held by us. We will wait in nfs4_attr_cache() for the
2586 * completion of the r_serial thread.
2587 */
2594 }
2600 }
2602 /* ARGSUSED */
2603 static int
2606 {
2608 uoff_t off;
2609 offset_t diff;
2610 uint_t on;
2611 uint_t n;
2612 caddr_t base;
2613 uint_t flags;
2641 else
2647 /*
2648 * Bypass VM if caching has been disabled (e.g., locking) or if
2649 * using client-side direct I/O and the file is not mmap'd and
2650 * there are no cached pages.
2651 */
2659 }
2676 }
2677 }
2686 /*
2687 * Copy data.
2688 */
2693 S_READ);
2696 }
2699 /*
2700 * If read a whole block or read to eof,
2701 * won't need this buffer again soon.
2702 */
2707 else
2714 }
2720 }
2721 }
2725 }
2727 /* ARGSUSED */
2728 static int
2731 {
2734 uoff_t off;
2735 caddr_t base;
2736 uint_t flags;
2742 uoff_t offset;
2744 uint_t bsize;
2765 else
2774 /*
2775 * Must serialize if appending.
2776 */
2782 }
2789 }
2799 /*
2800 * Check to make sure that the process will not exceed
2801 * its limit on file size. It is okay to write up to
2802 * the limit, but not beyond. Thus, the write which
2803 * reaches the limit will be short and the next write
2804 * will return an error.
2805 */
2819 }
2820 }
2822 /* update the change attribute, if we have a write delegation */
2833 /*
2834 * Bypass VM if caching has been disabled (e.g., locking) or if
2835 * using client-side direct I/O and the file is not mmap'd and
2836 * there are no cached pages.
2837 */
2843 uoff_t org_offset;
2844 stable_how4 stab_comm;
2845 nfs4_fwrite:
2850 /*
2851 * A close may have cleared r_error, if so,
2852 * propagate ESTALE error return properly
2853 */
2857 }
2864 else
2879 }
2880 }
2884 }
2898 /*
2899 * A close may have cleared r_error, if so,
2900 * propagate ESTALE error return properly
2901 */
2905 }
2907 /*
2908 * Don't create dirty pages faster than they
2909 * can be cleaned so that the system doesn't
2910 * get imbalanced. If the async queue is
2911 * maxed out, then wait for it to drain before
2912 * creating more dirty pages. Also, wait for
2913 * any threads doing pagewalks in the vop_getattr
2914 * entry points so that they don't block for
2915 * long periods.
2916 */
2932 }
2937 }
2940 /*
2941 * Touch the page and fault it in if it is not in core
2942 * before segmap_getmapflt or vpm_data_copy can lock it.
2943 * This is to avoid the deadlock if the buffer is mapped
2944 * to the same file through mmap which we want to write.
2945 */
2949 /*
2950 * It will use kpm mappings, so no need to
2951 * pass an address.
2952 */
2970 pagecreate);
2976 }
2977 }
2984 /*
2985 * Have written a whole block.
2986 * Start an asynchronous write
2987 * and mark the buffer to
2988 * indicate that it won't be
2989 * needed again soon.
2990 */
2998 }
3003 }
3009 }
3010 /*
3011 * In the event that we got an access error while
3012 * faulting in a page for a write-only file just
3013 * force a write.
3014 */
3017 }
3020 bottom:
3031 }
3033 }
3038 }
3040 /*
3041 * Flags are composed of {B_ASYNC, B_INVAL, B_FREE, B_DONTNEED}
3042 */
3043 static int
3046 {
3050 uchar_t fsdata;
3051 stable_how4 stab_comm;
3057 /*
3058 * pageio_setup should have set b_addr to 0. This
3059 * is correct since we want to do I/O on a page
3060 * boundary. bp_mapin will use this addr to calculate
3061 * an offset, and then set b_addr to the kernel virtual
3062 * address it allocated for us.
3063 */
3076 else
3086 else
3095 }
3097 /*
3098 */
3099 static int
3101 {
3115 /* returns with 'os_sync_lock' held */
3120 }
3127 }
3129 /*
3130 * Determine whether a reopen is needed. If this
3131 * is a delegation open stream, then the os_delegation bit
3132 * should be set.
3133 */
3148 }
3150 }
3154 }
3156 /*
3157 * Write to file. Writes to remote server in largest size
3158 * chunks that the server can handle. Write is synchronous.
3159 */
3160 static int
3163 {
3165 COMPOUND4args_clnt args;
3166 COMPOUND4res_clnt res;
3172 stable_how4 stable;
3175 bool_t needrecov;
3176 nfs4_recov_state_t recov_state;
3177 nfs4_stateid_types_t sid_types;
3194 /* Is curthread the recovery thread? */
3199 recov_retry:
3209 }
3211 /* 0. putfh target fh */
3215 /* 1. write */
3227 }
3233 else
3242 }
3250 }
3254 }
3256 /*
3257 * Do handling of OLD_STATEID outside
3258 * of the normal recovery framework.
3259 *
3260 * If write receives a BAD stateid error while using a
3261 * delegation stateid, retry using the open stateid (if it
3262 * exists). If it doesn't have an open stateid, reopen the
3263 * file first, then retry.
3264 */
3286 }
3290 /* hold needed for nfs4delegreturn_thread */
3296 }
3299 bool_t abort;
3302 "nfs4write: client got error %d, res.status %d"
3312 }
3318 }
3327 }
3342 }
3350 "nfs4write: server %s did not commit "
3357 }
3358 }
3368 tsize;
3370 }
3377 }
3381 }
3392 needrecov);
3395 }
3397 /*
3398 * Read from a file. Reads data in largest chunks our interface can handle.
3399 */
3400 static int
3403 {
3405 COMPOUND4args_clnt args;
3406 COMPOUND4res_clnt res;
3413 bool_t is_eof;
3415 nfs4_recov_state_t recov_state;
3416 nfs4_stateid_types_t sid_types;
3435 recov_retry:
3441 /* putfh target fh */
3445 /* read */
3456 }
3467 else
3480 else
3485 #ifdef DEBUG
3489 }
3490 #endif
3496 }
3503 }
3505 /*
3506 * Do proper retry for OLD and BAD stateid errors outside
3507 * of the normal recovery framework. There are two differences
3508 * between async and sync reads. The first is that we allow
3509 * retry on BAD_STATEID for async reads, but not sync reads.
3510 * The second is that we mark the file dead for a failed
3511 * attempt with a special stateid for sync reads, but just
3512 * return EIO for async reads.
3513 *
3514 * If a sync read receives a BAD stateid error while using a
3515 * delegation stateid, retry using the open stateid (if it
3516 * exists). If it doesn't have an open stateid, reopen the
3517 * file first, then retry.
3518 */
3527 }
3550 }
3553 /* hold needed for nfs4delegreturn_thread */
3559 }
3561 bool_t abort;
3570 /*
3571 * Do not retry if we got OLD_STATEID using a special
3572 * stateid. This avoids looping with a broken server.
3573 */
3579 /*
3580 * Need to retry all possible stateids in
3581 * case the recovery error wasn't stateid
3582 * related or the stateids have become
3583 * stale (server reboot).
3584 */
3589 }
3595 }
3597 }
3605 }
3617 }
3629 }
3631 /* ARGSUSED */
3632 static int
3635 {
3643 }
3644 }
3646 /* ARGSUSED */
3647 int
3650 {
3656 /*
3657 * If it has been specified that the return value will
3658 * just be used as a hint, and we are only being asked
3659 * for size, fsid or rdevid, then return the client's
3660 * notion of these values without checking to make sure
3661 * that the attribute cache is up to date.
3662 * The whole point is to avoid an over the wire GETATTR
3663 * call.
3664 */
3676 }
3677 }
3679 /*
3680 * Only need to flush pages if asking for the mtime
3681 * and if there any dirty pages or any outstanding
3682 * asynchronous (write) requests for this file.
3683 */
3695 error =
3703 }
3707 }
3710 }
3711 }
3712 }
3714 }
3716 int
3718 {
3719 /*
3720 * If these are the only two bits cleared
3721 * on the server then return 0 (OK) else
3722 * return 1 (BAD).
3723 */
3727 else
3729 }
3731 /*ARGSUSED4*/
3732 static int
3735 {
3744 /*
3745 * Don't call secpolicy_vnode_setattr, the client cannot
3746 * use its cached attributes to make security decisions
3747 * as the server may be faking mode bits or mapping uid/gid.
3748 * Always just let the server to the checking.
3749 * If we provide the ability to remove basic priviledges
3750 * to setattr (e.g. basic without chmod) then we will
3751 * need to add a check here before calling the server.
3752 */
3759 }
3761 /*
3762 * To replace the "guarded" version 3 setattr, we use two types of compound
3763 * setattr requests:
3764 * 1. The "normal" setattr, used when the size of the file isn't being
3765 * changed - { Putfh <fh>; Setattr; Getattr }/
3766 * 2. If the size is changed, precede Setattr with: Getattr; Verify
3767 * with only ctime as the argument. If the server ctime differs from
3768 * what is cached on the client, the verify will fail, but we would
3769 * already have the ctime from the preceding getattr, so just set it
3770 * and retry. Thus the compound here is - { Putfh <fh>; Getattr; Verify;
3771 * Setattr; Getattr }.
3772 *
3773 * The vsecattr_t * input parameter will be non-NULL if ACLs are being set in
3774 * this setattr and NULL if they are not.
3775 */
3776 static int
3779 {
3780 COMPOUND4args_clnt args;
3788 vattr_t va;
3792 mode_t omode;
3794 timestruc_t ctime;
3796 nfs4_recov_state_t recov_state;
3797 nfs4_stateid_types_t sid_types;
3798 stateid4 stateid;
3799 hrtime_t t;
3802 bitmap4 supp_attrs;
3808 /*
3809 * Only need to flush pages if there are any pages and
3810 * if the file is marked as dirty in some fashion. The
3811 * file must be flushed so that we can accurately
3812 * determine the size of the file and the cached data
3813 * after the SETATTR returns. A file is considered to
3814 * be dirty if it is either marked with R4DIRTY, has
3815 * outstanding i/o's active, or is mmap'd. In this
3816 * last case, we can't tell whether there are dirty
3817 * pages, so we flush just to be sure.
3818 */
3830 }
3831 }
3834 /*
3835 * Verification setattr compound for non-deleg AT_SIZE:
3836 * { Putfh; Getattr; Verify; Setattr; Getattr }
3837 * Set ctime local here (outside the do_again label)
3838 * so that subsequent retries (after failed VERIFY)
3839 * will use ctime from GETATTR results (from failed
3840 * verify compound) as VERIFY arg.
3841 * If file has delegation, then VERIFY(time_metadata)
3842 * is of little added value, so don't bother.
3843 */
3849 }
3851 }
3857 do_again:
3858 recov_retry:
3869 /* putfh target fh */
3874 /*
3875 * We only care about the ctime, but need to get mtime
3876 * and size for proper cache update.
3877 */
3878 /* getattr */
3883 /* verify - set later in loop */
3885 }
3887 /* setattr */
3897 /* req time field(s) overflow - return immediately */
3902 }
3905 /* getattr */
3908 /*
3909 * If we are setting the ACL (indicated only by vsap != NULL), request
3910 * the ACL in this getattr. The ACL returned from this getattr will be
3911 * used in updating the ACL cache.
3912 */
3915 FATTR4_ACL_MASK;
3918 /*
3919 * setattr iterates if the object size is set and the cached ctime
3920 * does not match the file ctime. In that case, verify the ctime first.
3921 */
3925 /*
3926 * Verify that the ctime match before doing setattr.
3927 */
3937 /* req time field(s) overflow - return */
3939 needrecov);
3941 }
3942 }
3950 /*
3951 * Purge the access cache and ACL cache if changing either the
3952 * owner of the file, the group owner, or the mode. These may
3953 * change the access permissions of the file, so purge old
3954 * information and start over again.
3955 */
3965 }
3966 }
3968 /*
3969 * If res.array_len == numops, then everything succeeded,
3970 * except for possibly the final getattr. If only the
3971 * last getattr failed, give up, and don't try recovery.
3972 */
3975 needrecov);
3979 }
3981 /*
3982 * if either rpc call failed or completely succeeded - done
3983 */
3989 needrecov);
3991 }
3992 }
3994 /*
3995 * Do proper retry for OLD_STATEID outside of the normal
3996 * recovery framework.
3997 */
4002 needrecov);
4009 }
4012 }
4015 bool_t abort;
4021 needrecov);
4022 /*
4023 * Do not retry if we failed with OLD_STATEID using
4024 * a special stateid. This is done to avoid looping
4025 * with a broken server.
4026 */
4034 OP_SETATTR);
4039 }
4045 }
4047 /*
4048 * Need to retry all possible stateids in
4049 * case the recovery error wasn't stateid
4050 * related or the stateids have become
4051 * stale (server reboot).
4052 */
4055 }
4057 }
4059 /*
4060 * Need to call nfs4_end_op before nfs4getattr to
4061 * avoid potential nfs4_start_op deadlock. See RFE
4062 * 4777612. Calls to nfs4_invalidate_pages() and
4063 * nfs4_purge_stale_fh() might also generate over the
4064 * wire calls which my cause nfs4_start_op() deadlock.
4065 */
4068 /*
4069 * Check to update lease.
4070 */
4074 }
4076 /*
4077 * Check if verify failed to see if try again
4078 */
4080 /*
4081 * can't continue...
4082 */
4088 /*
4089 * When the verify request fails, the client ctime is
4090 * not in sync with the server. This is the same as
4091 * the version 3 "not synchronized" error, and we
4092 * handle it in a similar manner (XXX do we need to???).
4093 * Use the ctime returned in the first getattr for
4094 * the input to the next verify.
4095 * If we couldn't get the attributes, then we give up
4096 * because we can't complete the operation as required.
4097 */
4099 }
4104 /*
4105 * retry with a new verify value
4106 */
4110 }
4117 }
4120 }
4124 /*
4125 * If we are here, rfs4call has an irrecoverable error - return
4126 */
4132 }
4136 }
4140 /*
4141 * If changing the size of the file, invalidate
4142 * any local cached data which is no longer part
4143 * of the file. We also possibly invalidate the
4144 * last page in the file. We could use
4145 * pvn_vpzero(), but this would mark the page as
4146 * modified and require it to be written back to
4147 * the server for no particularly good reason.
4148 * This way, if we access it, then we bring it
4149 * back in. A read should be cheaper than a
4150 * write.
4151 */
4154 }
4156 /* either no error or one of the postop getattr failed */
4158 /*
4159 * XXX Perform a simplified version of wcc checking. Instead of
4160 * have another getattr to get pre-op, just purge cache if
4161 * any of the ops prior to and including the getattr failed.
4162 * If the getattr succeeded then update the attrcache accordingly.
4163 */
4167 /*
4168 * Last getattr
4169 */
4172 }
4173 /*
4174 * In certain cases, nfs4_update_attrcache() will purge the attrcache,
4175 * rather than filling it. See the function itself for details.
4176 */
4184 /*
4185 * The ACL was supposed to be set and to be
4186 * returned in the last getattr of this
4187 * compound, but for some reason the getattr
4188 * result doesn't contain the ACL. In this
4189 * case, purge the ACL cache.
4190 */
4198 }
4199 }
4200 }
4201 }
4204 /*
4205 * Set the size, rather than relying on getting it updated
4206 * via a GETATTR. With delegations the client tries to
4207 * suppress GETATTR calls.
4208 */
4212 }
4214 /*
4215 * Can free up request args and res
4216 */
4222 }
4225 /*
4226 * Some servers will change the mode to clear the setuid
4227 * and setgid bits when changing the uid or gid. The
4228 * client needs to compensate appropriately.
4229 */
4241 /*
4242 * We asked the mode to be changed and what
4243 * we just got from the server in getattr is
4244 * not what we wanted it to be, so set it now.
4245 */
4249 /*
4250 * We did not ask the mode to be changed,
4251 * Check to see that the server just cleared
4252 * I_SUID and I_GUID from it. If not then
4253 * set mode to omode with UID/GID cleared.
4254 */
4259 }
4260 }
4264 }
4265 }
4268 }
4270 /* ARGSUSED */
4271 static int
4273 {
4274 COMPOUND4args_clnt args;
4275 COMPOUND4res_clnt res;
4280 nfs4_access_type_t cacc;
4285 nfs4_recov_state_t recov_state;
4287 hrtime_t t;
4303 }
4307 else
4309 }
4315 }
4321 else
4323 ACCESS4_EXECUTE;
4328 /*
4329 * ncr and ncrfree both initially
4330 * point to the memory area returned
4331 * by crnetadjust();
4332 * ncrfree not NULL when exiting means
4333 * that we need to release it
4334 */
4338 tryagain:
4344 }
4346 /*
4347 * If the cred can be adjusted, try again
4348 * with the new cred.
4349 */
4354 }
4358 }
4360 recov_retry:
4361 /*
4362 * Don't take with r_statev4_lock here. r_deleg_type could
4363 * change as soon as lock is released. Since it is an int,
4364 * there is no atomicity issue.
4365 */
4379 }
4381 /* putfh target fh */
4385 /* access */
4389 /* getattr */
4394 }
4418 }
4419 }
4427 /*
4428 * This might generate over the wire calls throught
4429 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
4430 * here to avoid a deadlock.
4431 */
4434 }
4443 }
4447 /*
4448 * we just cached results with cred; if cred is the
4449 * adjusted credentials from crnetadjust, we do not want
4450 * to release them before exiting: hence setting ncrfree
4451 * to NULL
4452 */
4455 /* XXX check the supported bits too? */
4457 /*
4458 * The following code implements the semantic
4459 * that a setuid root program has *at least* the
4460 * permissions of the user that is running the
4461 * program. See rfs3call() for more portions
4462 * of the implementation of this functionality.
4463 */
4464 /* XXX-LP */
4471 }
4473 }
4474 }
4476 out:
4484 }
4486 /* ARGSUSED */
4487 static int
4489 {
4490 COMPOUND4args_clnt args;
4491 COMPOUND4res_clnt res;
4498 uint_t len;
4501 nfs4_recov_state_t recov_state;
4502 hrtime_t t;
4507 /*
4508 * Can't readlink anything other than a symbolic link.
4509 */
4524 }
4526 }
4530 recov_retry:
4538 }
4540 /* 0. putfh symlink fh */
4544 /* 1. readlink */
4547 /* 2. getattr */
4574 needrecov);
4576 }
4577 }
4584 /*
4585 * There is an path in the code below which calls
4586 * nfs4_purge_stale_fh(), which may generate otw calls through
4587 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
4588 * here to avoid nfs4_start_op() deadlock.
4589 */
4592 /*
4593 * either Putfh or Link failed
4594 */
4599 }
4604 /*
4605 * treat symlink names as data
4606 */
4610 /* len includes null byte, which we won't uiomove */
4622 }
4625 }
4626 }
4630 }
4635 /*
4636 * The over the wire error for attempting to readlink something
4637 * other than a symbolic link is ENXIO. However, we need to
4638 * return EINVAL instead of ENXIO, so we map it here.
4639 */
4641 }
4643 /*
4644 * Flush local dirty pages to stable storage on the server.
4645 *
4646 * If FNODSYNC is specified, then there is nothing to do because
4647 * metadata changes are not cached on the client before being
4648 * sent to the server.
4649 */
4650 /* ARGSUSED */
4651 static int
4653 {
4664 }
4666 /*
4667 * Weirdness: if the file was removed or the target of a rename
4668 * operation while it was open, it got renamed instead. Here we
4669 * remove the renamed file.
4670 */
4671 /* ARGSUSED */
4672 void
4674 {
4684 }
4686 /*
4687 * If this is coming from the wrong zone, we let someone in the right
4688 * zone take care of it asynchronously. We can get here due to
4689 * VN_RELE() being called from pageout() or fsflush(). This call may
4690 * potentially turn into an expensive no-op if, for instance, v_count
4691 * gets incremented in the meantime, but it's still correct.
4692 */
4696 }
4698 /*
4699 * Some of the cleanup steps might require over-the-wire
4700 * operations. Since fop_inactive can get called as a result of
4701 * other over-the-wire operations (e.g., an attribute cache update
4702 * can lead to a DNLC purge), doing those steps now would lead to a
4703 * nested call to the recovery framework, which can deadlock. So
4704 * do any over-the-wire cleanups asynchronously, in a separate
4705 * thread.
4706 */
4718 }
4727 }
4735 }
4741 }
4743 /*
4744 * nfs4_inactive_otw - nfs4_inactive, plus over-the-wire calls to free up
4745 * various bits of state. The caller must not refer to vp after this call.
4746 */
4748 void
4750 {
4752 nfs4_recov_state_t recov_state;
4757 COMPOUND4args_clnt args;
4761 #ifdef DEBUG
4763 #endif
4768 #ifdef DEBUG
4773 #endif
4780 /* Check to see if recovery failed */
4790 }
4795 }
4796 }
4797 }
4799 redo:
4803 }
4805 /*
4806 * Save the vnode pointer for the directory where the
4807 * unlinked-open file got renamed, then set it to NULL
4808 * to prevent another thread from getting here before
4809 * we're done with the remove. While we have the
4810 * statelock, make local copies of the pertinent rnode
4811 * fields. If we weren't to do this in an atomic way, the
4812 * the unl* fields could become inconsistent with respect
4813 * to each other due to a race condition between this
4814 * code and nfs_remove(). See bug report 1034328.
4815 */
4821 }
4831 /*
4832 * If there are any dirty pages left, then flush
4833 * them. This is unfortunate because they just
4834 * may get thrown away during the remove operation,
4835 * but we have to do this for correctness.
4836 */
4846 }
4847 }
4851 recov_retry_remove:
4852 /*
4853 * Do the remove operation on the renamed file
4854 */
4857 /*
4858 * Remove ops: putfh dir; remove
4859 */
4868 /*
4869 * Try again; this time around r_unldvp will be NULL, so we'll
4870 * just call rp4_addfree() and return.
4871 */
4873 }
4875 /* putfh directory */
4879 /* remove */
4887 /*
4888 * Can't do this yet. We may be being called from
4889 * dnlc_purge_XXX while that routine is holding a
4890 * mutex lock to the nc_rele list. The calls to
4891 * nfs3_cache_wcc_data may result in calls to
4892 * dnlc_purge_XXX. This will result in a deadlock.
4893 */
4901 /*
4902 * This code is inactive right now
4903 * but if made active there should
4904 * be a nfs4_end_op() call before
4905 * nfs4_purge_stale_fh to avoid start_op()
4906 * deadlock. See BugId: 4948726
4907 */
4915 /*
4916 * Update directory cache attribute,
4917 * readdir and dnlc caches.
4918 */
4920 }
4921 #else
4925 #endif
4936 }
4937 }
4940 /*
4941 * Release stuff held for the remove
4942 */
4950 }
4952 /*
4953 * Remote file system operations having to do with directory manipulation.
4954 */
4955 /* ARGSUSED3 */
4956 int
4960 {
4968 /*
4969 * if LOOKUP_XATTR, must replace dvp (object) with
4970 * object's attrdir before continuing with lookup
4971 */
4979 /*
4980 * If lookup is for "", just return dvp now. The attrdir
4981 * has already been activated (from nfs4lookup_xattr), and
4982 * the caller will RELE the original dvp -- not
4983 * the attrdir. So, set vpp and return.
4984 * Currently, when the LOOKUP_XATTR flag is
4985 * passed to fop_lookup, the name is always empty, and
4986 * shortcircuiting here avoids 3 unneeded lock/unlock
4987 * pairs.
4988 *
4989 * If a non-empty name was provided, then it is the
4990 * attribute name, and it will be looked up below.
4991 */
4995 }
4997 /*
4998 * The vfs layer never sends a name when asking for the
4999 * attrdir, so we should never get here (unless of course
5000 * name is passed at some time in future -- at which time
5001 * we'll blow up here).
5002 */
5004 }
5013 /*
5014 * If vnode is a device, create special vnode.
5015 */
5020 }
5023 }
5025 /* ARGSUSED */
5026 static int
5028 {
5044 /*
5045 * If the server doesn't support xattrs just return EINVAL
5046 */
5051 }
5053 /*
5054 * If there is a cached xattr directory entry,
5055 * use it as long as the attributes are valid. If the
5056 * attributes are not valid, take the simple approach and
5057 * free the cached value and re-fetch a new value.
5058 *
5059 * We don't negative entry cache for now, if we did we
5060 * would need to check if the file has changed on every
5061 * lookup. But xattrs don't exist very often and failing
5062 * an openattr is not much more expensive than and NVERIFY or GETATTR
5063 * so do an openattr over the wire for now.
5064 */
5072 }
5075 }
5083 }
5085 static int
5087 {
5093 /*
5094 * If lookup is for "", just return dvp. Don't need
5095 * to send it over the wire, look it up in the dnlc,
5096 * or perform any access checks.
5097 */
5102 }
5104 /*
5105 * Can't do lookups in non-directories.
5106 */
5110 /*
5111 * If lookup is for ".", just return dvp. Don't need
5112 * to send it over the wire or look it up in the dnlc,
5113 * just need to check access.
5114 */
5122 }
5129 }
5132 /*
5133 * Lookup this name in the DNLC. If there is no entry
5134 * lookup over the wire.
5135 */
5139 /*
5140 * We need to go over the wire to lookup the name.
5141 */
5143 }
5145 /*
5146 * We hit on the dnlc
5147 */
5150 /*
5151 * But our attrs may not be valid.
5152 */
5159 }
5161 /*
5162 * If after the purge completes, check to make sure
5163 * our attrs are still valid.
5164 */
5166 /*
5167 * If we waited for a purge we may have
5168 * lost our vnode so look it up again.
5169 */
5176 /*
5177 * The access cache should almost always hit
5178 */
5185 }
5190 }
5192 }
5193 }
5194 }
5198 /*
5199 * We may have gotten here we have one of the following cases:
5200 * 1) vpp != DNLC_NO_VNODE, our attrs have timed out so we
5201 * need to validate them.
5202 * 2) vpp == DNLC_NO_VNODE, a negative entry that we always
5203 * must validate.
5204 *
5205 * Go to the server and check if the directory has changed, if
5206 * it hasn't we are done and can use the dnlc entry.
5207 */
5209 }
5211 /*
5212 * Go to the server and check if the directory has changed, if
5213 * it hasn't we are done and can use the dnlc entry. If it
5214 * has changed we get a new copy of its attributes and check
5215 * the access for VEXEC, then relookup the filename and
5216 * get its filehandle and attributes.
5217 *
5218 * PUTFH dfh NVERIFY GETATTR ACCESS LOOKUP GETFH GETATTR
5219 * if the NVERIFY failed we must
5220 * purge the caches
5221 * cache new attributes (will set r_time_attr_inval)
5222 * cache new access
5223 * recheck VEXEC access
5224 * add name to dnlc, possibly negative
5225 * if LOOKUP succeeded
5226 * cache new attributes
5227 * else
5228 * set a new r_time_attr_inval for dvp
5229 * check to make sure we have access
5230 *
5231 * The vpp returned is the vnode passed in if the directory is valid,
5232 * a new vnode if successful lookup, or NULL on error.
5233 */
5234 static int
5236 {
5237 COMPOUND4args_clnt args;
5238 COMPOUND4res_clnt res;
5240 fattr4_change dchange;
5246 nfs4_recov_state_t recov_state;
5247 hrtime_t t;
5252 nfs4_access_type_t cacc;
5269 /*
5270 * If dvp were a stub, it should have triggered and caused
5271 * a mount for us to get this far.
5272 */
5277 }
5285 /* Save the original mount point security information */
5288 recov_retry:
5296 }
5300 /* PUTFH dfh NVERIFY GETATTR ACCESS LOOKUP GETFH GETATTR */
5304 /* 0. putfh file */
5308 /* 1. nverify the change info */
5317 /* 2. getattr directory */
5322 /* 3. access directory */
5327 /* 4. lookup name */
5333 }
5335 /* 5. resulting file handle */
5338 /* 6. resulting file attributes */
5357 }
5360 /*
5361 * For WRONGSEC of a non-dotdot case, send secinfo directly
5362 * from this thread, do not go thru the recovery thread since
5363 * we need the nm information.
5364 *
5365 * Not doing dotdot case because there is no specification
5366 * for (PUTFH, SECINFO "..") yet.
5367 */
5372 else
5383 }
5393 }
5394 }
5399 /*
5400 * If e.error isn't set, then reply has no ops (or we couldn't
5401 * be here). The only legal way to reply without an op array
5402 * is via NFS4ERR_MINOR_VERS_MISMATCH. An ops array should
5403 * be in the reply for all other status values.
5404 *
5405 * For valid replies without an ops array, return ENOTSUP
5406 * (geterrno4 xlation of VERS_MISMATCH). For illegal replies,
5407 * return EIO -- don't trust status.
5408 */
5417 }
5422 /*
5423 * The NVERIFY "failed" so the directory has changed
5424 * First make sure PUTFH succeeded and NVERIFY "failed"
5425 * cleanly.
5426 */
5433 }
5435 /*
5436 * We know the NVERIFY "failed" so we must:
5437 * purge the caches (access and indirectly dnlc if needed)
5438 */
5446 }
5448 /*
5449 * Install new cached attributes for the directory
5450 */
5461 }
5463 /*
5464 * Now we know the directory is valid,
5465 * cache new directory access
5466 */
5471 /*
5472 * recheck VEXEC access
5473 */
5476 /*
5477 * Directory permissions might have been revoked
5478 */
5484 }
5486 /*
5487 * Somehow we must not have asked for enough
5488 * so try a singleton ACCESS, should never happen.
5489 */
5495 }
5496 }
5500 /*
5501 * The lookup failed, probably no entry
5502 */
5506 /*
5507 * Might be some other error, so remove
5508 * the dnlc entry to make sure we start all
5509 * over again, next time.
5510 */
5512 }
5516 }
5519 /*
5520 * The file exists but we can't get its fh for
5521 * some unknown reason. Remove it from the dnlc
5522 * and error out to be safe.
5523 */
5528 }
5531 /*
5532 * The file exists but a bogus fh
5533 * some unknown reason. Remove it from the dnlc
5534 * and error out to be safe.
5535 */
5541 }
5547 /*
5548 * Make the new rnode
5549 */
5557 }
5558 /*
5559 * XXX if nfs4_make_dotdot uses an existing rnode
5560 * XXX it doesn't update the attributes.
5561 * XXX for now just save them again to save an OTW
5562 */
5567 /*
5568 * If v_type == VNON, then garp was NULL because
5569 * the last op in the compound failed and makenfs4node
5570 * could not find the vnode for sfhp. It created
5571 * a new vnode, so we have nothing to purge here.
5572 */
5574 vattr_t vattr;
5577 /*
5578 * N.B. We've already called nfs4_end_fop above.
5579 */
5587 }
5589 }
5590 }
5604 hrtime_t now;
5609 /*
5610 * Because the NVERIFY "succeeded" we know that the
5611 * directory attributes are still valid
5612 * so update r_time_attr_inval
5613 */
5622 }
5627 /*
5628 * Even though we have a valid directory attr cache
5629 * and dnlc entry, we may not have access.
5630 * This should almost always hit the cache.
5631 */
5636 }
5642 }
5643 }
5645 exit:
5650 }
5652 /*
5653 * We need to go over the wire to lookup the name, but
5654 * while we are there verify the directory has not
5655 * changed but if it has, get new attributes and check access
5656 *
5657 * PUTFH dfh SAVEFH LOOKUP nm GETFH GETATTR RESTOREFH
5658 * NVERIFY GETATTR ACCESS
5659 *
5660 * With the results:
5661 * if the NVERIFY failed we must purge the caches, add new attributes,
5662 * and cache new access.
5663 * set a new r_time_attr_inval
5664 * add name to dnlc, possibly negative
5665 * if LOOKUP succeeded
5666 * cache new attributes
5667 */
5668 static int
5670 {
5671 COMPOUND4args_clnt args;
5672 COMPOUND4res_clnt res;
5674 fattr4_change dchange;
5681 nfs4_recov_state_t recov_state;
5682 hrtime_t t;
5687 nfs4_access_type_t cacc;
5703 /*
5704 * If dvp were a stub, it should have triggered and caused
5705 * a mount for us to get this far.
5706 */
5711 }
5719 /* Save the original mount point security information */
5722 recov_retry:
5728 }
5732 /* PUTFH SAVEFH LOOKUP GETFH GETATTR RESTOREFH NVERIFY GETATTR ACCESS */
5736 /* 0. putfh file */
5740 /* 1. savefh for the nverify */
5743 /* 2. lookup name */
5749 }
5751 /* 3. resulting file handle */
5754 /* 4. resulting file attributes */
5759 /* 5. restorefh back the directory for the nverify */
5762 /* 6. nverify the change info */
5771 /* 7. getattr directory */
5776 /* 8. access directory */
5795 }
5798 /*
5799 * For WRONGSEC of a non-dotdot case, send secinfo directly
5800 * from this thread, do not go thru the recovery thread since
5801 * we need the nm information.
5802 *
5803 * Not doing dotdot case because there is no specification
5804 * for (PUTFH, SECINFO "..") yet.
5805 */
5810 else
5819 }
5829 }
5830 }
5835 /*
5836 * If e.error isn't set, then reply has no ops (or we couldn't
5837 * be here). The only legal way to reply without an op array
5838 * is via NFS4ERR_MINOR_VERS_MISMATCH. An ops array should
5839 * be in the reply for all other status values.
5840 *
5841 * For valid replies without an ops array, return ENOTSUP
5842 * (geterrno4 xlation of VERS_MISMATCH). For illegal replies,
5843 * return EIO -- don't trust status.
5844 */
5852 }
5856 /*
5857 * The PUTFH and SAVEFH may have failed.
5858 */
5863 }
5865 /*
5866 * Check if the file exists, if it does delay entering
5867 * into the dnlc until after we update the directory
5868 * attributes so we don't cause it to get purged immediately.
5869 */
5871 /*
5872 * The lookup failed, probably no entry
5873 */
5877 }
5880 /*
5881 * The file exists but we can't get its fh for
5882 * some unknown reason. Error out to be safe.
5883 */
5885 }
5889 /*
5890 * The file exists but a bogus fh
5891 * some unknown reason. Error out to be safe.
5892 */
5895 }
5901 }
5904 /*
5905 * The RESTOREFH may have failed
5906 */
5911 }
5914 /*
5915 * First make sure the NVERIFY failed as we expected,
5916 * if it didn't then be conservative and error out
5917 * as we can't trust the directory.
5918 */
5923 }
5925 /*
5926 * We know the NVERIFY "failed" so the directory has changed,
5927 * so we must:
5928 * purge the caches (access and indirectly dnlc if needed)
5929 */
5935 }
5945 }
5947 /*
5948 * Now we know the directory is valid,
5949 * cache new directory access
5950 */
5955 /*
5956 * recheck VEXEC access
5957 */
5960 /*
5961 * Directory permissions might have been revoked
5962 */
5967 }
5969 /*
5970 * Somehow we must not have asked for enough
5971 * so try a singleton ACCESS should never happen
5972 */
5977 }
5978 }
5982 hrtime_t now;
5987 /*
5988 * Because the NVERIFY "succeeded" we know that the
5989 * directory attributes are still valid
5990 * so update r_time_attr_inval
5991 */
6000 }
6004 /*
6005 * Even though we have a valid directory attr cache,
6006 * we may not have access.
6007 * This should almost always hit the cache.
6008 */
6013 }
6014 }
6016 /*
6017 * Now we have successfully completed the lookup, if the
6018 * directory has changed we now have the valid attributes.
6019 * We also know we have directory access.
6020 * Create the new rnode and insert it in the dnlc.
6021 */
6027 }
6028 /*
6029 * XXX if nfs4_make_dotdot uses an existing rnode
6030 * XXX it doesn't update the attributes.
6031 * XXX for now just save them again to save an OTW
6032 */
6037 }
6050 exit:
6055 }
6057 #ifdef DEBUG
6058 void
6060 {
6102 }
6103 }
6104 }
6105 #endif
6107 /*
6108 * nfs4lookup_setup - constructs a multi-lookup compound request.
6109 *
6110 * Given the path "nm1/nm2/.../nmn", the following compound requests
6111 * may be created:
6112 *
6113 * Note: Getfh is not be needed because filehandle attr is mandatory, but it
6114 * is faster, for now.
6115 *
6116 * l4_getattrs indicates the type of compound requested.
6117 *
6118 * LKP4_NO_ATTRIBUTE - no attributes (used by secinfo):
6119 *
6120 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Lookup {nmn} }
6121 *
6122 * total number of ops is n + 1.
6123 *
6124 * LKP4_LAST_NAMED_ATTR - multi-component path for a named
6125 * attribute: create lookups plus one OPENATTR/GETFH/GETATTR
6126 * before the last component, and only get attributes
6127 * for the last component. Note that the second-to-last
6128 * pathname component is XATTR_RPATH, which does NOT go
6129 * over-the-wire as a lookup.
6130 *
6131 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Lookup {nmn-2};
6132 * Openattr; Getfh; Getattr; Lookup {nmn}; Getfh; Getattr }
6133 *
6134 * and total number of ops is n + 5.
6135 *
6136 * LKP4_LAST_ATTRDIR - multi-component path for the hidden named
6137 * attribute directory: create lookups plus an OPENATTR
6138 * replacing the last lookup. Note that the last pathname
6139 * component is XATTR_RPATH, which does NOT go over-the-wire
6140 * as a lookup.
6141 *
6142 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Getfh; Getattr;
6143 * Openattr; Getfh; Getattr }
6144 *
6145 * and total number of ops is n + 5.
6146 *
6147 * LKP4_ALL_ATTRIBUTES - create lookups and get attributes for intermediate
6148 * nodes too.
6149 *
6150 * compound { Put*fh; Lookup {nm1}; Getfh; Getattr;
6151 * Lookup {nm2}; ... Lookup {nmn}; Getfh; Getattr }
6152 *
6153 * and total number of ops is 3*n + 1.
6154 *
6155 * All cases: returns the index in the arg array of the final LOOKUP op, or
6156 * -1 if no LOOKUPs were used.
6157 */
6158 int
6160 {
6170 /* set lookuparg response result to 0 */
6173 /* skip leading "/" or "." e.g. ".//./" if there is */
6178 /* ".." is counted as 1 component */
6181 }
6183 /*
6184 * Find n = number of components - nm must be null terminated
6185 * Skip "." components.
6186 */
6193 n++;
6194 }
6195 else
6198 /*
6199 * nga is number of components that need Getfh+Getattr
6200 */
6207 /*
6208 * Always have at least 1 getfh, getattr pair
6209 */
6211 nga++;
6217 }
6219 /*
6220 * If change to use the filehandle attr instead of getfh
6221 * the following line can be deleted.
6222 */
6225 /*
6226 * calculate number of ops in request as
6227 * header + trailer + lookups + getattrs
6228 */
6238 /*
6239 * loop and create a lookup op and possibly getattr/getfh for
6240 * each component. Skip "." components.
6241 */
6243 /*
6244 * Set up a pathname struct for each component if needed
6245 */
6247 s++;
6252 ;
6259 }
6262 /* getfh XXX may not be needed in future */
6264 argop++;
6265 argcnt++;
6267 /* getattr */
6273 argop++;
6274 argcnt++;
6276 /* openattr */
6280 /* openattr */
6282 argop++;
6283 argcnt++;
6285 /* getfh XXX may not be needed in future */
6287 argop++;
6288 argcnt++;
6290 /* getattr */
6296 argop++;
6297 argcnt++;
6301 /* lookupp */
6304 /* lookup */
6308 }
6310 argop++;
6311 argcnt++;
6316 /* getfh XXX may not be needed in future */
6318 argop++;
6319 argcnt++;
6321 /* getattr */
6327 argop++;
6328 argcnt++;
6329 }
6330 }
6335 /* stick in a post-lookup getfh */
6337 argcnt++;
6338 argop++;
6339 }
6340 /* post-lookup getattr */
6345 argcnt++;
6346 }
6351 #ifdef DEBUG
6354 #endif
6357 }
6359 static int
6361 {
6362 COMPOUND4args_clnt args;
6363 COMPOUND4res_clnt res;
6368 hrtime_t t;
6369 nfs4_error_t e;
6375 nfs4_recov_state_t recov_state;
6383 recov_retry:
6384 /* COMPOUND: putfh, openattr, getfh, getattr */
6395 /* putfh */
6399 /* openattr */
6403 /* getfh */
6406 /* getattr */
6421 bool_t abort;
6433 }
6437 }
6442 }
6445 /*
6446 * If OTW errro is NOTSUPP, then it should be
6447 * translated to EINVAL. All Solaris file system
6448 * implementations return EINVAL to the syscall layer
6449 * when the attrdir cannot be created due to an
6450 * implementation restriction or noxattr mount option.
6451 */
6463 }
6468 needrecov);
6470 }
6471 }
6486 }
6509 /*
6510 * Invalidate pathconf4 cache because r_xattr_dir is no longer
6511 * NULL. xattrs could be created at any time, and we have no
6512 * way to update pc4_xattr_exists in the base object if/when
6513 * it happens.
6514 */
6524 }
6526 /* ARGSUSED */
6527 static int
6531 {
6546 }
6548 /* . and .. have special meaning in the protocol, reject them. */
6558 top:
6559 /*
6560 * We make a copy of the attributes because the caller does not
6561 * expect us to change what va points to.
6562 */
6565 /*
6566 * If the pathname is "", then dvp is the root vnode of
6567 * a remote file mounted over a local directory.
6568 * All that needs to be done is access
6569 * checking and truncation. Note that we avoid doing
6570 * open w/ create because the parent directory might
6571 * be in pseudo-fs and the open would fail.
6572 */
6579 /*
6580 * We need to go over the wire, just to be sure whether the
6581 * file exists or not. Using the DNLC can be dangerous in
6582 * this case when making a decision regarding existence.
6583 */
6585 }
6589 else
6592 /*
6593 * error would be set if the file does not exist on the
6594 * server, so lets go create it.
6595 */
6598 }
6600 /*
6601 * File does exist on the server
6602 */
6608 /*
6609 * If vnode is a device, create special vnode.
6610 */
6615 }
6620 /*
6621 * Check here for large file handled
6622 * by LF-unaware process (as
6623 * ufs_create() does)
6624 */
6630 }
6632 /* if error is set then we need to return */
6637 }
6642 NULL);
6644 /*
6645 * we know we have a regular file that already
6646 * exists and we may end up truncating the file
6647 * as a result of the open_otw, so flush out
6648 * any dirty pages for this file first.
6649 */
6662 error;
6665 }
6666 }
6673 }
6674 }
6675 }
6676 }
6688 }
6691 /*
6692 * existing file got truncated, notify.
6693 */
6695 }
6698 }
6701 create_otw:
6706 /*
6707 * If not a regular file let nfs4mknod() handle it.
6708 */
6713 }
6715 /*
6716 * It _is_ a regular file.
6717 */
6722 }
6724 /*
6725 * If this happens to be a mknod of a regular file, then flags will
6726 * have neither FREAD or FWRITE. However, we must set at least one
6727 * for the call to nfs4open_otw. If it's open(O_CREAT) driving
6728 * nfs4_create, then either FREAD, FWRITE, or FRDWR has already been
6729 * set (based on openmode specified by app).
6730 */
6737 /* if create was successful, throw away the file's pages */
6740 cr);
6741 /* release the lookup hold */
6744 }
6746 /*
6747 * validate that we opened a regular file. This handles a misbehaving
6748 * server that returns an incorrect FH.
6749 */
6753 }
6755 /*
6756 * If this is not an exclusive create, then the CREATE
6757 * request will be made with the GUARDED mode set. This
6758 * means that the server will return EEXIST if the file
6759 * exists. The file could exist because of a retransmitted
6760 * request. In this case, we recover by starting over and
6761 * checking to see whether the file exists. This second
6762 * time through it should and a CREATE request will not be
6763 * sent.
6764 *
6765 * This handles the problem of a dangling CREATE request
6766 * which contains attributes which indicate that the file
6767 * should be truncated. This retransmitted request could
6768 * possibly truncate valid data in the file if not caught
6769 * by the duplicate request mechanism on the server or if
6770 * not caught by other means. The scenario is:
6771 *
6772 * Client transmits CREATE request with size = 0
6773 * Client times out, retransmits request.
6774 * Response to the first request arrives from the server
6775 * and the client proceeds on.
6776 * Client writes data to the file.
6777 * The server now processes retransmitted CREATE request
6778 * and truncates file.
6779 *
6780 * The use of the GUARDED CREATE request prevents this from
6781 * happening because the retransmitted CREATE would fail
6782 * with EEXIST and would not truncate the file.
6783 */
6785 #ifdef DEBUG
6786 nfs4_create_misses++;
6787 #endif
6789 }
6794 /*
6795 * existing file got truncated, notify.
6796 */
6802 }
6804 }
6806 /*
6807 * Create compound (for mkdir, mknod, symlink):
6808 * { Putfh <dfh>; Create; Getfh; Getattr }
6809 * It's okay if setattr failed to set gid - this is not considered
6810 * an error, but purge attrs in that case.
6811 */
6812 static int
6815 {
6817 COMPOUND4args_clnt args;
6830 nfs4_recov_state_t recov_state;
6832 hrtime_t t;
6837 bitmap4 supp_attrs;
6844 /*
6845 * Make sure we properly deal with setting the right gid
6846 * on a new directory to reflect the parent's setgid bit
6847 */
6856 /*
6857 * If the parent's directory has the setgid bit set
6858 * _and_ the client was able to get a valid mapping
6859 * for the parent dir's owner_group, we want to
6860 * append NVERIFY(owner_group == dva.va_gid) and
6861 * SETTATTR to the CREATE compound.
6862 */
6869 }
6870 }
6871 }
6872 }
6874 /*
6875 * Create ops:
6876 * 0:putfh(dir) 1:savefh(dir) 2:create 3:getfh(new) 4:getattr(new)
6877 * 5:restorefh(dir) 6:getattr(dir)
6878 *
6879 * if (setgid)
6880 * 0:putfh(dir) 1:create 2:getfh(new) 3:getattr(new)
6881 * 4:savefh(new) 5:putfh(dir) 6:getattr(dir) 7:restorefh(new)
6882 * 8:nverify 9:setattr
6883 */
6892 }
6897 }
6904 recov_retry:
6909 else
6919 }
6923 /* 0: putfh directory */
6927 /* 1/2: Create object */
6932 /*
6933 * symlink, treat name as data
6934 */
6938 }
6943 }
6958 }
6960 /* 2/3: getfh fh of created object */
6964 /* 3/4: getattr of new object */
6970 vattr_t _v;
6983 /*
6984 * nverify
6985 *
6986 * XXX - Revisit the last argument to nfs4_end_op()
6987 * once 5020486 is fixed.
6988 */
6992 supp_attrs)) {
6998 }
7000 /*
7001 * setattr
7002 *
7003 * We _know_ we're not messing with AT_SIZE or AT_XTIME,
7004 * so no need for stateid or flags. Also we specify NULL
7005 * rp since we're only interested in setting owner_group
7006 * attributes.
7007 */
7018 }
7027 }
7040 }
7046 needrecov);
7052 }
7055 }
7056 }
7067 /*
7068 * This check is left over from when create was implemented
7069 * using a setattr op (instead of createattrs). If the
7070 * putfh/create/getfh failed, the error was returned. If
7071 * setattr/getattr failed, we keep going.
7072 *
7073 * It might be better to get rid of the GETFH also, and just
7074 * do PUTFH/CREATE/GETATTR since the FH attr is mandatory.
7075 * Then if any of the operations failed, we could return the
7076 * error now, and remove much of the error code below.
7077 */
7079 /*
7080 * Either Putfh, Create or Getfh failed.
7081 */
7083 /*
7084 * nfs4_purge_stale_fh() may generate otw calls through
7085 * nfs4_invalidate_pages. Hence the need to call
7086 * nfs4_end_op() here to avoid nfs4_start_op() deadlock.
7087 */
7089 needrecov);
7093 }
7094 }
7108 /*
7109 * Need to call nfs4_end_op before nfs4getattr to avoid
7110 * potential nfs4_start_op deadlock. See RFE 4777612.
7111 */
7113 needrecov);
7120 }
7122 }
7129 }
7131 /*
7132 * If compound succeeded, then update dir attrs
7133 */
7142 /* Update directory cache attribute, readdir and dnlc caches */
7145 out:
7153 }
7161 }
7163 /* ARGSUSED */
7164 static int
7167 {
7170 nfs_ftype4 type;
7193 }
7198 }
7200 /*
7201 * This might not be needed any more; special case to deal
7202 * with problematic v2/v3 servers. Since create was unable
7203 * to set group correctly, not sure what hope setattr has.
7204 */
7208 }
7210 /*
7211 * If vnode is a device create special vnode
7212 */
7218 }
7220 }
7222 /*
7223 * Remove requires that the current fh be the target directory.
7224 * After the operation, the current fh is unchanged.
7225 * The compound op structure is:
7226 * PUTFH(targetdir), REMOVE
7227 *
7228 * Weirdness: if the vnode to be removed is open
7229 * we rename it instead of removing it and nfs_inactive
7230 * will remove the new name.
7231 */
7232 /* ARGSUSED */
7233 static int
7235 {
7236 COMPOUND4args_clnt args;
7248 nfs4_recov_state_t recov_state;
7251 dirattr_info_t dinfo;
7263 }
7269 }
7271 /*
7272 * First just remove the entry from the name cache, as it
7273 * is most likely the only entry for this vp.
7274 */
7279 /*
7280 * For regular file types, check to see if the file is open by looking
7281 * at the open streams.
7282 * For all other types, check the reference count on the vnode. Since
7283 * they are not opened OTW they never have an open stream.
7284 *
7285 * If the file is open, rename it to .nfsXXXX.
7286 */
7288 /*
7289 * If the file has a v_count > 1 then there may be more than one
7290 * entry in the name cache due multiple links or an open file,
7291 * but we don't have the real reference count so flush all
7292 * possible entries.
7293 */
7297 /*
7298 * Now we have the real reference count.
7299 */
7305 }
7328 }
7330 }
7334 }
7335 /*
7336 * Actually remove the file/dir
7337 */
7340 /*
7341 * We need to flush any dirty pages which happen to
7342 * be hanging around before removing the file.
7343 * This shouldn't happen very often since in NFSv4
7344 * we should be close to open consistent.
7345 */
7354 }
7355 }
7363 recov_retry:
7364 /*
7365 * Remove ops: putfh dir; remove
7366 */
7376 }
7378 /* putfh directory */
7382 /* remove */
7386 /* getattr dir */
7408 needrecov);
7410 }
7411 }
7413 /*
7414 * Matching nfs4_end_op() for start_op() above.
7415 * There is a path in the code below which calls
7416 * nfs4_purge_stale_fh(), which may generate otw calls through
7417 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
7418 * here to avoid nfs4_start_op() deadlock.
7419 */
7437 /* Update directory attr, readdir and dnlc caches */
7440 }
7441 }
7454 }
7457 }
7459 /*
7460 * Link requires that the current fh be the target directory and the
7461 * saved fh be the source fh. After the operation, the current fh is unchanged.
7462 * Thus the compound op structure is:
7463 * PUTFH(file), SAVEFH, PUTFH(targetdir), LINK, RESTOREFH,
7464 * GETATTR(file)
7465 */
7466 /* ARGSUSED */
7467 static int
7470 {
7471 COMPOUND4args_clnt args;
7482 nfs4_recov_state_t recov_state;
7483 hrtime_t t;
7485 dirattr_info_t dinfo;
7497 }
7504 }
7511 recov_retry:
7516 /*
7517 * Link ops: putfh fl; savefh; putfh tdir; link; getattr(dir);
7518 * restorefh; getattr(fl)
7519 */
7528 }
7530 /* 0. putfh file */
7534 /* 1. save current fh to free up the space for the dir */
7537 /* 2. putfh targetdir */
7541 /* 3. link: current_fh is targetdir, saved_fh is source */
7545 /* 4. Get attributes of dir */
7550 /* 5. If link was successful, restore current vp to file */
7553 /* 6. Get attributes of linked object */
7571 }
7574 bool_t abort;
7580 needrecov);
7593 }
7594 /* fall through for res.status case */
7595 }
7596 }
7602 /* If link succeeded, then don't return error */
7605 /*
7606 * Either Putfh, Savefh, Putfh dir, or Link failed
7607 */
7614 }
7615 /* XXX-LP */
7619 }
7620 }
7622 /* either no error or one of the postop getattr failed */
7624 /*
7625 * XXX - if LINK succeeded, but no attrs were returned for link
7626 * file, purge its cache.
7627 *
7628 * XXX Perform a simplified version of wcc checking. Instead of
7629 * have another getattr to get pre-op, just purge cache if
7630 * any of the ops prior to and including the getattr failed.
7631 * If the getattr succeeded then update the attrcache accordingly.
7632 */
7634 /*
7635 * update cache with link file postattrs.
7636 * Note: at this point resop points to link res.
7637 */
7645 /*
7646 * Call makenfs4node to create the new shadow vp for tnm.
7647 * We pass NULL attrs because we just cached attrs for
7648 * the src object. All we're trying to accomplish is to
7649 * to create the new shadow vnode.
7650 */
7654 /* Update target cache attribute, readdir and dnlc caches */
7668 /*
7669 * Notify the source file of this link operation.
7670 */
7676 }
7677 out:
7685 }
7687 /* ARGSUSED */
7688 static int
7691 {
7700 }
7702 /*
7703 * nfs4rename does the real work of renaming in NFS Version 4.
7704 *
7705 * A file handle is considered volatile for renaming purposes if either
7706 * of the volatile bits are turned on. However, the compound may differ
7707 * based on the likelihood of the filehandle to change during rename.
7708 */
7709 static int
7712 {
7745 }
7752 }
7753 }
7755 /*
7756 * Lookup the target file. If it exists, it needs to be
7757 * checked to see whether it is a mount point and whether
7758 * it is active (open).
7759 */
7765 /*
7766 * If this file has been mounted on, then just
7767 * return busy because renaming to it would remove
7768 * the mounted file system from the name space.
7769 */
7775 }
7777 /*
7778 * First just remove the entry from the name cache, as it
7779 * is most likely the only entry for this vp.
7780 */
7786 /*
7787 * Purge the name cache of all references to this vnode
7788 * so that we can check the reference count to infer
7789 * whether it is active or not.
7790 */
7799 }
7801 /*
7802 * If the vnode is active and is not a directory,
7803 * arrange to rename it to a
7804 * temporary file so that it will continue to be
7805 * accessible. This implements the "unlink-open-file"
7806 * semantics for the target of a rename operation.
7807 * Before doing this though, make sure that the
7808 * source and target files are not already the same.
7809 */
7811 /*
7812 * Lookup the source name.
7813 */
7816 /*
7817 * The source name *should* already exist.
7818 */
7824 }
7828 /*
7829 * Compare the two vnodes. If they are the same,
7830 * just release all held vnodes and return success.
7831 */
7838 }
7840 /*
7841 * Can't mix and match directories and non-
7842 * directories in rename operations. We already
7843 * know that the target is not a directory. If
7844 * the source is a directory, return an error.
7845 */
7852 }
7853 link_call:
7854 /*
7855 * The target file exists, is not the same as
7856 * the source file, and is active. We first
7857 * try to Link it to a temporary filename to
7858 * avoid having the server removing the file
7859 * completely (which could cause data loss to
7860 * the user's POV in the event the Rename fails
7861 * -- see bug 1165874).
7862 */
7863 /*
7864 * The do_link and did_link booleans are
7865 * introduced in the event we get NFS4ERR_FILE_OPEN
7866 * returned for the Rename. Some servers can
7867 * not Rename over an Open file, so they return
7868 * this error. The client needs to Remove the
7869 * newly created Link and do two Renames, just
7870 * as if the server didn't support LINK.
7871 */
7878 }
7885 }
7893 }
7908 }
7910 }
7915 }
7918 /*
7919 * When renaming directories to be a subdirectory of a
7920 * different parent, the dnlc entry for ".." will no
7921 * longer be valid, so it must be removed.
7922 *
7923 * We do a lookup here to determine whether we are renaming
7924 * a directory and we need to check if we are renaming
7925 * an unlinked file. This might have already been done
7926 * in previous code, so we check ovp == NULL to avoid
7927 * doing it twice.
7928 */
7930 /*
7931 * The source name *should* already exist.
7932 */
7938 }
7940 }
7943 }
7945 /*
7946 * Is the object being renamed a dir, and if so, is
7947 * it being renamed to a child of itself? The underlying
7948 * fs should ultimately return EINVAL for this case;
7949 * however, buggy beta non-Solaris NFSv4 servers at
7950 * interop testing events have allowed this behavior,
7951 * and it caused our client to panic due to a recursive
7952 * mutex_enter in fn_move.
7953 *
7954 * The tedious locking in fn_move could be changed to
7955 * deal with this case, and the client could avoid the
7956 * panic; however, the client would just confuse itself
7957 * later and misbehave. A better way to handle the broken
7958 * server is to detect this condition and return EINVAL
7959 * without ever sending the the bogus rename to the server.
7960 * We know the rename is invalid -- just fail it now.
7961 */
7968 }
7970 }
7974 /*
7975 * If FH4_VOL_RENAME or FH4_VOLATILE_ANY bits are set, it is
7976 * possible for the filehandle to change due to the rename.
7977 * If neither of these bits is set, but FH4_VOL_MIGRATION is set,
7978 * the fh will not change because of the rename, but we still need
7979 * to update its rnode entry with the new name for
7980 * an eventual fh change due to migration. The FH4_NOEXPIRE_ON_OPEN
7981 * has no effect on these for now, but for future improvements,
7982 * we might want to use it too to simplify handling of files
7983 * that are open with that flag on. (XXX)
7984 */
7989 else
7999 /*
8000 * Before the 'link_call' code, we did a nfs4_lookup
8001 * that puts a VN_HOLD on nvp. After the nfs4_link
8002 * call we call VN_RELE to match that hold. We need
8003 * to place an additional VN_HOLD here since we will
8004 * be hitting that VN_RELE again.
8005 */
8010 /* Undo the unlinked file naming stuff we just did */
8018 /* rp->r_unlanme points to tmpname */
8022 }
8027 }
8029 }
8037 }
8039 }
8041 /*
8042 * when renaming directories to be a subdirectory of a
8043 * different parent, the dnlc entry for ".." will no
8044 * longer be valid, so it must be removed
8045 */
8052 }
8053 }
8055 /*
8056 * If we are renaming the unlinked file, update the
8057 * r_unldvp and r_unlname as needed.
8058 */
8068 }
8069 }
8070 }
8073 /*
8074 * Notify the rename vnevents to source vnode, and to the target
8075 * vnode if it already existed.
8076 */
8080 /*
8081 * Notify the vnode. Each links is represented by
8082 * a different vnode, in nfsv4.
8083 */
8090 }
8092 /*
8093 * if the source and destination directory are not the
8094 * same notify the destination directory.
8095 */
8102 }
8109 }
8113 }
8120 }
8122 /*
8123 * When the parent directory has changed, sv_dfh must be updated
8124 */
8125 static void
8127 {
8135 }
8137 /*
8138 * nfs4rename_persistent does the otw portion of renaming in NFS Version 4,
8139 * when it is known that the filehandle is persistent through rename.
8140 *
8141 * Rename requires that the current fh be the target directory and the
8142 * saved fh be the source directory. After the operation, the current fh
8143 * is unchanged.
8144 * The compound op structure for persistent fh rename is:
8145 * PUTFH(sourcdir), SAVEFH, PUTFH(targetdir), RENAME
8146 * Rather than bother with the directory postop args, we'll simply
8147 * update that a change occurred in the cache, so no post-op getattrs.
8148 */
8149 static int
8152 {
8153 COMPOUND4args_clnt args;
8162 bool_t needrecov;
8163 nfs4_recov_state_t recov_state;
8172 /*
8173 * Rename ops: putfh sdir; savefh; putfh tdir; rename; getattr tdir
8174 *
8175 * If source/target are different dirs, then append putfh(src); getattr
8176 */
8181 recov_retry:
8184 /* No need to Lookup the file, persistent fh */
8192 }
8194 /* 0: putfh source directory */
8198 /* 1: Save source fh to free up current for target */
8201 /* 2: putfh targetdir */
8205 /* 3: current_fh is targetdir, saved_fh is sourcedir */
8210 /* 4: getattr (targetdir) */
8217 /* 5: putfh (sourcedir) */
8221 /* 6: getattr (sourcedir) */
8225 }
8240 }
8250 }
8251 }
8255 /*
8256 * as long as OP_RENAME
8257 */
8262 /*
8263 * System V defines rename to return EEXIST, not
8264 * ENOTEMPTY if the target directory is not empty.
8265 * Over the wire, the error is NFSERR_ENOTEMPTY
8266 * which geterrno4 maps to ENOTEMPTY.
8267 */
8276 /*
8277 * Update target attribute, readdir and dnlc
8278 * caches.
8279 */
8290 /*
8291 * Update source attribute, readdir and dnlc caches
8292 *
8293 */
8304 }
8307 nnm);
8308 }
8309 }
8317 }
8319 /*
8320 * nfs4rename_volatile_fh does the otw part of renaming in NFS Version 4, when
8321 * it is possible for the filehandle to change due to the rename.
8322 *
8323 * The compound req in this case includes a post-rename lookup and getattr
8324 * to ensure that we have the correct fh and attributes for the object.
8325 *
8326 * Rename requires that the current fh be the target directory and the
8327 * saved fh be the source directory. After the operation, the current fh
8328 * is unchanged.
8329 *
8330 * We need the new filehandle (hence a LOOKUP and GETFH) so that we can
8331 * update the filehandle for the renamed object. We also get the old
8332 * filehandle for historical reasons; this should be taken out sometime.
8333 * This results in a rather cumbersome compound...
8334 *
8335 * PUTFH(sourcdir), SAVEFH, LOOKUP(src), GETFH(old),
8336 * PUTFH(targetdir), RENAME, LOOKUP(trgt), GETFH(new), GETATTR
8337 *
8338 */
8339 static int
8342 {
8343 COMPOUND4args_clnt args;
8355 bool_t needrecov;
8356 nfs4_recov_state_t recov_state;
8357 hrtime_t t;
8366 recov_retry:
8369 /*
8370 * There is a window between the RPC and updating the path and
8371 * filehandle stored in the rnode. Lock out the FHEXPIRED recovery
8372 * code, so that it doesn't try to use the old path during that
8373 * window.
8374 */
8386 }
8389 }
8400 /*
8401 * Rename ops:
8402 * PUTFH(sourcdir), SAVEFH, LOOKUP(src), GETFH(old),
8403 * PUTFH(targetdir), RENAME, GETATTR(targetdir)
8404 * LOOKUP(trgt), GETFH(new), GETATTR,
8405 *
8406 * if (odvp != ndvp)
8407 * add putfh(sourcedir), getattr(sourcedir) }
8408 */
8420 }
8422 /* 0: putfh source directory */
8426 /* 1: Save source fh to free up current for target */
8429 /* 2: Lookup pre-rename fh of renamed object */
8433 /* 3: getfh fh of renamed object (before rename) */
8436 /* 4: putfh targetdir */
8440 /* 5: current_fh is targetdir, saved_fh is sourcedir */
8445 /* 6: getattr of target dir (post op attrs) */
8450 /* 7: Lookup post-rename fh of renamed object */
8454 /* 8: getfh fh of renamed object (after rename) */
8457 /* 9: getattr of renamed object */
8462 /*
8463 * If source/target dirs are different, then get new post-op
8464 * attrs for source dir also.
8465 */
8467 /* 10: putfh (sourcedir) */
8471 /* 11: getattr (sourcedir) */
8475 }
8492 }
8495 }
8498 bool_t abort;
8519 }
8520 /* fall through for res.status case */
8521 }
8522 }
8525 /*
8526 * If OP_RENAME (or any prev op) failed, then return an error.
8527 * OP_RENAME is index 5, so if array len <= 6 we return an error.
8528 */
8530 /*
8531 * Error in an op other than last Getattr
8532 */
8536 /*
8537 * System V defines rename to return EEXIST, not
8538 * ENOTEMPTY if the target directory is not empty.
8539 * Over the wire, the error is NFSERR_ENOTEMPTY
8540 * which geterrno4 maps to ENOTEMPTY.
8541 */
8545 needrecov);
8547 }
8549 /* rename results */
8553 /* Update target attribute, readdir and dnlc caches */
8561 /* Update source cache attribute, readdir and dnlc caches */
8564 /* Update source cache attribute, readdir and dnlc caches */
8568 /*
8569 * If dinfop is non-NULL, then compound succeded, so
8570 * set di_garp to attrs for source dir. dinfop is only
8571 * set to NULL when compound fails.
8572 */
8577 dinfop);
8578 }
8580 /*
8581 * Update the rnode with the new component name and args,
8582 * and if the file handle changed, also update it with the new fh.
8583 * This is only necessary if the target object has an rnode
8584 * entry and there is no need to create one for it.
8585 */
8589 /*
8590 * Update the path and filehandle for the renamed object.
8591 */
8601 }
8603 out:
8613 }
8615 /* ARGSUSED */
8616 static int
8619 {
8625 /*
8626 * As ".." has special meaning and rather than send a mkdir
8627 * over the wire to just let the server freak out, we just
8628 * short circuit it here and return EEXIST
8629 */
8633 /*
8634 * Decision to get the right gid and setgid bit of the
8635 * new directory is now made in call_nfs4_create_req.
8636 */
8644 }
8647 /*
8648 * rmdir is using the same remove v4 op as does remove.
8649 * Remove requires that the current fh be the target directory.
8650 * After the operation, the current fh is unchanged.
8651 * The compound op structure is:
8652 * PUTFH(targetdir), REMOVE
8653 */
8654 /*ARGSUSED4*/
8655 static int
8658 {
8660 COMPOUND4args_clnt args;
8670 nfs4_recov_state_t recov_state;
8676 /*
8677 * As ".." has special meaning and rather than send a rmdir
8678 * over the wire to just let the server freak out, we just
8679 * short circuit it here and return EEXIST
8680 */
8688 /*
8689 * Attempt to prevent a rmdir(".") from succeeding.
8690 */
8695 }
8700 }
8702 /*
8703 * Since nfsv4 remove op works on both files and directories,
8704 * check that the removed object is indeed a directory.
8705 */
8710 }
8712 /*
8713 * First just remove the entry from the name cache, as it
8714 * is most likely an entry for this vp.
8715 */
8718 /*
8719 * If there vnode reference count is greater than one, then
8720 * there may be additional references in the DNLC which will
8721 * need to be purged. First, trying removing the entry for
8722 * the parent directory and see if that removes the additional
8723 * reference(s). If that doesn't do it, then use dnlc_purge_vp
8724 * to completely remove any references to the directory which
8725 * might still exist in the DNLC.
8726 */
8731 }
8737 recov_retry:
8740 /*
8741 * Rmdir ops: putfh dir; remove
8742 */
8750 }
8753 /* putfh directory */
8757 /* remove */
8761 /* getattr (postop attrs for dir that contained removed dir) */
8775 }
8785 needrecov);
8788 }
8789 }
8794 /*
8795 * Only return error if first 2 ops (OP_REMOVE or earlier)
8796 * failed.
8797 */
8805 /*
8806 * System V defines rmdir to return EEXIST, not
8807 * ENOTEMPTY if the directory is not empty. Over
8808 * the wire, the error is NFSERR_ENOTEMPTY which
8809 * geterrno4 maps to ENOTEMPTY.
8810 */
8826 /* Update dir attribute, readdir and dnlc caches */
8828 dinfop);
8830 /* destroy rddir cache for dir that was removed */
8833 }
8834 }
8852 }
8857 }
8859 /* ARGSUSED */
8860 static int
8863 {
8896 }
8897 }
8898 }
8902 }
8905 /*
8906 * Read directory entries.
8907 * There are some weird things to look out for here. The uio_loffset
8908 * field is either 0 or it is the offset returned from a previous
8909 * readdir. It is an opaque value used by the server to find the
8910 * correct directory block to read. The count field is the number
8911 * of blocks to read on the server. This is advisory only, the server
8912 * may return only one block's worth of entries. Entries may be compressed
8913 * on the server.
8914 */
8915 /* ARGSUSED */
8916 static int
8919 {
8921 uint_t count;
8932 /*
8933 * Make sure that the directory cache is valid.
8934 */
8937 /*
8938 * Setting nfs_disable_rddir_cache in /etc/system
8939 * allows interoperability with servers that do not
8940 * properly update the attributes of directories.
8941 * Any cached information gets purged before an
8942 * access is made to it.
8943 */
8945 }
8950 }
8954 /*
8955 * Short circuit last readdir which always returns 0 bytes.
8956 * This can be done after the directory has been read through
8957 * completely at least once. This will set r_direof which
8958 * can be used to find the value of the last cookie.
8959 */
8964 #ifdef DEBUG
8965 nfs4_readdir_cache_shorts++;
8966 #endif
8970 }
8972 /*
8973 * Look for a cache entry. Cache entries are identified
8974 * by the NFS cookie value and the byte count requested.
8975 */
8978 /*
8979 * If rdc is NULL then the lookup resulted in an unrecoverable error.
8980 */
8984 }
8986 /*
8987 * Check to see if we need to fill this entry in.
8988 */
8994 /*
8995 * Do the readdir.
8996 */
8999 /*
9000 * Reacquire the lock, so that we can continue
9001 */
9003 /*
9004 * The entry is now complete
9005 */
9007 }
9011 /*
9012 * If an error occurred while attempting
9013 * to fill the cache entry, mark the entry invalid and
9014 * just return the error.
9015 */
9022 }
9024 /*
9025 * The cache entry is complete and good,
9026 * copyout the dirent structs to the calling
9027 * thread.
9028 */
9031 /*
9032 * If no error occurred during the copyout,
9033 * update the offset in the uio struct to
9034 * contain the value of the next NFS 4 cookie
9035 * and set the eof value appropriately.
9036 */
9041 }
9043 /*
9044 * Decide whether to do readahead. Don't if we
9045 * have already read to the end of directory.
9046 */
9048 /*
9049 * Make the entry the direof only if it is cached
9050 */
9056 }
9058 /* Determine if a readdir readahead should be done */
9063 }
9065 /*
9066 * Now look for a readahead entry.
9067 *
9068 * Check to see whether we found an entry for the readahead.
9069 * If so, we don't need to do anything further, so free the new
9070 * entry if one was allocated. Otherwise, allocate a new entry, add
9071 * it to the cache, and then initiate an asynchronous readdir
9072 * operation to fill it.
9073 */
9076 /*
9077 * A readdir cache entry could not be obtained for the readahead. In
9078 * this case we skip the readahead and return.
9079 */
9084 }
9086 /*
9087 * Check to see if we need to fill this entry in.
9088 */
9094 #ifdef DEBUG
9095 nfs4_readdir_readahead++;
9096 #endif
9097 /*
9098 * Do the readdir.
9099 */
9102 }
9108 }
9110 static int
9112 {
9120 /*
9121 * Obtain the readdir results for the caller.
9122 */
9126 /*
9127 * The entry is now complete
9128 */
9138 }
9140 /*
9141 * Read directory entries.
9142 * There are some weird things to look out for here. The uio_loffset
9143 * field is either 0 or it is the offset returned from a previous
9144 * readdir. It is an opaque value used by the server to find the
9145 * correct directory block to read. The count field is the number
9146 * of blocks to read on the server. This is advisory only, the server
9147 * may return only one block's worth of entries. Entries may be compressed
9148 * on the server.
9149 *
9150 * Generates the following compound request:
9151 * 1. If readdir offset is zero and no dnlc entry for parent exists,
9152 * must include a Lookupp as well. In this case, send:
9153 * { Putfh <fh>; Readdir; Lookupp; Getfh; Getattr }
9154 * 2. Otherwise just do: { Putfh <fh>; Readdir }
9155 *
9156 * Get complete attributes and filehandles for entries if this is the
9157 * first read of the directory. Otherwise, just get fileid's.
9158 */
9159 static void
9161 {
9162 COMPOUND4args_clnt args;
9163 COMPOUND4res_clnt res;
9166 bitmap4 rd_bitsval;
9177 nfs4_recov_state_t recov_state;
9178 hrtime_t t;
9185 /*
9186 * If rp were a stub, it should have triggered and caused
9187 * a mount for us to get this far.
9188 */
9193 /*
9194 * Since nfsv4 readdir may not return entries for "." and "..",
9195 * the client must recreate them:
9196 * To find the correct nodeid, do the following:
9197 * For current node, get nodeid from dnlc.
9198 * - if current node is rootvp, set pnodeid to nodeid.
9199 * - else if parent is in the dnlc, get its nodeid from there.
9200 * - else add LOOKUPP+GETATTR to compound.
9201 */
9208 /* parent in dnlc cache - no need for otw */
9211 /*
9212 * parent not in dnlc cache,
9213 * do lookupp to get its id
9214 */
9217 }
9220 }
9221 }
9225 /* Save the original mount point security flavor */
9228 recov_retry:
9236 /*
9237 * If readdir a node that is a stub for a crossed mount point,
9238 * keep the original secinfo flavor for the current file
9239 * system, not the crossed one.
9240 */
9244 }
9246 /*
9247 * Determine which attrs to request for dirents. This code
9248 * must be protected by nfs4_start/end_fop because of r_server
9249 * (which will change during failover recovery).
9250 *
9251 */
9253 /*
9254 * Get all vattr attrs plus filehandle and rdattr_error
9255 */
9257 FATTR4_RDATTR_ERROR_MASK |
9258 FATTR4_FILEHANDLE_MASK;
9264 }
9268 /*
9269 * Already read directory. Use readdir with
9270 * no attrs (except for mounted_on_fileid) for updates.
9271 */
9274 /*
9275 * request mounted on fileid if supported, else request
9276 * fileid. maybe we should verify that fileid is supported
9277 * and request something else if not.
9278 */
9283 }
9285 /* putfh directory fh */
9291 /*
9292 * 1 and 2 are reserved for client "." and ".." entry offset.
9293 * cookie 0 should be used over-the-wire to start reading at
9294 * the beginning of the directory excluding "." and "..".
9295 */
9306 }
9316 /*
9317 * If count < than the minimum required, we return no entries
9318 * and fail with EINVAL
9319 */
9323 }
9326 /*
9327 * Add lookupp and getattr for parent nodeid.
9328 */
9333 /* getattr parent */
9337 }
9345 }
9347 /* capture the time of this call */
9356 }
9360 /*
9361 * If RPC error occurred and it isn't an error that
9362 * triggers recovery, then go ahead and fail now.
9363 */
9367 }
9370 bool_t abort;
9386 }
9388 }
9393 }
9395 /* fall through for res.status case */
9396 }
9400 /*
9401 * If compound failed first 2 ops (PUTFH+READDIR), then return
9402 * failure here. Subsequent ops are for filling out dot-dot
9403 * dirent, and if they fail, we still want to give the caller
9404 * the dirents returned by (the successful) READDIR op, so we need
9405 * to silently ignore failure for subsequent ops (LOOKUPP+GETATTR).
9406 *
9407 * One example where PUTFH+READDIR ops would succeed but
9408 * LOOKUPP+GETATTR would fail would be a dir that has r perm
9409 * but lacks x. In this case, a POSIX server's fop_readdir
9410 * would succeed; however, fop_lookup(..) would fail since no
9411 * x perm. We need to come up with a non-vendor-specific way
9412 * for a POSIX server to return d_ino from dotdot's dirent if
9413 * client only requests mounted_on_fileid, and just say the
9414 * LOOKUPP succeeded and fill out the GETATTR. However, if
9415 * client requested any mandatory attrs, server would be required
9416 * to fail the GETATTR op because it can't call fop_lookup+fop_getattr
9417 * for dotdot.
9418 */
9431 }
9432 /*
9433 * If readdir a node that is a stub for a
9434 * crossed mount point, keep the original
9435 * secinfo flavor for the current file system,
9436 * not the crossed one.
9437 */
9440 }
9441 }
9450 /*
9451 * For "." and ".." entries
9452 * e.g.
9453 * seek(cookie=0) -> "." entry with d_off = 1
9454 * seek(cookie=1) -> ".." entry with d_off = 2
9455 */
9461 }
9465 }
9468 /* LOOKUPP+GETATTR attemped */
9482 /*
9483 * First, take care of finishing the
9484 * readdir results.
9485 */
9487 /*
9488 * The d_ino of .. must be the inode number
9489 * of the mounted filesystem.
9490 */
9496 /*
9497 * Next, create the ".." dnlc entry
9498 */
9503 }
9505 }
9506 }
9513 }
9517 out:
9518 /*
9519 * If readdir a node that is a stub for a crossed mount point,
9520 * keep the original secinfo flavor for the current file system,
9521 * not the crossed one.
9522 */
9526 }
9529 static int
9531 {
9536 offset_t offset;
9547 read_again:
9548 /*
9549 * Releases the osp, if it is provided.
9550 * Puts a hold on the cred_otw and the new osp (if found).
9551 */
9560 /*
9561 * Didn't get it all because we hit EOF,
9562 * zero all the memory beyond the EOF.
9563 */
9564 /* bzero(rdaddr + */
9567 }
9571 /*
9572 * We didn't read anything at all as we are
9573 * past EOF. Return an error indicator back
9574 * but don't destroy the pages (yet).
9575 */
9577 }
9581 }
9584 write_again:
9585 /*
9586 * Releases the osp, if it is provided.
9587 * Puts a hold on the cred_otw and the new
9588 * osp (if found).
9589 */
9597 #ifdef DEBUG
9603 offset);
9611 }
9612 #endif
9618 }
9622 /*
9623 * Don't print EDQUOT errors on the console.
9624 * Don't print asynchronous EACCES errors.
9625 * Don't print EFBIG errors.
9626 * Print all other write errors.
9627 */
9633 /*
9634 * Update r_error and r_flags as appropriate.
9635 * If the error was ESTALE, then mark the
9636 * rnode as not being writeable and save
9637 * the error status. Otherwise, save any
9638 * errors which occur from asynchronous
9639 * page invalidations. Any errors occurring
9640 * from other operations should be saved
9641 * by the caller.
9642 */
9653 }
9655 }
9659 /*
9660 * A close may have cleared r_error, if so,
9661 * propagate ESTALE error return properly
9662 */
9665 }
9666 }
9677 }
9679 /* ARGSUSED */
9680 int
9682 {
9684 }
9686 /* ARGSUSED2 */
9687 int
9689 {
9695 }
9703 }
9707 }
9709 /* ARGSUSED */
9710 void
9712 {
9716 }
9718 /* ARGSUSED */
9719 static int
9721 {
9725 /*
9726 * Because we stuff the readdir cookie into the offset field
9727 * someone may attempt to do an lseek with the cookie which
9728 * we want to succeed.
9729 */
9735 }
9738 /*
9739 * Return all the pages from [off..off+len) in file
9740 */
9741 /* ARGSUSED */
9742 static int
9746 {
9763 /*
9764 * Now validate that the caches are up to date.
9765 */
9770 retry:
9773 /*
9774 * Don't create dirty pages faster than they
9775 * can be cleaned so that the system doesn't
9776 * get imbalanced. If the async queue is
9777 * maxed out, then wait for it to drain before
9778 * creating more dirty pages. Also, wait for
9779 * any threads doing pagewalks in the vop_getattr
9780 * entry points so that they don't block for
9781 * long periods.
9782 */
9788 }
9790 /*
9791 * If we are getting called as a side effect of an nfs_write()
9792 * operation the local file size might not be extended yet.
9793 * In this case we want to be able to return pages of zeroes.
9794 */
9802 }
9818 }
9821 }
9823 /*
9824 * Called from pvn_getpages to get a particular page.
9825 */
9826 /* ARGSUSED */
9827 static int
9831 {
9833 uint_t bsize;
9836 uoff_t lbn;
9837 uoff_t io_off;
9838 uoff_t blkoff;
9839 uoff_t rablkoff;
9841 uint_t blksize;
9856 reread:
9868 /*
9869 * Queueing up the readahead before doing the synchronous read
9870 * results in a significant increase in read throughput because
9871 * of the increased parallelism between the async threads and
9872 * the process context.
9873 */
9879 /*
9880 * Calculate the number of readaheads to do.
9881 * a) No readaheads at offset = 0.
9882 * b) Do maximum(nfs4_nra) readaheads when the readahead
9883 * window is closed.
9884 * c) Do readaheads between 1 to (nfs4_nra - 1) depending
9885 * upon how far the readahead window is open or close.
9886 * d) No readaheads if rp->r_nextr is not within the scope
9887 * of the readahead window (random i/o).
9888 */
9898 else
9909 }
9910 readahead--;
9912 /*
9913 * Indicate that we did a readahead so
9914 * readahead offset is not updated
9915 * by the synchronous read below.
9916 */
9919 /*
9920 * set readahead offset to
9921 * offset of last async readahead
9922 * request.
9923 */
9925 }
9927 }
9929 again:
9933 nfs4_readahead);
9935 /*
9936 * Block for this page is not allocated, or the offset
9937 * is beyond the current allocation size, or we're
9938 * allocating a swap slot and the page was not found,
9939 * so allocate it and return a zero page.
9940 */
9949 /*
9950 * Need to go to server to get a block
9951 */
9955 /*
9956 * If less than a block left in
9957 * file read less than a block.
9958 */
9960 /*
9961 * Trying to access beyond EOF,
9962 * set up to get at least one page.
9963 */
9978 /*
9979 * Some other thread has entered the page,
9980 * so just use it.
9981 */
9985 /*
9986 * Now round the request size up to page boundaries.
9987 * This ensures that the entire page will be
9988 * initialized to zeroes if EOF is encountered.
9989 */
9995 /*
9996 * pageio_setup should have set b_addr to 0. This
9997 * is correct since we want to do I/O on a page
9998 * boundary. bp_mapin will use this addr to calculate
9999 * an offset, and then set b_addr to the kernel virtual
10000 * address it allocated for us.
10001 */
10011 /*
10012 * If doing a write beyond what we believe is EOF,
10013 * don't bother trying to read the pages from the
10014 * server, we'll just zero the pages here. We
10015 * don't check that the rw flag is S_WRITE here
10016 * because some implementations may attempt a
10017 * read access to the buffer before copying data.
10018 */
10026 }
10028 /*
10029 * Unmap the buffer before freeing it.
10030 */
10040 /*
10041 * If doing a write system call just return
10042 * zeroed pages, else user tried to get pages
10043 * beyond EOF, return error. We don't check
10044 * that the rw flag is S_WRITE here because
10045 * some implementations may attempt a read
10046 * access to the buffer before copying data.
10047 */
10050 else
10052 }
10058 }
10059 }
10060 }
10062 out:
10070 }
10075 /*
10076 * Page exists in the cache, acquire the appropriate lock.
10077 * If this fails, start all over again.
10078 */
10080 #ifdef DEBUG
10081 nfs4_lostpage++;
10082 #endif
10084 }
10088 }
10094 }
10096 static void
10099 {
10102 uoff_t io_off;
10115 /*
10116 * If less than a block left in file read less
10117 * than a block.
10118 */
10126 /*
10127 * The isra flag passed to the kluster function is 1, we may have
10128 * gotten a return value of NULL for a variety of reasons (# of free
10129 * pages < minfree, someone entered the page on the vnode etc). In all
10130 * cases, we want to punt on the readahead.
10131 */
10135 /*
10136 * Now round the request size up to page boundaries.
10137 * This ensures that the entire page will be
10138 * initialized to zeroes if EOF is encountered.
10139 */
10145 /*
10146 * pageio_setup should have set b_addr to 0. This is correct since
10147 * we want to do I/O on a page boundary. bp_mapin() will use this addr
10148 * to calculate an offset, and then set b_addr to the kernel virtual
10149 * address it allocated for us.
10150 */
10160 /*
10161 * If doing a write beyond what we believe is EOF, don't bother trying
10162 * to read the pages from the server, we'll just zero the pages here.
10163 * We don't check that the rw flag is S_WRITE here because some
10164 * implementations may attempt a read access to the buffer before
10165 * copying data.
10166 */
10177 }
10179 /*
10180 * Unmap the buffer before freeing it.
10181 */
10192 /*
10193 * In case of error set readahead offset
10194 * to the lowest offset.
10195 * pvn_read_done() calls VN_DISPOSE to destroy the pages
10196 */
10202 }
10203 }
10205 /*
10206 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
10207 * If len == 0, do from off to EOF.
10208 *
10209 * The normal cases should be len == 0 && off == 0 (entire vp list) or
10210 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
10211 * (from pageout).
10212 */
10213 /* ARGSUSED */
10214 static int
10217 {
10230 /*
10231 * XXX - Why should this check be made here?
10232 */
10250 }
10252 /*
10253 * Write out a single page, possibly klustering adjacent dirty pages.
10254 */
10255 int
10258 {
10259 uoff_t io_off;
10260 uoff_t lbn_off;
10261 uoff_t lbn;
10263 uint_t bsize;
10280 /*
10281 * Find a kluster that fits in one block, or in
10282 * one page if pages are bigger than blocks. If
10283 * there is less file space allocated than a whole
10284 * page, we'll shorten the i/o request below.
10285 */
10289 /*
10290 * pvn_write_kluster shouldn't have returned a page with offset
10291 * behind the original page we were given. Verify that.
10292 */
10295 /*
10296 * Now pp will have the list of kept dirty pages marked for
10297 * write back. It will also handle invalidation and freeing
10298 * of pages that are not dirty. Check for page length rounding
10299 * problems.
10300 */
10304 }
10305 /*
10306 * The R4MODINPROGRESS flag makes sure that nfs4_bio() sees a
10307 * consistent value of r_size. R4MODINPROGRESS is set in writerp4().
10308 * When R4MODINPROGRESS is set it indicates that a uiomove() is in
10309 * progress and the r_size has not been made consistent with the
10310 * new size of the file. When the uiomove() completes the r_size is
10311 * updated and the R4MODINPROGRESS flag is cleared.
10312 *
10313 * The R4MODINPROGRESS flag makes sure that nfs4_bio() sees a
10314 * consistent value of r_size. Without this handshaking, it is
10315 * possible that nfs4_bio() picks up the old value of r_size
10316 * before the uiomove() in writerp4() completes. This will result
10317 * in the write through nfs4_bio() being dropped.
10318 *
10319 * More precisely, there is a window between the time the uiomove()
10320 * completes and the time the r_size is updated. If a fop_putpage()
10321 * operation intervenes in this window, the page will be picked up,
10322 * because it is dirty (it will be unlocked, unless it was
10323 * pagecreate'd). When the page is picked up as dirty, the dirty
10324 * bit is reset (pvn_getdirty()). In nfs4write(), r_size is
10325 * checked. This will still be the old size. Therefore the page will
10326 * not be written out. When segmap_release() calls fop_putpage(),
10327 * the page will be found to be clean and the write will be dropped.
10328 */
10335 /*
10336 * A write is in progress for this region of the file.
10337 * If we did not detect R4MODINPROGRESS here then this
10338 * path through nfs_putapage() would eventually go to
10339 * nfs4_bio() and may not write out all of the data
10340 * in the pages. We end up losing data. So we decide
10341 * to set the modified bit on each page in the page
10342 * list and mark the rnode with R4DIRTY. This write
10343 * will be restarted at some later time.
10344 */
10352 }
10360 }
10362 }
10366 nfs4_sync_putapage);
10375 }
10377 static int
10380 {
10399 }
10402 /*
10403 * If this was not an async thread, then try again to
10404 * write out the pages, but this time, also destroy
10405 * them whether or not the write is successful. This
10406 * will prevent memory from filling up with these
10407 * pages and destroying them is the only alternative
10408 * if they can't be written out.
10409 *
10410 * Don't do this if this is an async thread because
10411 * when the pages are unlocked in pvn_write_done,
10412 * some other thread could have come along, locked
10413 * them, and queued for an async thread. It would be
10414 * possible for all of the async threads to be tied
10415 * up waiting to lock the pages again and they would
10416 * all already be locked and waiting for an async
10417 * thread to handle them. Deadlock.
10418 */
10422 }
10430 }
10434 NFS4_WRITE_NOWAIT);
10435 }
10438 }
10440 #ifdef DEBUG
10442 #endif
10444 /* ARGSUSED */
10445 static int
10449 {
10467 /*
10468 * If the file is delegated to the client don't do anything.
10469 * If the file is not delegated, then validate the data cache.
10470 */
10479 }
10481 /*
10482 * Check to see if the vnode is currently marked as not cachable.
10483 * This means portions of the file are locked (through fop_frlock).
10484 * In this case the map request must be refused. We use
10485 * rp->r_lkserlock to avoid a race with concurrent lock requests.
10486 *
10487 * Atomically increment r_inmap after acquiring r_rwlock. The
10488 * idea here is to acquire r_rwlock to block read/write and
10489 * not to protect r_inmap. r_inmap will inform nfs4_read/write()
10490 * that we are in nfs4_map(). Now, r_rwlock is acquired in order
10491 * and we can prevent the deadlock that would have occurred
10492 * when nfs4_addmap() would have acquired it out of order.
10493 *
10494 * Since we are not protecting r_inmap by any lock, we do not
10495 * hold any lock when we decrement it. We atomically decrement
10496 * r_inmap after we release r_lkserlock.
10497 */
10507 }
10512 }
10514 /*
10515 * Don't allow concurrent locks and mapping if mandatory locking is
10516 * enabled.
10517 */
10527 }
10528 }
10530 /*
10531 * It is possible that the rnode has a lost lock request that we
10532 * are still trying to recover, and that the request conflicts with
10533 * this map request.
10534 *
10535 * An alternative approach would be for nfs4_safemap() to consider
10536 * queued lock requests when deciding whether to set or clear
10537 * VNOCACHE. This would require the frlock code path to call
10538 * nfs4_safemap() after enqueing a lost request.
10539 */
10543 }
10550 }
10553 /*
10554 * We need to retrieve the open stream
10555 */
10561 /* returns with 'os_sync_lock' held */
10564 }
10566 #ifdef DEBUG
10570 }
10571 #endif
10572 /* returns with 'os_sync_lock' held */
10576 "nfs4_map: we tried to OPEN the file "
10579 }
10580 }
10586 "nfs4_map: os_failed_reopen set on "
10591 }
10594 }
10610 done:
10614 }
10616 /*
10617 * We're most likely dealing with a kernel module that likes to READ
10618 * and mmap without OPENing the file (ie: lookup/read/mmap), so lets
10619 * officially OPEN the file to create the necessary client state
10620 * for bookkeeping of os_mmap_read/write counts.
10621 *
10622 * Since fop_map only passes in a pointer to the vnode rather than
10623 * a double pointer, we can't handle the case where nfs4open_otw()
10624 * returns a different vnode than the one passed into fop_map (since
10625 * fop_delmap will not see the vnode nfs4open_otw used). In this case,
10626 * we return NULL and let nfs4_map() fail. Note: the only case where
10627 * this should happen is if the file got removed and replaced with the
10628 * same name on the server (in addition to the fact that we're trying
10629 * to fop_map withouth fop_opening the file in the first place).
10630 */
10631 static int
10633 {
10653 }
10659 }
10667 /* This is needed so we don't bump the open ref count */
10672 }
10677 just_created);
10683 }
10688 /*
10689 * If nfs4open_otw() returned a different vnode then "undo"
10690 * the open and return failure to the caller.
10691 */
10693 nfs4_error_t e;
10697 /*
10698 * If there's an error, ignore it,
10699 * and let fop_inactive handle it.
10700 */
10705 }
10711 nfs4_error_t e;
10715 /*
10716 * If there's an error, ignore it,
10717 * and let fop_inactive handle it.
10718 */
10722 }
10727 }
10729 /*
10730 * Please be aware that when this function is called, the address space write
10731 * a_lock is held. Do not put over the wire calls in this function.
10732 */
10733 /* ARGSUSED */
10734 static int
10738 {
10751 /*
10752 * Don't need to update the open stream first, since this
10753 * mmap can't add any additional share access that isn't
10754 * already contained in the open stream (for the case where we
10755 * open/mmap/only update rp->r_mapcnt/server reboots/reopen doesn't
10756 * take into account os_mmap_read[write] counts).
10757 */
10761 /*
10762 * We need to retrieve the open stream and update the counts.
10763 * If there is no open stream here, something is wrong.
10764 */
10770 /* returns with 'os_sync_lock' held */
10773 }
10776 "nfs4_addmap: we should have an osp"
10780 }
10785 /*
10786 * Update the map count in the open stream.
10787 * This is necessary in the case where we
10788 * open/mmap/close/, then the server reboots, and we
10789 * attempt to reopen. If the mmap doesn't add share
10790 * access then we send an invalid reopen with
10791 * access = NONE.
10792 *
10793 * We need to specifically check each PROT_* so a mmap
10794 * call of (PROT_WRITE | PROT_EXEC) will ensure us both
10795 * read and write access. A simple comparison of prot
10796 * to ~PROT_WRITE to determine read access is insufficient
10797 * since prot can be |= with PROT_USER, etc.
10798 */
10800 /*
10801 * Unless we're MAP_SHARED, no sense in adding os_mmap_write
10802 */
10809 /*
10810 * Ensure that os_mmap_read gets incremented, even if
10811 * maxprot were to look like PROT_NONE.
10812 */
10819 }
10821 out:
10822 /*
10823 * If we got an error, then undo our
10824 * incrementing of 'r_mapcnt'.
10825 */
10830 }
10832 }
10834 /* ARGSUSED */
10835 static int
10837 {
10840 }
10842 /* ARGSUSED */
10843 static int
10847 {
10852 nfs4_error_t e;
10857 /* check for valid cmd parameter */
10861 /* Verify l_type. */
10877 }
10879 /* check the validity of the lock range */
10885 /*
10886 * If the filesystem is mounted using local locking, pass the
10887 * request off to the local locking code.
10888 */
10891 /*
10892 * For complete safety, we should be holding
10893 * r_lkserlock. However, we can't call
10894 * nfs4_safelock and then fs_frlock while
10895 * holding r_lkserlock, so just invoke
10896 * nfs4_safelock and expect that this will
10897 * catch enough of the cases.
10898 */
10901 }
10903 }
10907 /*
10908 * Check whether the given lock request can proceed, given the
10909 * current file mappings.
10910 */
10917 }
10918 }
10920 /*
10921 * Flush the cache after waiting for async I/O to finish. For new
10922 * locks, this is so that the process gets the latest bits from the
10923 * server. For unlocks, this is so that other clients see the
10924 * latest bits once the file has been unlocked. If currently dirty
10925 * pages can't be flushed, then don't allow a lock to be set. But
10926 * allow unlocks to succeed, to avoid having orphan locks on the
10927 * server.
10928 */
10943 }
10948 }
10949 }
10960 }
10964 }
10965 }
10966 }
10968 /*
10969 * Call the lock manager to do the real work of contacting
10970 * the server and obtaining the lock.
10971 */
10979 done:
10983 }
10985 /*
10986 * Free storage space associated with the specified vnode. The portion
10987 * to be freed is specified by bfp->l_start and bfp->l_len (already
10988 * normalized to a "whence" of 0).
10989 *
10990 * This is an experimental facility whose continued existence is not
10991 * guaranteed. Currently, we only support the special case
10992 * of l_len == 0, meaning free to end of file.
10993 */
10994 /* ARGSUSED */
10995 static int
10998 {
11021 }
11024 }
11026 /* ARGSUSED */
11027 int
11029 {
11035 }
11038 }
11040 /*
11041 * Setup and add an address space callback to do the work of the delmap call.
11042 * The callback will (and must be) deleted in the actual callback function.
11043 *
11044 * This is done in order to take care of the problem that we have with holding
11045 * the address space's a_lock for a long period of time (e.g. if the NFS server
11046 * is down). Callbacks will be executed in the address space code while the
11047 * a_lock is not held. Holding the address space's a_lock causes things such
11048 * as ps and fork to hang because they are trying to acquire this lock as well.
11049 */
11050 /* ARGSUSED */
11051 static int
11055 {
11065 /*
11066 * A process may not change zones if it has NFS pages mmap'ed
11067 * in, so we can't legitimately get here from the wrong zone.
11068 */
11073 /*
11074 * The way that the address space of this process deletes its mapping
11075 * of this file is via the following call chains:
11076 * - as_free()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs4_delmap()
11077 * - as_unmap()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs4_delmap()
11078 *
11079 * With the use of address space callbacks we are allowed to drop the
11080 * address space lock, a_lock, while executing the NFS operations that
11081 * need to go over the wire. Returning EAGAIN to the caller of this
11082 * function is what drives the execution of the callback that we add
11083 * below. The callback will be executed by the address space code
11084 * after dropping the a_lock. When the callback is finished, since
11085 * we dropped the a_lock, it must be re-acquired and segvn_unmap()
11086 * is called again on the same segment to finish the rest of the work
11087 * that needs to happen during unmapping.
11088 *
11089 * This action of calling back into the segment driver causes
11090 * nfs4_delmap() to get called again, but since the callback was
11091 * already executed at this point, it already did the work and there
11092 * is nothing left for us to do.
11093 *
11094 * To Summarize:
11095 * - The first time nfs4_delmap is called by the current thread is when
11096 * we add the caller associated with this delmap to the delmap caller
11097 * list, add the callback, and return EAGAIN.
11098 * - The second time in this call chain when nfs4_delmap is called we
11099 * will find this caller in the delmap caller list and realize there
11100 * is no more work to do thus removing this caller from the list and
11101 * returning the error that was set in the callback execution.
11102 */
11105 /*
11106 * 'error' is from the actual delmap operations. To avoid
11107 * hangs, we need to handle the return of EAGAIN differently
11108 * since this is what drives the callback execution.
11109 * In this case, we don't want to return EAGAIN and do the
11110 * callback execution because there are none to execute.
11111 */
11114 else
11116 }
11118 /* current caller was not in the list */
11141 }
11145 {
11153 }
11155 static void
11157 {
11159 }
11161 /*
11162 * Searches for the current delmap caller (based on curthread) in the list of
11163 * callers. If it is found, we remove it and free the delmap caller.
11164 * Returns:
11165 * 0 if the caller wasn't found
11166 * 1 if the caller was found, removed and freed. *errp will be set
11167 * to what the result of the delmap was.
11168 */
11169 static int
11171 {
11174 /*
11175 * If the list doesn't exist yet, we create it and return
11176 * that the caller wasn't found. No list = no callers.
11177 */
11180 /* The list does not exist */
11187 /* The list exists so search it */
11192 /* current caller is in the list */
11198 }
11199 }
11200 }
11203 }
11205 /*
11206 * Remove some pages from an mmap'd vnode. Just update the
11207 * count of pages. If doing close-to-open, then flush and
11208 * commit all of the pages associated with this file.
11209 * Otherwise, start an asynchronous page flush to write out
11210 * any dirty pages. This will also associate a credential
11211 * with the rnode which can be used to write the pages.
11212 */
11213 /* ARGSUSED */
11214 static void
11216 {
11228 /*
11229 * Initiate a page flush and potential commit if there are
11230 * pages, the file system was not mounted readonly, the segment
11231 * was mapped shared, and the pages themselves were writeable.
11232 */
11246 }
11259 }
11261 /* Check to see if we need to close the file */
11268 /*
11269 * Since it is possible that e.error == 0 and
11270 * e.stat != NFS4_OK (and vice versa),
11271 * we do the proper checking in order to get both
11272 * e.error and e.stat reporting the correct info.
11273 */
11282 }
11283 }
11287 }
11290 static uint_t
11292 {
11297 }
11301 }
11304 }
11307 }
11310 }
11313 }
11316 }
11318 }
11320 static int
11322 {
11333 }
11335 /* ARGSUSED */
11336 int
11339 {
11341 hrtime_t t;
11343 nfs4_ga_res_t gar;
11344 nfs4_ga_ext_res_t ger;
11353 }
11357 }
11361 /*
11362 * The existence of the xattr directory is not sufficient
11363 * for determining whether generic user attributes exists.
11364 * The attribute directory could only be a transient directory
11365 * used for Solaris sysattr support. Do a small readdir
11366 * to verify if the only entries are sysattrs or not.
11367 *
11368 * pc4_xattr_valid can be only be trusted when r_xattr_dir
11369 * is NULL. Once the xadir vp exists, we can create xattrs,
11370 * and we don't have any way to update the "base" object's
11371 * pc4_xattr_exists from the xattr or xadir. Maybe FEM
11372 * could help out.
11373 */
11377 }
11407 }
11409 #ifdef DEBUG
11410 nfs4_pathconf_cache_hits++;
11411 #endif
11413 }
11415 }
11416 }
11417 #ifdef DEBUG
11418 nfs4_pathconf_cache_misses++;
11419 #endif
11431 }
11433 /* interpret the max filesize */
11437 /* Store the attributes we just received */
11460 }
11464 }
11467 }
11469 /*
11470 * Called by async thread to do synchronous pageio. Do the i/o, wait
11471 * for it to complete, and cleanup the page list when done.
11472 */
11473 static int
11476 {
11484 else
11487 }
11489 /* ARGSUSED */
11490 static int
11493 {
11510 nfs4_sync_pageio);
11518 }
11520 /* ARGSUSED */
11521 static void
11524 {
11529 offset3 offset;
11530 count3 len;
11531 k_sigset_t smask;
11533 /*
11534 * We should get called with fl equal to either B_FREE or
11535 * B_INVAL. Any other value is illegal.
11536 *
11537 * The page that we are either supposed to free or destroy
11538 * should be exclusive locked and its io lock should not
11539 * be held.
11540 */
11546 /*
11547 * If the page doesn't need to be committed or we shouldn't
11548 * even bother attempting to commit it, then just make sure
11549 * that the p_fsdata byte is clear and then either free or
11550 * destroy the page as appropriate.
11551 */
11556 else
11559 }
11561 /*
11562 * If there is a page invalidation operation going on, then
11563 * if this is one of the pages being destroyed, then just
11564 * clear the p_fsdata byte and then either free or destroy
11565 * the page as appropriate.
11566 */
11573 else
11576 }
11578 /*
11579 * If we are freeing this page and someone else is already
11580 * waiting to do a commit, then just unlock the page and
11581 * return. That other thread will take care of commiting
11582 * this page. The page can be freed sometime after the
11583 * commit has finished. Otherwise, if the page is marked
11584 * as delay commit, then we may be getting called from
11585 * pvn_write_done, one page at a time. This could result
11586 * in one commit per page, so we end up doing lots of small
11587 * commits instead of fewer larger commits. This is bad,
11588 * we want do as few commits as possible.
11589 */
11595 }
11601 }
11602 }
11604 /*
11605 * Check to see if there is a signal which would prevent an
11606 * attempt to commit the pages from being successful. If so,
11607 * then don't bother with all of the work to gather pages and
11608 * generate the unsuccessful RPC. Just return from here and
11609 * let the page be committed at some later time.
11610 */
11617 }
11620 /*
11621 * We are starting to need to commit pages, so let's try
11622 * to commit as many as possible at once to reduce the
11623 * overhead.
11624 *
11625 * Set the `commit inprogress' state bit. We must
11626 * first wait until any current one finishes. Then
11627 * we initialize the c_pages list with this page.
11628 */
11633 }
11641 /*
11642 * Gather together all other pages which can be committed.
11643 * They will all be chained off r_commit.c_pages.
11644 */
11647 /*
11648 * Clear the `commit inprogress' status and disconnect
11649 * the list of pages to be committed from the rnode.
11650 * At this same time, we also save the starting offset
11651 * and length of data to be committed on the server.
11652 */
11667 }
11669 /*
11670 * Actually generate the COMMIT op over the wire operation.
11671 */
11674 /*
11675 * If we got an error during the commit, just unlock all
11676 * of the pages. The pages will get retransmitted to the
11677 * server during a putpage operation.
11678 */
11684 }
11686 }
11688 /*
11689 * We've tried as hard as we can to commit the data to stable
11690 * storage on the server. We just unlock the rest of the pages
11691 * and clear the commit required state. They will be put
11692 * onto the tail of the cachelist if they are nolonger
11693 * mapped.
11694 */
11700 }
11702 /*
11703 * It is possible that nfs4_commit didn't return error but
11704 * some other thread has modified the page we are going
11705 * to free/destroy.
11706 * In this case we need to rewrite the page. Do an explicit check
11707 * before attempting to free/destroy the page. If modified, needs to
11708 * be rewritten so unlock the page and return.
11709 */
11714 }
11716 /*
11717 * Now, as appropriate, either free or destroy the page
11718 * that we were called with.
11719 */
11723 else
11725 }
11727 /*
11728 * Commit requires that the current fh be the file written to.
11729 * The compound op structure is:
11730 * PUTFH(file), COMMIT
11731 */
11732 static int
11734 {
11735 COMPOUND4args_clnt args;
11736 COMPOUND4res_clnt res;
11745 nfs4_recov_state_t recov_state;
11758 get_commit_cred:
11759 /*
11760 * Releases the osp, if a valid open stream is provided.
11761 * Puts a hold on the cred_otw and the new osp (if found).
11762 */
11766 recov_retry:
11767 /*
11768 * Commit ops: putfh file; commit
11769 */
11780 }
11782 /* putfh directory */
11786 /* commit */
11797 needrecov);
11804 }
11815 }
11823 }
11824 /* fall through for res.status case */
11825 }
11835 }
11836 /*
11837 * Can't do a nfs4_purge_stale_fh here because this
11838 * can cause a deadlock. nfs4_commit can
11839 * be called from nfs4_dispose which can be called
11840 * indirectly via pvn_vplist_dirty. nfs4_purge_stale_fh
11841 * can call back to pvn_vplist_dirty.
11842 */
11855 }
11870 }
11875 }
11884 }
11886 static void
11888 {
11891 /* make sure we're looking at the master vnode, not a shadow */
11893 }
11895 /*
11896 * This function is used to gather a page list of the pages which
11897 * can be committed on the server.
11898 *
11899 * The calling thread must have set R4COMMIT. This bit is used to
11900 * serialize access to the commit structure in the rnode. As long
11901 * as the thread has set R4COMMIT, then it can manipulate the commit
11902 * structure without requiring any other locks.
11903 *
11904 * When this function is called from nfs4_dispose() the page passed
11905 * into nfs4_dispose() will be SE_EXCL locked, and so this function
11906 * will skip it. This is not a problem since we initially add the
11907 * page to the r_commit page list.
11908 *
11909 */
11910 static void
11912 {
11921 /* make sure we're looking at the master vnode, not a shadow */
11929 /*
11930 * Step through all of the pages associated with this vnode
11931 * looking for pages which need to be committed.
11932 */
11936 /* Skip marker pages. */
11940 /*
11941 * First short-cut everything (without the page_lock)
11942 * and see if this page does not need to be committed
11943 * or is modified if so then we'll just skip it.
11944 */
11948 /*
11949 * Attempt to lock the page. If we can't, then
11950 * someone else is messing with it or we have been
11951 * called from nfs4_dispose and this is the page that
11952 * nfs4_dispose was called with.. anyway just skip it.
11953 */
11957 /*
11958 * Lets check again now that we have the page lock.
11959 */
11963 }
11965 /* this had better not be a free page */
11968 /*
11969 * The page needs to be committed and we locked it.
11970 * Update the base and length parameters and add it
11971 * to r_pages.
11972 */
11984 }
11986 }
11989 }
11991 /*
11992 * This routine is used to gather together a page list of the pages
11993 * which are to be committed on the server. This routine must not
11994 * be called if the calling thread holds any locked pages.
11995 *
11996 * The calling thread must have set R4COMMIT. This bit is used to
11997 * serialize access to the commit structure in the rnode. As long
11998 * as the thread has set R4COMMIT, then it can manipulate the commit
11999 * structure without requiring any other locks.
12000 */
12001 static void
12003 {
12007 uoff_t end;
12008 uoff_t off;
12015 /* make sure we're looking at the master vnode, not a shadow */
12020 /*
12021 * If there are no pages associated with this vnode, then
12022 * just return.
12023 */
12026 /*
12027 * Calculate the ending offset.
12028 */
12031 /*
12032 * Lookup each page by vp, offset.
12033 */
12036 /*
12037 * If this page does not need to be committed or is
12038 * modified, then just skip it.
12039 */
12043 }
12046 /*
12047 * The page needs to be committed and we locked it.
12048 * Update the base and length parameters and add it
12049 * to r_pages.
12050 */
12057 }
12059 }
12060 }
12062 /*
12063 * Called from nfs4_close(), nfs4_fsync() and nfs4_delmap().
12064 * Flushes and commits data to the server.
12065 */
12066 static int
12068 {
12070 verifier4 write_verf;
12075 /*
12076 * Flush the data portion of the file and then commit any
12077 * portions which need to be committed. This may need to
12078 * be done twice if the server has changed state since
12079 * data was last written. The data will need to be
12080 * rewritten to the server and then a new commit done.
12081 *
12082 * In fact, this may need to be done several times if the
12083 * server is having problems and crashing while we are
12084 * attempting to do this.
12085 */
12087 top:
12088 /*
12089 * Do a flush based on the poff and plen arguments. This
12090 * will synchronously write out any modified pages in the
12091 * range specified by (poff, plen). This starts all of the
12092 * i/o operations which will be waited for in the next
12093 * call to nfs4_putpage
12094 */
12104 /*
12105 * Do a flush based on the poff and plen arguments. This
12106 * will synchronously write out any modified pages in the
12107 * range specified by (poff, plen) and wait until all of
12108 * the asynchronous i/o's in that range are done as well.
12109 */
12120 }
12123 /*
12124 * Now commit any pages which might need to be committed.
12125 * If the error, NFS_VERF_MISMATCH, is returned, then
12126 * start over with the flush operation.
12127 */
12134 }
12136 /*
12137 * nfs4_commit_vp() will wait for other pending commits and
12138 * will either commit the whole file or a range, plen dictates
12139 * if we commit whole file. a value of zero indicates the whole
12140 * file. Called from nfs4_putpage_commit() or nfs4_sync_putapage()
12141 */
12142 static int
12145 {
12148 offset3 offset;
12149 count3 len;
12155 /*
12156 * before we gather commitable pages make
12157 * sure there are no outstanding async writes
12158 */
12163 }
12165 }
12167 /*
12168 * Set the `commit inprogress' state bit. We must
12169 * first wait until any current one finishes.
12170 */
12176 }
12180 /*
12181 * Gather all of the pages which need to be
12182 * committed.
12183 */
12186 else
12189 /*
12190 * Clear the `commit inprogress' bit and disconnect the
12191 * page list which was gathered by nfs4_get_commit.
12192 */
12202 /*
12203 * If any pages need to be committed, commit them and
12204 * then unlock them so that they can be freed some
12205 * time later.
12206 */
12210 /*
12211 * No error occurred during the flush portion
12212 * of this operation, so now attempt to commit
12213 * the data to stable storage on the server.
12214 *
12215 * This will unlock all of the pages on the list.
12216 */
12218 }
12220 static int
12223 {
12231 /*
12232 * If we got an error, then just unlock all of the pages
12233 * on the list.
12234 */
12240 }
12242 }
12243 /*
12244 * We've tried as hard as we can to commit the data to stable
12245 * storage on the server. We just unlock the pages and clear
12246 * the commit required state. They will get freed later.
12247 */
12253 }
12256 }
12258 static void
12261 {
12264 }
12266 /*ARGSUSED*/
12267 static int
12270 {
12273 vattr_t va;
12274 vsecattr_t nfsace4_vsap;
12280 /* if we have a delegation, return it */
12286 NFS4_ACL_SET);
12291 /*
12292 * These are aclent_t type entries.
12293 */
12299 /*
12300 * These are ace_t type entries.
12301 */
12303 FALSE);
12306 }
12311 }
12313 }
12315 /* ARGSUSED */
12316 int
12319 {
12322 nfs4_ga_res_t gar;
12332 /*
12333 * vsecattr->vsa_mask holds the original acl request mask.
12334 * This is needed when determining what to return.
12335 * (See: nfs4_create_getsecattr_return())
12336 */
12341 /*
12342 * If this is a referral stub, don't try to go OTW for an ACL
12343 */
12348 /*
12349 * Check if the data is cached and the cache is valid. If it
12350 * is we don't go over the wire.
12351 */
12362 }
12363 }
12365 }
12367 /*
12368 * The getattr otw call will always get both the acl, in
12369 * the form of a list of nfsace4's, and the number of acl
12370 * entries; independent of the value of gar.n4g_va.va_mask.
12371 */
12378 }
12381 /*
12382 * No error was returned, but according to the response
12383 * bitmap, neither was an acl.
12384 */
12388 }
12390 /*
12391 * Update the cache with the ACL.
12392 */
12403 }
12405 }
12408 }
12410 /*
12411 * The function returns:
12412 * - 0 (zero) if the passed in "acl_mask" is a valid request.
12413 * - EINVAL if the passed in "acl_mask" is an invalid request.
12414 *
12415 * In the case of getting an acl (op == NFS4_ACL_GET) the mask is invalid if:
12416 * - We have a mixture of ACE and ACL requests (e.g. VSA_ACL | VSA_ACE)
12417 *
12418 * In the case of setting an acl (op == NFS4_ACL_SET) the mask is invalid if:
12419 * - We have a mixture of ACE and ACL requests (e.g. VSA_ACL | VSA_ACE)
12420 * - We have a count field set without the corresponding acl field set. (e.g. -
12421 * VSA_ACECNT is set, but VSA_ACE is not)
12422 */
12423 static int
12425 {
12426 /* Shortcut the masks that are always valid. */
12433 /*
12434 * We can't have any VSA_ACL type stuff in the mask now.
12435 */
12437 VSA_DFACLCNT))
12443 }
12444 }
12447 /*
12448 * We can't have any VSA_ACE type stuff in the mask now.
12449 */
12460 }
12461 }
12463 }
12465 /*
12466 * The theory behind creating the correct getsecattr return is simply this:
12467 * "Don't return anything that the caller is not expecting to have to free."
12468 */
12469 static int
12472 {
12474 /* Save the mask since the translators modify it. */
12483 /*
12484 * If the caller only asked for the ace count (VSA_ACECNT)
12485 * don't give them the full acl (VSA_ACE), free it.
12486 */
12492 }
12493 }
12497 VSA_DFACLCNT)) {
12504 /*
12505 * If the caller only asked for the acl count (VSA_ACLCNT)
12506 * and/or the default acl count (VSA_DFACLCNT) don't give them
12507 * the acl (VSA_ACL) or default acl (VSA_DFACL), free it.
12508 */
12514 }
12515 }
12522 }
12523 }
12525 }
12527 }
12529 /* ARGSUSED */
12530 int
12533 {
12538 /*
12539 * check for valid cmd parameter
12540 */
12544 /*
12545 * Check access permissions
12546 */
12552 /*
12553 * If the filesystem is mounted using local locking, pass the
12554 * request off to the local share code.
12555 */
12562 /*
12563 * This will be properly implemented later,
12564 * see RFE: 4823948 .
12565 */
12570 /*
12571 * NFS client can't store remote locks itself
12572 */
12580 }
12583 }
12585 /*
12586 * Common code called by directory ops to update the attrcache
12587 */
12588 static int
12591 {
12597 /* getattr not done or failed */
12600 }
12606 }
12608 }
12610 /*
12611 * Update directory caches for directory modification ops (link, rename, etc.)
12612 * When dinfo is NULL, manage dircaches in the old way.
12613 */
12614 static void
12617 {
12622 /* Purge rddir cache for dir since it changed */
12626 /*
12627 * If caller provided dinfo, then use it to manage dir caches.
12628 */
12636 /*
12637 * XXX don't update if the created_v4 flag is
12638 * set
12639 */
12644 }
12645 }
12651 }
12653 /*
12654 * Caller didn't provide dinfo, then check change_info4 to update DNLC.
12655 * Since caller modified dir but didn't receive post-dirmod-op dir
12656 * attrs, the dir's attrs must be purged.
12657 *
12658 * XXX this check and dnlc update/purge should really be atomic,
12659 * XXX but can't use rnode statelock because it'll deadlock in
12660 * XXX dnlc_purge_vp, however, the risk is minimal even if a race
12661 * XXX does occur.
12662 *
12663 * XXX We also may want to check that atomic is true in the
12664 * XXX change_info struct. If it is not, the change_info may
12665 * XXX reflect changes by more than one clients which means that
12666 * XXX our cache may not be valid.
12667 */
12670 /* no changes took place in the directory prior to our link */
12677 /*
12678 * XXX dont' update if the created_v4 flag
12679 * is set
12680 */
12683 "nfs4_update_dircaches: don't"
12685 }
12686 }
12688 /* Another client modified directory - purge its dnlc cache */
12690 }
12691 }
12693 /*
12694 * The OPEN_CONFIRM operation confirms the sequence number used in OPENing a
12695 * file.
12696 *
12697 * The 'reopening_file' boolean should be set to TRUE if we are reopening this
12698 * file (ie: client recovery) and otherwise set to FALSE.
12699 *
12700 * 'nfs4_start/end_op' should have been called by the proper (ie: not recovery
12701 * initiated) calling functions.
12702 *
12703 * 'resend' is set to TRUE if this is a OPEN_CONFIRM issued as a result
12704 * of resending a 'lost' open request.
12705 *
12706 * 'num_bseqid_retryp' makes sure we don't loop forever on a broken
12707 * server that hands out BAD_SEQID on open confirm.
12708 *
12709 * Errors are returned via the nfs4_error_t parameter.
12710 */
12711 void
12715 {
12716 COMPOUND4args_clnt args;
12717 COMPOUND4res_clnt res;
12726 #if DEBUG
12730 #endif
12732 recov_retry_confirm:
12738 else
12744 /* putfh target fh */
12761 }
12785 }
12786 }
12796 }
12797 /* State may have changed so retry the entire OPEN op */
12800 else
12805 }
12810 }
12817 }
12819 /*
12820 * Return the credentials associated with a client state object. The
12821 * caller is responsible for freeing the credentials.
12822 */
12826 {
12829 /*
12830 * It's ok to not lock the open stream and open owner to get
12831 * the oo_cred since this is only written once (upon creation)
12832 * and will not change.
12833 */
12838 }
12840 /*
12841 * nfs4_find_sysid
12842 *
12843 * Find the sysid for the knetconfig associated with the given mi.
12844 */
12847 {
12850 /*
12851 * Switch from RDMA knconf to original mount knconf
12852 */
12855 }
12857 #ifdef DEBUG
12858 /*
12859 * Return a string version of the call type for easy reading.
12860 */
12863 {
12877 }
12878 }
12879 #endif
12881 /*
12882 * Map the frlock cmd and lock type to the NFSv4 over-the-wire lock type
12883 * Unlock requests don't have an over-the-wire locktype, so we just return
12884 * something non-threatening.
12885 */
12887 static nfs_lock_type4
12889 {
12898 else
12903 else
12905 }
12907 /*NOTREACHED*/
12908 }
12910 /*
12911 * Do some preliminary checks for nfs4frlock.
12912 */
12913 static int
12915 uoff_t offset)
12916 {
12919 /*
12920 * If we are setting a lock, check that the file is opened
12921 * with the correct mode.
12922 */
12927 "nfs4frlock_validate_args: file was opened with "
12930 }
12931 }
12933 /* Convert the offset. It may need to be restored before returning. */
12937 error));
12939 }
12942 }
12944 /*
12945 * Set the flock64's lm_sysid for nfs4frlock.
12946 */
12947 static int
12949 {
12952 /* Find the lm_sysid */
12959 }
12964 }
12966 /*
12967 * Do the remaining preliminary setup for nfs4frlock.
12968 */
12969 static void
12973 {
12974 /*
12975 * set tick_delay to the base delay time.
12976 * (NFS4_BASE_WAIT_TIME is in secs)
12977 */
12981 /*
12982 * If lock is relative to EOF, we need the newest length of the
12983 * file. Therefore invalidate the ATTR_CACHE.
12984 */
12994 }
12996 /*
12997 * Initialize and allocate the data structures necessary for
12998 * the nfs4frlock call.
12999 * Allocates argsp's op array.
13000 */
13001 static void
13006 {
13015 /* fill array with zero */
13024 /* initialize in case of error; will get real value down below */
13029 else
13031 }
13033 /*
13034 * Call the nfs4_start_fop() for nfs4frlock, if necessary. Assign
13035 * the proper nfs4_server_t for this instance of nfs4frlock.
13036 * Returns 0 (success) or an errno value.
13037 */
13038 static int
13042 {
13057 }
13062 /* If the file failed recovery, just quit. */
13066 }
13068 }
13071 }
13073 /*
13074 * Setup the LOCK4/LOCKU4 arguments for resending a lost lock request. A
13075 * resend nfs4frlock call is initiated by the recovery framework.
13076 * Acquires the lop and oop seqid synchronization.
13077 */
13078 static void
13083 {
13099 }
13101 /* Must resend this lost lock/locku request. */
13140 }
13167 }
13168 }
13169 }
13171 /*
13172 * Setup the LOCKT4 arguments.
13173 */
13174 static void
13178 {
13187 /*
13188 * The locktype will be READ_LT unless it's
13189 * a write lock. We do this because the Solaris
13190 * system call allows the combination of
13191 * F_UNLCK and F_GETLK* and so in that case the
13192 * unlock is mapped to a read.
13193 */
13196 else
13200 /* set the lock owner4 args */
13210 }
13212 /*
13213 * If the client is holding a delegation, and the open stream to be used
13214 * with this lock request is a delegation open stream, then re-open the stream.
13215 * Sets the nfs4_error_t to all zeros unless the open stream has already
13216 * failed a reopen or we couldn't find the open stream. NFS4ERR_DELAY
13217 * means the caller should retry (like a recovery retry).
13218 */
13219 static void
13221 {
13222 open_delegation_type4 dt;
13225 open_claim_type4 oclaim;
13244 }
13245 /* returns with 'os_sync_lock' held */
13251 }
13256 "nfs4frlock_check_deleg: os_failed_reopen set "
13264 }
13266 /*
13267 * Determine whether a reopen is needed. If this
13268 * is a delegation open stream, then send the open
13269 * to the server to give visibility to the open owner.
13270 * Even if it isn't a delegation open stream, we need
13271 * to check if the previous open CLAIM_DELEGATE_CUR
13272 * was sufficient.
13273 */
13285 /*
13286 * Always use CLAIM_PREVIOUS after server reboot.
13287 * The server will reject CLAIM_DELEGATE_CUR if
13288 * it is used during the grace period.
13289 */
13297 }
13304 }
13305 }
13308 }
13309 }
13311 /*
13312 * Setup the LOCKU4 arguments.
13313 * Returns errors via the nfs4_error_t.
13314 * NFS4_OK no problems. *go_otwp is TRUE if call should go
13315 * over-the-wire. The caller must release the
13316 * reference on *lopp.
13317 * NFS4ERR_DELAY caller should retry (like recovery retry)
13318 * (other) unrecoverable error.
13319 */
13320 static void
13326 {
13329 pid_t pid;
13343 else
13348 /* locktype should be set to any legal value */
13354 /*
13355 * Get the lock owner stateid. If no lock owner
13356 * exists, return success.
13357 */
13363 /*
13364 * No lock owner so no locks to unlock.
13365 * Return success. If there was a failed
13366 * reclaim earlier, the lock might still be
13367 * registered with the local locking code,
13368 * so notify it of the unlock.
13369 *
13370 * If the lockowner is using a special stateid,
13371 * then the original lock request (that created
13372 * this lockowner) was never successful, so we
13373 * have no lock to undo OTW.
13374 */
13376 "nfs4frlock_setup_locku_args: LOCKU: no lock owner "
13382 /*
13383 * Release our hold and NULL out so final_cleanup
13384 * doesn't try to end a lock seqid sync we
13385 * never started.
13386 */
13390 }
13394 }
13401 }
13408 /* leave the ref count on lop, rele after RPC call */
13416 }
13418 /*
13419 * Setup the LOCK4 arguments.
13420 *
13421 * Returns errors via the nfs4_error_t.
13422 * NFS4_OK no problems
13423 * NFS4ERR_DELAY caller should retry (like recovery retry)
13424 * (other) unrecoverable error
13425 */
13426 static void
13431 {
13436 pid_t pid;
13450 else
13455 /*
13456 * Get the lock owner. If no lock owner exists,
13457 * create a 'temporary' one and grab the open seqid
13458 * synchronization (which puts a hold on the open
13459 * owner and open stream).
13460 * This also grabs the lock seqid synchronization.
13461 */
13477 out:
13481 }
13483 /*
13484 * After we get the reply from the server, record the proper information
13485 * for possible resend lock requests.
13486 */
13487 static void
13492 {
13502 "nfs4frlock_save_lost_rqst: set lo_pending_rqsts to 1 "
13508 }
13513 /*
13514 * For lock/locku requests, we treat EINTR as ETIMEDOUT for
13515 * recovery purposes so that the lock request that was sent
13516 * can be saved and re-issued later. Ditto for EIO from a forced
13517 * unmount. This is done to have the client's local locking state
13518 * match the v4 server's state; that is, the request was
13519 * potentially received and accepted by the server but the client
13520 * thinks it was not.
13521 */
13526 "nfs4frlock_save_lost_rqst: got a lost %s lock for "
13534 }
13535 /*
13536 * Objects are held and rele'd via the recovery code.
13537 * See nfs4_save_lost_rqst.
13538 */
13556 }
13558 }
13559 }
13561 /*
13562 * Update lop's seqid. Also update the seqid stored in a resend request,
13563 * if any. (Some recovery errors increment the seqid, and we may have to
13564 * send the resend request again.)
13565 */
13567 static void
13570 {
13577 }
13581 }
13582 }
13584 /*
13585 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13586 * COMPOUND4 args/res for calls that need to retry.
13587 * Switches the *cred_otwp to base_cr.
13588 */
13589 static void
13595 {
13603 needrecov);
13605 }
13621 }
13623 /* need to free up the reference on osp for lock args */
13627 }
13629 /* need to free up the reference on oop for lock args */
13634 }
13639 }
13641 /*
13642 * Function to process the client's recovery for nfs4frlock.
13643 * Returns TRUE if we should retry the lock request; FALSE otherwise.
13644 *
13645 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13646 * COMPOUND4 args/res for calls that need to retry.
13647 *
13648 * Note: the rp's r_lkserlock is *not* dropped during this path.
13649 */
13650 static bool_t
13658 {
13678 nfs_opnum4 op;
13683 seqid4 seqid;
13689 else
13696 }
13700 }
13709 }
13711 /*
13712 * Return that we do not want to retry the request for 3 cases:
13713 * 1. If we received EINTR or are bailing out because of a forced
13714 * unmount, we came into this code path just for the sake of
13715 * initiating recovery, we now need to return the error.
13716 * 2. If we have aborted recovery.
13717 * 3. We received NFS4ERR_BAD_SEQID.
13718 */
13725 needrecov);
13727 }
13744 }
13749 }
13753 /* need to free up the reference on osp for lock args */
13757 }
13759 /* need to free up the reference on oop for lock args */
13764 }
13767 }
13769 /*
13770 * Handles the successful reply from the server for nfs4frlock.
13771 */
13772 static void
13776 {
13782 /*
13783 * We do not register lost locks locally in
13784 * the 'resend' case since the user/application
13785 * doesn't think we have the lock.
13786 */
13789 }
13790 }
13791 }
13793 /*
13794 * Handle the DENIED reply from the server for nfs4frlock.
13795 * Returns TRUE if we should retry the request; FALSE otherwise.
13796 *
13797 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13798 * COMPOUND4 args/res for calls that need to retry. Can also
13799 * drop and regrab the r_lkserlock.
13800 */
13801 static bool_t
13811 {
13820 /*
13821 * Blocking lock needs to sleep and retry from the request.
13822 *
13823 * Do not block and wait for 'resend' or 'reinstate'
13824 * lock requests, just return the error.
13825 *
13826 * Note: reclaim requests have cmd == F_SETLK, not F_SETLKW.
13827 */
13854 }
13859 }
13870 }
13875 /*
13876 * Make sure we are still safe to lock with
13877 * regards to mmapping.
13878 */
13882 }
13885 }
13899 /* according to NLM code */
13904 }
13906 }
13908 /*
13909 * Handles all NFS4 errors besides NFS4_OK and NFS4ERR_DENIED for nfs4frlock.
13910 */
13911 static void
13913 {
13947 "nfs4frlock_results_default: got unrecognizable "
13950 }
13951 }
13953 /*
13954 * The lock request was successful, so update the client's state.
13955 */
13956 static void
13961 {
13968 /* update the stateid with server's response */
13974 }
13978 /*
13979 * If the lock was the result of a resending a lost
13980 * request, we've synched up the stateid and seqid
13981 * with the server, but now the server might be out of sync
13982 * with what the application thinks it has for locks.
13983 * Clean that up here. It's unclear whether we should do
13984 * this even if the filesystem has been forcibly unmounted.
13985 * For most servers, it's probably wasted effort, but
13986 * RFC 7530 lets servers require that unlocks exactly match
13987 * the locks that are held.
13988 */
13994 }
14000 /* Update the stateid with the server's response */
14003 /* Switch the lock type to express success, see fcntl */
14006 }
14007 }
14009 /*
14010 * Do final cleanup before exiting nfs4frlock.
14011 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
14012 * COMPOUND4 args/res for calls that haven't already.
14013 */
14014 static void
14023 {
14031 /*
14032 * The client recovery code wants the raw status information,
14033 * so don't map the NFS status code to an errno value for
14034 * non-normal call types.
14035 */
14041 needrecov);
14043 /*
14044 * We've established a new lock on the server, so invalidate
14045 * the pages associated with the vnode to get the most up to
14046 * date pages from the server after acquiring the lock. We
14047 * want to be sure that the read operation gets the newest data.
14048 * N.B.
14049 * We used to do this in nfs4frlock_results_ok but that doesn't
14050 * work since fop_putpage can call nfs4_commit which calls
14051 * nfs4_start_fop. We flush the pages below after calling
14052 * nfs4_end_fop above
14053 * The flush of the page cache must be done after
14054 * nfs4_end_open_seqid_sync() to avoid a 4-way hang.
14055 */
14058 }
14069 }
14071 /* free the reference on the lock owner */
14075 }
14077 /* need to free up the reference on osp for lock args */
14081 /* need to free up the reference on oop for lock args */
14085 }
14094 /*
14095 * Record debug information in the event we get EINVAL.
14096 */
14102 "%s operation failed with "
14103 "EINVAL probably since the server, %s,"
14108 }
14109 }
14114 }
14116 /*
14117 * This calls the server and the local locking code.
14118 *
14119 * Client locks are registerred locally by oring the sysid with
14120 * LM_SYSID_CLIENT. The server registers locks locally using just the sysid.
14121 * We need to distinguish between the two to avoid collision in case one
14122 * machine is used as both client and server.
14123 *
14124 * Blocking lock requests will continually retry to acquire the lock
14125 * forever.
14126 *
14127 * The ctype is defined as follows:
14128 * NFS4_LCK_CTYPE_NORM: normal lock request.
14129 *
14130 * NFS4_LCK_CTYPE_RECLAIM: bypass the usual calls for synchronizing with client
14131 * recovery, get the pid from flk instead of curproc, and don't reregister
14132 * the lock locally.
14133 *
14134 * NFS4_LCK_CTYPE_RESEND: same as NFS4_LCK_CTYPE_RECLAIM, with the addition
14135 * that we will use the information passed in via resend_rqstp to setup the
14136 * lock/locku request. This resend is the exact same request as the 'lost
14137 * lock', and is initiated by the recovery framework. A successful resend
14138 * request can initiate one or more reinstate requests.
14139 *
14140 * NFS4_LCK_CTYPE_REINSTATE: same as NFS4_LCK_CTYPE_RESEND, except that it
14141 * does not trigger additional reinstate requests. This lock call type is
14142 * set for setting the v4 server's locking state back to match what the
14143 * client's local locking state is in the event of a received 'lost lock'.
14144 *
14145 * Errors are returned via the nfs4_error_t parameter.
14146 */
14147 void
14151 {
14167 nfs4_recov_state_t recov_state;
14169 nfs4_op_hint_t op_hint;
14170 nfs4_lost_rqst_t lost_rqst;
14177 #ifdef DEBUG
14179 #endif
14183 #ifdef DEBUG
14193 #endif
14205 recov_retry:
14217 /*
14218 * Leave the request for the recovery system to deal with.
14219 */
14237 }
14241 }
14243 /* putfh directory fh */
14247 /*
14248 * Set up the over-the-wire arguments and get references to the
14249 * open owner, etc.
14250 */
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 uoff_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 fop_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 fop_open but never did fop_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 fop_close.
15073 * CLOSE_DELMAP: close initiated via fop_delmap.
15074 * CLOSE_FORCE: close initiated via fop_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 fop_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 our 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 }