| blob | 6b71a0d80b6aebc9cdb671825a72d6b96c54c091 |
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/file.h>
52 #include <sys/filio.h>
53 #include <sys/uio.h>
54 #include <sys/buf.h>
55 #include <sys/mman.h>
56 #include <sys/pathname.h>
57 #include <sys/dirent.h>
58 #include <sys/debug.h>
59 #include <sys/vmsystm.h>
60 #include <sys/fcntl.h>
61 #include <sys/flock.h>
62 #include <sys/swap.h>
63 #include <sys/errno.h>
64 #include <sys/strsubr.h>
65 #include <sys/sysmacros.h>
66 #include <sys/kmem.h>
67 #include <sys/cmn_err.h>
68 #include <sys/pathconf.h>
69 #include <sys/utsname.h>
70 #include <sys/dnlc.h>
71 #include <sys/acl.h>
72 #include <sys/systeminfo.h>
73 #include <sys/policy.h>
74 #include <sys/sdt.h>
75 #include <sys/list.h>
76 #include <sys/stat.h>
77 #include <sys/zone.h>
79 #include <rpc/types.h>
80 #include <rpc/auth.h>
81 #include <rpc/clnt.h>
83 #include <nfs/nfs.h>
84 #include <nfs/nfs_clnt.h>
85 #include <nfs/nfs_acl.h>
86 #include <nfs/lm.h>
87 #include <nfs/nfs4.h>
88 #include <nfs/nfs4_kprot.h>
89 #include <nfs/rnode4.h>
90 #include <nfs/nfs4_clnt.h>
92 #include <vm/hat.h>
93 #include <vm/as.h>
94 #include <vm/page.h>
95 #include <vm/pvn.h>
96 #include <vm/seg.h>
97 #include <vm/seg_map.h>
98 #include <vm/seg_kpm.h>
99 #include <vm/seg_vn.h>
101 #include <sys/fs_subr.h>
103 #include <sys/ddi.h>
104 #include <sys/int_fmtio.h>
105 #include <sys/fs/autofs.h>
110 hrtime_t di_time_call;
114 NFS4_ACL_GET,
115 NFS4_ACL_SET
127 cred_t *);
129 stable_how4 *);
133 vsecattr_t *);
144 caller_context_t *);
156 cred_t *);
168 cred_t *);
170 cred_t *);
176 uoff_t);
185 nfs4_lock_owner_t *);
195 /*
196 * Routines that implement the setting of v4 args for the misc. ops
197 */
202 nfs4_stateid_types_t *);
205 bitmap4);
210 /*
211 * These are the vnode ops functions that implement the vnode interface to
212 * the networked file system. See more comments below at nfs4_vnodeops.
213 */
216 caller_context_t *);
218 caller_context_t *);
220 caller_context_t *);
222 caller_context_t *);
224 caller_context_t *);
227 caller_context_t *);
231 vsecattr_t *);
251 caller_context_t *);
266 caller_context_t *);
268 caller_context_t *);
269 /*
270 * These vnode ops are required to be called from outside this source file,
271 * e.g. by ephemeral mount stub vnode ops, and so may not be declared
272 * as static.
273 */
275 caller_context_t *);
285 caller_context_t *);
287 caller_context_t *);
289 caller_context_t *);
291 /*
292 * Used for nfs4_commit_vp() to indicate if we should
293 * wait on pending writes.
294 */
295 #define NFS4_WRITE_NOWAIT 0
296 #define NFS4_WRITE_WAIT 1
300 /*
301 * Error flags used to pass information about certain special errors
302 * which need to be handled specially.
303 */
304 #define NFS_EOF -98
305 #define NFS_VERF_MISMATCH -97
307 /*
308 * Flags used to differentiate between which operation drove the
309 * potential CLOSE OTW. (see nfs4_close_otw_if_necessary)
310 */
311 #define NFS4_CLOSE_OP 0x1
312 #define NFS4_DELMAP_OP 0x2
313 #define NFS4_INACTIVE_OP 0x3
315 #define ISVDEV(t) ((t == VBLK) || (t == VCHR) || (t == VFIFO))
317 /* ALIGN64 aligns the given buffer and adjust buffer size to 64 bit */
318 #define ALIGN64(x, ptr, sz) \
319 x = ((uintptr_t)(ptr)) & (sizeof (uint64_t) - 1); \
320 if (x) { \
321 x = sizeof (uint64_t) - (x); \
322 sz -= (x); \
323 ptr += (x); \
324 }
326 #ifdef DEBUG
367 #endif
369 /*
370 * How long to wait before trying again if OPEN_CONFIRM gets ETIMEDOUT
371 * or NFS4ERR_RESOURCE.
372 */
377 /*
378 * number of pages to read ahead
379 * optimized for 100 base-T.
380 */
387 /*
388 * These are the vnode ops routines which implement the vnode interface to
389 * the networked file system. These routines just take their parameters,
390 * make them look networkish by putting the right info into interface structs,
391 * and then calling the appropriate remote routine(s) to do the work.
392 *
393 * Note on directory name lookup cacheing: If we detect a stale fhandle,
394 * we purge the directory cache relative to that vnode. This way, the
395 * user won't get burned by the cache repeatedly. See <nfs/rnode4.h> for
396 * more details on rnode locking.
397 */
433 /* no separate nfs4_dump */
442 };
444 /*
445 * The following are subroutines and definitions to set args or get res
446 * for the different nfsv4 ops
447 */
449 void
451 {
461 }
462 }
463 }
465 static void
467 {
477 }
478 }
479 }
481 static void
483 {
488 }
489 }
491 static void
495 {
500 /*
501 * The stateid is set to 0 if client is not modifying the size
502 * and otherwise to whatever nfs4_get_stateid() returns.
503 *
504 * XXX Note: nfs4_get_stateid() returns 0 if no lockowner and/or no
505 * state struct could be found for the process/file pair. We may
506 * want to change this in the future (by OPENing the file). See
507 * bug # 4474852.
508 */
520 }
525 }
527 static void
529 {
531 }
533 static int
535 bitmap4 supp)
536 {
550 }
556 }
558 static void
560 {
570 }
571 }
573 static void
576 {
586 }
588 void
590 {
594 }
598 }
599 }
601 /*
602 * XXX: This is referenced in modstubs.s
603 */
606 {
608 }
610 /*
611 * The OPEN operation opens a regular file.
612 */
613 /*ARGSUSED3*/
614 static int
616 {
628 /*
629 * Check to see if opening something besides a regular file;
630 * if so skip the OTW call
631 */
635 }
637 /*
638 * XXX - would like a check right here to know if the file is
639 * executable or not, so as to skip OTW
640 */
652 }
654 /*
655 * See if this file has just been CREATEd.
656 * If so, clear the flag and update the dnlc, which was previously
657 * skipped in nfs4_create.
658 * XXX need better serilization on this.
659 * XXX move this into the nf4open_otw call, after we have
660 * XXX acquired the open owner seqid sync.
661 */
668 /* This is needed so we don't bump the open ref count */
673 }
675 /*
676 * If caller specified O_TRUNC/FTRUNC, then be sure to set
677 * FWRITE (to drive successful setattr(size=0) after open)
678 */
683 just_been_created);
690 /* release the hold from vtodv */
693 /* exchange the shadow for the master vnode, if needed */
699 }
701 /*
702 * See if there's a "lost open" request to be saved and recovered.
703 */
704 static void
708 {
718 }
725 /*
726 * The vp (if it is not NULL) and dvp are held and rele'd via
727 * the recovery code. See nfs4_save_lost_rqst.
728 */
745 }
750 }
753 uint32 seconds;
754 uint32 nseconds;
755 };
757 /*
758 * The OPEN operation creates and/or opens a regular file
759 *
760 * ARGSUSED
761 */
762 static int
766 {
775 COMPOUND4args_clnt args;
776 COMPOUND4res_clnt res;
795 nfs4_recov_state_t recov_state;
796 nfs4_lost_rqst_t lost_rqst;
798 hrtime_t t;
809 /*
810 * Make sure we properly deal with setting the right gid on
811 * a newly created file to reflect the parent's setgid bit
812 */
816 /*
817 * If there is grpid mount flag used or
818 * the parent's directory has the setgid bit set
819 * _and_ the client was able to get a valid mapping
820 * for the parent dir's owner_group, we want to
821 * append NVERIFY(owner_group == dva.va_gid) and
822 * SETATTR to the CREATE compound.
823 */
831 }
833 }
835 /*
836 * Normal/non-create compound:
837 * PUTFH(dfh) + OPEN(create) + GETFH + GETATTR(new)
838 *
839 * Open(create) compound no setgid:
840 * PUTFH(dfh) + SAVEFH + OPEN(create) + GETFH + GETATTR(new) +
841 * RESTOREFH + GETATTR
842 *
843 * Open(create) setgid:
844 * PUTFH(dfh) + OPEN(create) + GETFH + GETATTR(new) +
845 * SAVEFH + PUTFH(dfh) + GETATTR(dvp) + RESTOREFH +
846 * NVERIFY(grp) + SETATTR
847 */
860 }
872 /*
873 * We are to create a file. Initialize the passed in vnode
874 * pointer.
875 */
878 /*
879 * Check to see if the client owns a read delegation and is
880 * trying to open for write. If so, then return the delegation
881 * to avoid the server doing a cb_recall and returning DELAY.
882 * NB - we don't use the statev4_lock here because we'd have
883 * to drop the lock anyway and the result would be stale.
884 */
889 /*
890 * If the file has a delegation, then do an access check up
891 * front. This avoids having to an access check later after
892 * we've already done start_op, which could deadlock.
893 */
901 }
902 }
910 recov_retry:
920 }
926 /* putfh directory fh */
930 /* OPEN: either op 1 or op 2 depending upon create/setgid flags */
935 /* name of file */
941 /* CREATE a file */
950 timestruc_t now;
955 }
956 /*
957 * Since the server will use this value for the
958 * mtime, make sure that it can't overflow. Zero
959 * out the MSB. The actual value does not matter
960 * here, only its uniqeness.
961 */
964 }
966 /* Now copy over verifier to OPEN4args. */
970 bitmap4 supp_attrs;
980 /* GUARDED4 or UNCHECKED4 */
982 supp_attrs);
992 }
993 }
995 /* NO CREATE */
997 }
1004 /* XXX should we just fail here? */
1006 }
1008 /*
1009 * This increments oop's ref count or creates a temporary 'just_created'
1010 * open owner that will become valid when this OPEN/OPEN_CONFIRM call
1011 * completes.
1012 */
1015 /* See if a permanent or just created open owner exists */
1018 /*
1019 * This open owner does not exist so create a temporary
1020 * just created one.
1021 */
1024 }
1027 /* this length never changes, do alloc before seqid sync */
1040 }
1042 }
1044 /* Check to see if we need to do the OTW call */
1049 /*
1050 * The OTW open is not necessary. Either
1051 * the open can succeed without it (eg.
1052 * delegation, error == 0) or the open
1053 * must fail due to an access failure
1054 * (error != 0). In either case, tidy
1055 * up and return.
1056 */
1066 }
1067 }
1083 /*
1084 * getfh w/sanity check for idx_open/idx_fattr
1085 */
1089 /* getattr */
1095 vattr_t _v;
1097 bitmap4 supp_attrs;
1104 /*
1105 * For setgid case, we need to:
1106 * 4:savefh(new) 5:putfh(dir) 6:getattr(dir) 7:restorefh(new)
1107 */
1119 /*
1120 * nverify
1121 */
1125 supp_attrs))) {
1127 /*
1128 * setattr
1129 *
1130 * We _know_ we're not messing with AT_SIZE or
1131 * AT_XTIME, so no need for stateid or flags.
1132 * Also we specify NULL rp since we're only
1133 * interested in setting owner_group attributes.
1134 */
1139 }
1142 /*
1143 * XXX - Revisit the last argument to nfs4_end_op()
1144 * once 5020486 is fixed.
1145 */
1154 }
1163 }
1191 num_bseqid_retry--;
1192 }
1200 /* give up if we keep getting BAD_SEQID */
1205 }
1213 }
1219 }
1224 }
1226 }
1228 /*
1229 * Will check and update lease after checking the rflag for
1230 * OPEN_CONFIRM in the successful OPEN call.
1231 */
1234 /*
1235 * XXX what if we're crossing mount points from server1:/drp
1236 * to server2:/drp/rp.
1237 */
1239 /* Signal our end of use of the open seqid */
1242 /*
1243 * This will destroy the open owner if it was just created,
1244 * and no one else has put a reference on it.
1245 */
1256 }
1259 /*
1260 * If the reply is NFS4ERR_ACCESS, it may be because
1261 * we are root (no root net access). If the real uid
1262 * is not root, then retry with the real uid instead.
1263 */
1267 }
1272 }
1275 }
1280 #ifdef DEBUG
1281 /*
1282 * verify attrset bitmap
1283 */
1286 /* make sure attrset returned is what we asked for */
1287 /* XXX Ignore this 'error' for now */
1290 }
1291 #endif
1297 }
1304 /*
1305 * The open stateid has been updated on the server but not
1306 * on the client yet. There is a path: makenfs4node->nfs4_attr_cache->
1307 * flush_pages->fop_putpage->...->nfs4write where we will issue an OTW
1308 * WRITE call. That, however, will use the old stateid, so go ahead
1309 * and upate the open stateid now, before any call to makenfs4node.
1310 */
1320 }
1322 /*
1323 * We must determine if the file handle given by the otw open
1324 * is the same as the file handle which was passed in with
1325 * *vpp. This case can be reached if the file we are trying
1326 * to open has been removed and another file has been created
1327 * having the same file name. The passed in vnode is released
1328 * later.
1329 */
1332 }
1344 /*
1345 * For the newly created vp case, make sure the rnode
1346 * isn't bad before using it.
1347 */
1359 }
1362 needrecov);
1370 }
1373 }
1376 /*
1377 * It seems odd to get a full set of attrs and then not update
1378 * the object's attrcache in the non-create case. Create case uses
1379 * the attrs since makenfs4node checks to see if the attrs need to
1380 * be updated (and then updates them). The non-create case should
1381 * update attrs also.
1382 */
1385 }
1389 /* This does not do recovery for vp explicitly. */
1399 }
1402 needrecov);
1405 /* rele the makenfs4node */
1407 }
1411 }
1414 "nfs4open_otw: retry the open since OPEN "
1420 "createmode from GUARDED4 to "
1423 }
1425 }
1432 }
1435 }
1436 }
1446 /* Doesn't matter if 'oo_just_created' already was set as this */
1454 /* returns with 'os_sync_lock' held */
1468 }
1479 }
1489 /*
1490 * Need to reset this bitfield for the possible case where we were
1491 * going to OTW CLOSE the file, got a non-recoverable error, and before
1492 * we could retry the CLOSE, OPENed the file again.
1493 */
1497 #ifdef DEBUG
1502 #endif
1513 }
1515 /* get rid of our reference to find oop */
1520 /* accept delegation, if any */
1529 /*
1530 * If doing an exclusive create, then generate
1531 * a SETATTR to set the initial attributes.
1532 * Try to set the mtime and the atime to the
1533 * server's current time. It is somewhat
1534 * expected that these fields will be used to
1535 * store the exclusive create cookie. If not,
1536 * server implementors will need to know that
1537 * a SETATTR will follow an exclusive create
1538 * and the cookie should be destroyed if
1539 * appropriate.
1540 *
1541 * The AT_GID and AT_SIZE bits are turned off
1542 * so that the SETATTR request will not attempt
1543 * to process these. The gid will be set
1544 * separately if appropriate. The size is turned
1545 * off because it is assumed that a new file will
1546 * be created empty and if the file wasn't empty,
1547 * then the exclusive create will have failed
1548 * because the file must have existed already.
1549 * Therefore, no truncate operation is needed.
1550 */
1556 /*
1557 * Couldn't correct the attributes of
1558 * the newly created file and the
1559 * attributes are wrong. Remove the
1560 * file and return an error to the
1561 * application.
1562 */
1563 /* XXX will this take care of client state ? */
1565 "nfs4open_otw: EXCLUSIVE4: error %d on SETATTR:"
1569 /*
1570 * Since we've reled the vnode and removed
1571 * the file we now need to return the error.
1572 * At this point we don't want to update the
1573 * dircaches, call nfs4_waitfor_purge_complete
1574 * or set vpp to vp so we need to skip these
1575 * as well.
1576 */
1578 }
1579 }
1581 /*
1582 * If we created or found the correct vnode, due to create_flag or
1583 * fh_differs being set, then update directory cache attribute, readdir
1584 * and dnlc caches.
1585 */
1589 /*
1590 * Make sure getattr succeeded before using results.
1591 * note: op 7 is getattr(dir) for both flavors of
1592 * open(create).
1593 */
1602 }
1605 dinfop);
1606 }
1608 /*
1609 * If the page cache for this file was flushed from actions
1610 * above, it was done asynchronously and if that is true,
1611 * there is a need to wait here for it to complete. This must
1612 * be done outside of start_fop/end_fop.
1613 */
1616 /*
1617 * It is implicit that we are in the open case (create_flag == 0) since
1618 * fh_differs can only be set to a non-zero value in the open case.
1619 */
1623 /*
1624 * Be sure to set *vpp to the correct value before returning.
1625 */
1628 skip_update_dircaches:
1634 }
1641 }
1643 /*
1644 * Reopen an open instance. cf. nfs4open_otw().
1645 *
1646 * Errors are returned by the nfs4_error_t parameter.
1647 * - ep->error contains an errno value or zero.
1648 * - if it is zero, ep->stat is set to an NFS status code, if any.
1649 * If the file could not be reopened, but the caller should continue, the
1650 * file is marked dead and no error values are returned. If the caller
1651 * should stop recovering open files and start over, either the ep->error
1652 * value or ep->stat will indicate an error (either something that requires
1653 * recovery or EAGAIN). Note that some recovery (e.g., expired volatile
1654 * filehandles) may be handled silently by this routine.
1655 * - if it is EINTR, ETIMEDOUT, or NFS4_FRC_UNMT_ERR, recovery for lost state
1656 * will be started, so the caller should not do it.
1657 *
1658 * Gotos:
1659 * - kill_file : reopen failed in such a fashion to constitute marking the
1660 * file dead and setting the open stream's 'os_failed_reopen' as 1. This
1661 * is for cases where recovery is not possible.
1662 * - failed_reopen : same as above, except that the file has already been
1663 * marked dead, so no need to do it again.
1664 * - bailout : reopen failed but we are able to recover and retry the reopen -
1665 * either within this function immediately or via the calling function.
1666 */
1668 void
1671 bool_t is_recov)
1672 {
1673 COMPOUND4args_clnt args;
1674 COMPOUND4res_clnt res;
1684 seqid4 seqid;
1688 nfs4_lost_rqst_t lost_rqst;
1690 bool_t abort;
1693 hrtime_t t;
1701 /* this is the cred used to find the open owner */
1706 }
1707 /* use this cred for OTW operations */
1710 top:
1714 /* File system has been unmounted, quit */
1718 }
1726 }
1734 }
1736 /*
1737 * If the rnode has a delegation and the delegation has been
1738 * recovered and the server didn't request a recall and the caller
1739 * didn't specifically ask for CLAIM_PREVIOUS (nfs4frlock during
1740 * recovery) and the rnode hasn't been marked dead, then install
1741 * the delegation stateid in the open stream. Otherwise, proceed
1742 * with a CLAIM_PREVIOUS or CLAIM_NULL OPEN.
1743 */
1757 }
1760 /*
1761 * If the file failed recovery, just quit. This failure need not
1762 * affect other reopens, so don't return an error.
1763 */
1769 }
1772 /*
1773 * argop is empty here
1774 *
1775 * PUTFH, OPEN, GETATTR
1776 */
1788 /*
1789 * if this is a file mount then
1790 * use the mntinfo parentfh
1791 */
1796 /* putfh fh to reopen */
1798 }
1812 /* nothing allocated yet */
1814 }
1819 /*
1820 * We have two cases to deal with here:
1821 * 1) We're being called to reopen files in order to satisfy
1822 * a lock operation request which requires us to explicitly
1823 * reopen files which were opened under a delegation. If
1824 * we're in recovery, we *must* use CLAIM_PREVIOUS. In
1825 * that case, frc_use_claim_previous is TRUE and we must
1826 * use the rnode's current delegation type (r_deleg_type).
1827 * 2) We're reopening files during some form of recovery.
1828 * In this case, frc_use_claim_previous is FALSE and we
1829 * use the delegation type appropriate for recovery
1830 * (r_deleg_needs_recovery).
1831 */
1834 frc_use_claim_previous ?
1843 "failed for vp 0x%p for CLAIM_DELEGATE_CUR "
1847 /* nothing allocated yet */
1849 }
1857 }
1889 /* Construct the getfh part of the compound */
1892 /* Construct the getattr part of the compound */
1913 }
1925 }
1930 }
1941 }
1966 /*
1967 * Retry as a plain open. We don't need to worry about
1968 * checking the changeinfo: it is acceptable for a
1969 * client to re-open a file and continue processing
1970 * (in the absence of locks).
1971 */
1973 "nfs4_reopen: CLAIM_PREVIOUS: NFS4ERR_NO_GRACE; "
1978 }
1979 failed_msg =
2006 /* recover filehandle and retry */
2022 /*
2023 * Do not mark the file dead and let the calling
2024 * function initiate recovery.
2025 */
2043 }
2044 /* fall through */
2054 }
2061 /*
2062 * Check if the path we reopened really is the same
2063 * file. We could end up in a situation where the file
2064 * was removed and a new file created with the same name.
2065 */
2073 /* Oops, we don't have the same file */
2077 else
2087 /*
2088 * We have volatile file handles that don't compare.
2089 * If the fids are the same then we assume that the
2090 * file handle expired but the rnode still refers to
2091 * the same file object.
2092 *
2093 * First check that we have fids or not.
2094 * If we don't we have a dumb server so we will
2095 * just assume every thing is ok for now.
2096 */
2100 /*
2101 * We have fids, but they don't
2102 * compare. So kill the file.
2103 */
2104 failed_msg =
2105 "Couldn't reopen: file handle changed"
2113 /*
2114 * We have volatile file handles that refers
2115 * to the same file (at least they have the
2116 * same fid) or we don't have fids so we
2117 * can't tell. :(. We'll be a kind and accepting
2118 * client so we'll update the rnode's file
2119 * handle with the otw handle.
2120 *
2121 * We need to drop mi->mi_fh_lock since
2122 * sh4_update acquires it. Since there is
2123 * only one recovery thread there is no
2124 * race.
2125 */
2128 }
2129 }
2132 }
2136 /*
2137 * If the server wanted an OPEN_CONFIRM but that fails, just start
2138 * over. Presumably if there is a persistent error it will show up
2139 * when we resend the OPEN.
2140 */
2154 }
2155 }
2160 /*
2161 * Need to reset this bitfield for the possible case where we were
2162 * going to OTW CLOSE the file, got a non-recoverable error, and before
2163 * we could retry the CLOSE, OPENed the file again.
2164 */
2174 /* accept delegation, if any */
2190 kill_file:
2192 failed_reopen:
2199 bailout:
2203 }
2208 }
2210 /* for . and .. OPENs */
2211 /* ARGSUSED */
2212 static int
2214 {
2216 nfs4_ga_res_t gar;
2220 /*
2221 * If close-to-open consistency checking is turned off or
2222 * if there is no cached data, we can avoid
2223 * the over the wire getattr. Otherwise, force a
2224 * call to the server to get fresh attributes and to
2225 * check caches. This is required for close-to-open
2226 * consistency.
2227 */
2234 }
2236 /*
2237 * CLOSE a file
2238 */
2239 /* ARGSUSED */
2240 static int
2243 {
2250 /*
2251 * Remove client state for this (lockowner, file) pair.
2252 * Issue otw v4 call to have the server do the same.
2253 */
2257 /*
2258 * zone_enter(2) prevents processes from changing zones with NFS files
2259 * open; if we happen to get here from the wrong zone we can't do
2260 * anything over the wire.
2261 */
2263 /*
2264 * We could attempt to clean up locks, except we're sure
2265 * that the current process didn't acquire any locks on
2266 * the file: any attempt to lock a file belong to another zone
2267 * will fail, and one can't lock an NFS file and then change
2268 * zones, as that fails too.
2269 *
2270 * Returning an error here is the sane thing to do. A
2271 * subsequent call to VN_RELE() which translates to a
2272 * nfs4_inactive() will clean up state: if the zone of the
2273 * vnode's origin is still alive and kicking, the inactive
2274 * thread will handle the request (from the correct zone), and
2275 * everything (minus the OTW close call) should be OK. If the
2276 * zone is going away nfs4_async_inactive() will throw away
2277 * delegations, open streams and cached pages inline.
2278 */
2280 }
2282 /*
2283 * If we are using local locking for this filesystem, then
2284 * release all of the SYSV style record locks. Otherwise,
2285 * we are doing network locking and we need to release all
2286 * of the network locks. All of the locks held by this
2287 * process on this file are released no matter what the
2288 * incoming reference count is.
2289 */
2307 }
2309 }
2314 /*
2315 * If the file has been `unlinked', then purge the
2316 * DNLC so that this vnode will get reycled quicker
2317 * and the .nfs* file on the server will get removed.
2318 */
2322 /*
2323 * If the file was open for write and there are pages,
2324 * do a synchronous flush and commit of all of the
2325 * dirty and uncommitted pages.
2326 */
2336 /*
2337 * If this file type is one for which no explicit 'open' was
2338 * done, then bail now (ie. no need for protocol 'close'). If
2339 * there was an error w/the vm subsystem, return _that_ error,
2340 * otherwise, return any errors that may've been reported via
2341 * the rnode.
2342 */
2346 /*
2347 * The sync putpage commit may have failed above, but since
2348 * we're working w/a regular file, we need to do the protocol
2349 * 'close' (nfs4close_one will figure out if an otw close is
2350 * needed or not). Report any errors _after_ doing the protocol
2351 * 'close'.
2352 */
2356 /*
2357 * Error reporting prio (Hi -> Lo)
2358 *
2359 * i) nfs4_putpage_commit (error)
2360 * ii) rnode's (r_error)
2361 * iii) nfs4close_one (n4error)
2362 */
2364 }
2366 /*
2367 * Initialize *lost_rqstp.
2368 */
2370 static void
2374 {
2379 }
2385 /*
2386 * The vp is held and rele'd via the recovery code.
2387 * See nfs4_save_lost_rqst.
2388 */
2400 }
2402 /*
2403 * Assumes you already have the open seqid sync grabbed as well as the
2404 * 'os_sync_lock'. Note: this will release the open seqid sync and
2405 * 'os_sync_lock' if client recovery starts. Calling functions have to
2406 * be prepared to handle this.
2407 *
2408 * 'recov' is returned as 1 if the CLOSE operation detected client recovery
2409 * was needed and was started, and that the calling function should retry
2410 * this function; otherwise it is returned as 0.
2411 *
2412 * Errors are returned via the nfs4_error_t parameter.
2413 */
2414 static void
2418 {
2419 COMPOUND4args_clnt args;
2420 COMPOUND4res_clnt res;
2426 seqid4 seqid;
2429 nfs4_lost_rqst_t lost_rqst;
2430 hrtime_t t;
2438 /* Only set this to 1 if recovery is started */
2441 /* do the OTW call to close the file */
2447 else
2457 /* putfh target fh */
2483 }
2487 /*
2488 * if there was an error and no recovery is to be done
2489 * then then set up the file to flush its cache if
2490 * needed for the next caller.
2491 */
2497 }
2500 bool_t abort;
2512 "nfs4close_otw: initiating recovery. error %d "
2515 /*
2516 * Drop the 'os_sync_lock' here so we don't hit
2517 * a potential recursive mutex_enter via an
2518 * 'open_stream_hold()'.
2519 */
2527 /* drop open seq sync, and let the calling function regrab it */
2533 /*
2534 * For signals, the caller wants to quit, so don't say to
2535 * retry. For forced unmount, if it's a user thread, it
2536 * wants to quit. If it's a recovery thread, the retry
2537 * will happen higher-up on the call stack. Either way,
2538 * don't say to retry.
2539 */
2545 else
2551 }
2556 }
2566 /*
2567 * This removes the reference obtained at OPEN; ie, when the
2568 * open stream structure was created.
2569 *
2570 * We don't have to worry about calling 'open_stream_rele'
2571 * since we our currently holding a reference to the open
2572 * stream which means the count cannot go to 0 with this
2573 * decrement.
2574 */
2579 /*
2580 * Avoid a deadlock with the r_serial thread waiting for
2581 * os_sync_lock in nfs4_get_otw_cred_by_osp() which might be
2582 * held by us. We will wait in nfs4_attr_cache() for the
2583 * completion of the r_serial thread.
2584 */
2591 }
2597 }
2599 /* ARGSUSED */
2600 static int
2603 {
2605 uoff_t off;
2606 offset_t diff;
2607 uint_t on;
2608 uint_t n;
2609 caddr_t base;
2610 uint_t flags;
2638 else
2644 /*
2645 * Bypass VM if caching has been disabled (e.g., locking) or if
2646 * using client-side direct I/O and the file is not mmap'd and
2647 * there are no cached pages.
2648 */
2656 }
2673 }
2674 }
2683 /*
2684 * Copy data.
2685 */
2690 S_READ);
2693 }
2696 /*
2697 * If read a whole block or read to eof,
2698 * won't need this buffer again soon.
2699 */
2704 else
2711 }
2717 }
2718 }
2722 }
2724 /* ARGSUSED */
2725 static int
2728 {
2731 uoff_t off;
2732 caddr_t base;
2733 uint_t flags;
2739 uoff_t offset;
2741 uint_t bsize;
2762 else
2771 /*
2772 * Must serialize if appending.
2773 */
2779 }
2786 }
2796 /*
2797 * Check to make sure that the process will not exceed
2798 * its limit on file size. It is okay to write up to
2799 * the limit, but not beyond. Thus, the write which
2800 * reaches the limit will be short and the next write
2801 * will return an error.
2802 */
2816 }
2817 }
2819 /* update the change attribute, if we have a write delegation */
2830 /*
2831 * Bypass VM if caching has been disabled (e.g., locking) or if
2832 * using client-side direct I/O and the file is not mmap'd and
2833 * there are no cached pages.
2834 */
2840 uoff_t org_offset;
2841 stable_how4 stab_comm;
2842 nfs4_fwrite:
2847 /*
2848 * A close may have cleared r_error, if so,
2849 * propagate ESTALE error return properly
2850 */
2854 }
2861 else
2876 }
2877 }
2881 }
2895 /*
2896 * A close may have cleared r_error, if so,
2897 * propagate ESTALE error return properly
2898 */
2902 }
2904 /*
2905 * Don't create dirty pages faster than they
2906 * can be cleaned so that the system doesn't
2907 * get imbalanced. If the async queue is
2908 * maxed out, then wait for it to drain before
2909 * creating more dirty pages. Also, wait for
2910 * any threads doing pagewalks in the vop_getattr
2911 * entry points so that they don't block for
2912 * long periods.
2913 */
2929 }
2934 }
2937 /*
2938 * Touch the page and fault it in if it is not in core
2939 * before segmap_getmapflt or vpm_data_copy can lock it.
2940 * This is to avoid the deadlock if the buffer is mapped
2941 * to the same file through mmap which we want to write.
2942 */
2946 /*
2947 * It will use kpm mappings, so no need to
2948 * pass an address.
2949 */
2967 pagecreate);
2973 }
2974 }
2981 /*
2982 * Have written a whole block.
2983 * Start an asynchronous write
2984 * and mark the buffer to
2985 * indicate that it won't be
2986 * needed again soon.
2987 */
2995 }
3000 }
3006 }
3007 /*
3008 * In the event that we got an access error while
3009 * faulting in a page for a write-only file just
3010 * force a write.
3011 */
3014 }
3017 bottom:
3028 }
3030 }
3035 }
3037 /*
3038 * Flags are composed of {B_ASYNC, B_INVAL, B_FREE, B_DONTNEED}
3039 */
3040 static int
3043 {
3047 uchar_t fsdata;
3048 stable_how4 stab_comm;
3054 /*
3055 * pageio_setup should have set b_addr to 0. This
3056 * is correct since we want to do I/O on a page
3057 * boundary. bp_mapin will use this addr to calculate
3058 * an offset, and then set b_addr to the kernel virtual
3059 * address it allocated for us.
3060 */
3073 else
3083 else
3092 }
3094 /*
3095 */
3096 static int
3098 {
3112 /* returns with 'os_sync_lock' held */
3117 }
3124 }
3126 /*
3127 * Determine whether a reopen is needed. If this
3128 * is a delegation open stream, then the os_delegation bit
3129 * should be set.
3130 */
3145 }
3147 }
3151 }
3153 /*
3154 * Write to file. Writes to remote server in largest size
3155 * chunks that the server can handle. Write is synchronous.
3156 */
3157 static int
3160 {
3162 COMPOUND4args_clnt args;
3163 COMPOUND4res_clnt res;
3169 stable_how4 stable;
3172 bool_t needrecov;
3173 nfs4_recov_state_t recov_state;
3174 nfs4_stateid_types_t sid_types;
3191 /* Is curthread the recovery thread? */
3196 recov_retry:
3206 }
3208 /* 0. putfh target fh */
3212 /* 1. write */
3224 }
3230 else
3239 }
3247 }
3251 }
3253 /*
3254 * Do handling of OLD_STATEID outside
3255 * of the normal recovery framework.
3256 *
3257 * If write receives a BAD stateid error while using a
3258 * delegation stateid, retry using the open stateid (if it
3259 * exists). If it doesn't have an open stateid, reopen the
3260 * file first, then retry.
3261 */
3282 }
3286 /* hold needed for nfs4delegreturn_thread */
3292 }
3295 bool_t abort;
3298 "nfs4write: client got error %d, res.status %d"
3307 }
3313 }
3322 }
3337 }
3344 "nfs4write: server %s did not commit "
3351 }
3352 }
3362 tsize;
3364 }
3371 }
3375 }
3386 needrecov);
3389 }
3391 /*
3392 * Read from a file. Reads data in largest chunks our interface can handle.
3393 */
3394 static int
3397 {
3399 COMPOUND4args_clnt args;
3400 COMPOUND4res_clnt res;
3407 bool_t is_eof;
3409 nfs4_recov_state_t recov_state;
3410 nfs4_stateid_types_t sid_types;
3429 recov_retry:
3435 /* putfh target fh */
3439 /* read */
3450 }
3461 else
3474 else
3479 #ifdef DEBUG
3483 }
3484 #endif
3490 }
3497 }
3499 /*
3500 * Do proper retry for OLD and BAD stateid errors outside
3501 * of the normal recovery framework. There are two differences
3502 * between async and sync reads. The first is that we allow
3503 * retry on BAD_STATEID for async reads, but not sync reads.
3504 * The second is that we mark the file dead for a failed
3505 * attempt with a special stateid for sync reads, but just
3506 * return EIO for async reads.
3507 *
3508 * If a sync read receives a BAD stateid error while using a
3509 * delegation stateid, retry using the open stateid (if it
3510 * exists). If it doesn't have an open stateid, reopen the
3511 * file first, then retry.
3512 */
3520 }
3542 }
3545 /* hold needed for nfs4delegreturn_thread */
3551 }
3553 bool_t abort;
3562 /*
3563 * Do not retry if we got OLD_STATEID using a special
3564 * stateid. This avoids looping with a broken server.
3565 */
3571 /*
3572 * Need to retry all possible stateids in
3573 * case the recovery error wasn't stateid
3574 * related or the stateids have become
3575 * stale (server reboot).
3576 */
3580 }
3585 }
3587 }
3595 }
3607 }
3619 }
3621 /* ARGSUSED */
3622 static int
3625 {
3633 }
3634 }
3636 /* ARGSUSED */
3637 int
3640 {
3646 /*
3647 * If it has been specified that the return value will
3648 * just be used as a hint, and we are only being asked
3649 * for size, fsid or rdevid, then return the client's
3650 * notion of these values without checking to make sure
3651 * that the attribute cache is up to date.
3652 * The whole point is to avoid an over the wire GETATTR
3653 * call.
3654 */
3666 }
3667 }
3669 /*
3670 * Only need to flush pages if asking for the mtime
3671 * and if there any dirty pages or any outstanding
3672 * asynchronous (write) requests for this file.
3673 */
3685 error =
3693 }
3697 }
3700 }
3701 }
3702 }
3704 }
3706 int
3708 {
3709 /*
3710 * If these are the only two bits cleared
3711 * on the server then return 0 (OK) else
3712 * return 1 (BAD).
3713 */
3717 else
3719 }
3721 /*ARGSUSED4*/
3722 static int
3725 {
3734 /*
3735 * Don't call secpolicy_vnode_setattr, the client cannot
3736 * use its cached attributes to make security decisions
3737 * as the server may be faking mode bits or mapping uid/gid.
3738 * Always just let the server to the checking.
3739 * If we provide the ability to remove basic priviledges
3740 * to setattr (e.g. basic without chmod) then we will
3741 * need to add a check here before calling the server.
3742 */
3749 }
3751 /*
3752 * To replace the "guarded" version 3 setattr, we use two types of compound
3753 * setattr requests:
3754 * 1. The "normal" setattr, used when the size of the file isn't being
3755 * changed - { Putfh <fh>; Setattr; Getattr }/
3756 * 2. If the size is changed, precede Setattr with: Getattr; Verify
3757 * with only ctime as the argument. If the server ctime differs from
3758 * what is cached on the client, the verify will fail, but we would
3759 * already have the ctime from the preceding getattr, so just set it
3760 * and retry. Thus the compound here is - { Putfh <fh>; Getattr; Verify;
3761 * Setattr; Getattr }.
3762 *
3763 * The vsecattr_t * input parameter will be non-NULL if ACLs are being set in
3764 * this setattr and NULL if they are not.
3765 */
3766 static int
3769 {
3770 COMPOUND4args_clnt args;
3778 vattr_t va;
3782 mode_t omode;
3784 timestruc_t ctime;
3786 nfs4_recov_state_t recov_state;
3787 nfs4_stateid_types_t sid_types;
3788 stateid4 stateid;
3789 hrtime_t t;
3792 bitmap4 supp_attrs;
3798 /*
3799 * Only need to flush pages if there are any pages and
3800 * if the file is marked as dirty in some fashion. The
3801 * file must be flushed so that we can accurately
3802 * determine the size of the file and the cached data
3803 * after the SETATTR returns. A file is considered to
3804 * be dirty if it is either marked with R4DIRTY, has
3805 * outstanding i/o's active, or is mmap'd. In this
3806 * last case, we can't tell whether there are dirty
3807 * pages, so we flush just to be sure.
3808 */
3820 }
3821 }
3824 /*
3825 * Verification setattr compound for non-deleg AT_SIZE:
3826 * { Putfh; Getattr; Verify; Setattr; Getattr }
3827 * Set ctime local here (outside the do_again label)
3828 * so that subsequent retries (after failed VERIFY)
3829 * will use ctime from GETATTR results (from failed
3830 * verify compound) as VERIFY arg.
3831 * If file has delegation, then VERIFY(time_metadata)
3832 * is of little added value, so don't bother.
3833 */
3839 }
3841 }
3847 do_again:
3848 recov_retry:
3859 /* putfh target fh */
3864 /*
3865 * We only care about the ctime, but need to get mtime
3866 * and size for proper cache update.
3867 */
3868 /* getattr */
3873 /* verify - set later in loop */
3875 }
3877 /* setattr */
3887 /* req time field(s) overflow - return immediately */
3892 }
3895 /* getattr */
3898 /*
3899 * If we are setting the ACL (indicated only by vsap != NULL), request
3900 * the ACL in this getattr. The ACL returned from this getattr will be
3901 * used in updating the ACL cache.
3902 */
3905 FATTR4_ACL_MASK;
3908 /*
3909 * setattr iterates if the object size is set and the cached ctime
3910 * does not match the file ctime. In that case, verify the ctime first.
3911 */
3915 /*
3916 * Verify that the ctime match before doing setattr.
3917 */
3927 /* req time field(s) overflow - return */
3929 needrecov);
3931 }
3932 }
3940 /*
3941 * Purge the access cache and ACL cache if changing either the
3942 * owner of the file, the group owner, or the mode. These may
3943 * change the access permissions of the file, so purge old
3944 * information and start over again.
3945 */
3955 }
3956 }
3958 /*
3959 * If res.array_len == numops, then everything succeeded,
3960 * except for possibly the final getattr. If only the
3961 * last getattr failed, give up, and don't try recovery.
3962 */
3965 needrecov);
3969 }
3971 /*
3972 * if either rpc call failed or completely succeeded - done
3973 */
3979 needrecov);
3981 }
3982 }
3984 /*
3985 * Do proper retry for OLD_STATEID outside of the normal
3986 * recovery framework.
3987 */
3992 needrecov);
3999 }
4002 }
4005 bool_t abort;
4011 needrecov);
4012 /*
4013 * Do not retry if we failed with OLD_STATEID using
4014 * a special stateid. This is done to avoid looping
4015 * with a broken server.
4016 */
4024 OP_SETATTR);
4028 }
4034 }
4036 /*
4037 * Need to retry all possible stateids in
4038 * case the recovery error wasn't stateid
4039 * related or the stateids have become
4040 * stale (server reboot).
4041 */
4044 }
4046 }
4048 /*
4049 * Need to call nfs4_end_op before nfs4getattr to
4050 * avoid potential nfs4_start_op deadlock. See RFE
4051 * 4777612. Calls to nfs4_invalidate_pages() and
4052 * nfs4_purge_stale_fh() might also generate over the
4053 * wire calls which my cause nfs4_start_op() deadlock.
4054 */
4057 /*
4058 * Check to update lease.
4059 */
4063 }
4065 /*
4066 * Check if verify failed to see if try again
4067 */
4069 /*
4070 * can't continue...
4071 */
4077 /*
4078 * When the verify request fails, the client ctime is
4079 * not in sync with the server. This is the same as
4080 * the version 3 "not synchronized" error, and we
4081 * handle it in a similar manner (XXX do we need to???).
4082 * Use the ctime returned in the first getattr for
4083 * the input to the next verify.
4084 * If we couldn't get the attributes, then we give up
4085 * because we can't complete the operation as required.
4086 */
4088 }
4093 /*
4094 * retry with a new verify value
4095 */
4099 }
4106 }
4109 }
4113 /*
4114 * If we are here, rfs4call has an irrecoverable error - return
4115 */
4121 }
4125 }
4129 /*
4130 * If changing the size of the file, invalidate
4131 * any local cached data which is no longer part
4132 * of the file. We also possibly invalidate the
4133 * last page in the file. We could use
4134 * pvn_vpzero(), but this would mark the page as
4135 * modified and require it to be written back to
4136 * the server for no particularly good reason.
4137 * This way, if we access it, then we bring it
4138 * back in. A read should be cheaper than a
4139 * write.
4140 */
4143 }
4145 /* either no error or one of the postop getattr failed */
4147 /*
4148 * XXX Perform a simplified version of wcc checking. Instead of
4149 * have another getattr to get pre-op, just purge cache if
4150 * any of the ops prior to and including the getattr failed.
4151 * If the getattr succeeded then update the attrcache accordingly.
4152 */
4156 /*
4157 * Last getattr
4158 */
4161 }
4162 /*
4163 * In certain cases, nfs4_update_attrcache() will purge the attrcache,
4164 * rather than filling it. See the function itself for details.
4165 */
4173 /*
4174 * The ACL was supposed to be set and to be
4175 * returned in the last getattr of this
4176 * compound, but for some reason the getattr
4177 * result doesn't contain the ACL. In this
4178 * case, purge the ACL cache.
4179 */
4187 }
4188 }
4189 }
4190 }
4193 /*
4194 * Set the size, rather than relying on getting it updated
4195 * via a GETATTR. With delegations the client tries to
4196 * suppress GETATTR calls.
4197 */
4201 }
4203 /*
4204 * Can free up request args and res
4205 */
4211 }
4214 /*
4215 * Some servers will change the mode to clear the setuid
4216 * and setgid bits when changing the uid or gid. The
4217 * client needs to compensate appropriately.
4218 */
4230 /*
4231 * We asked the mode to be changed and what
4232 * we just got from the server in getattr is
4233 * not what we wanted it to be, so set it now.
4234 */
4238 /*
4239 * We did not ask the mode to be changed,
4240 * Check to see that the server just cleared
4241 * I_SUID and I_GUID from it. If not then
4242 * set mode to omode with UID/GID cleared.
4243 */
4248 }
4249 }
4253 }
4254 }
4257 }
4259 /* ARGSUSED */
4260 static int
4262 {
4263 COMPOUND4args_clnt args;
4264 COMPOUND4res_clnt res;
4269 nfs4_access_type_t cacc;
4274 nfs4_recov_state_t recov_state;
4276 hrtime_t t;
4292 }
4296 else
4298 }
4304 }
4310 else
4312 ACCESS4_EXECUTE;
4317 /*
4318 * ncr and ncrfree both initially
4319 * point to the memory area returned
4320 * by crnetadjust();
4321 * ncrfree not NULL when exiting means
4322 * that we need to release it
4323 */
4327 tryagain:
4333 }
4335 /*
4336 * If the cred can be adjusted, try again
4337 * with the new cred.
4338 */
4343 }
4347 }
4349 recov_retry:
4350 /*
4351 * Don't take with r_statev4_lock here. r_deleg_type could
4352 * change as soon as lock is released. Since it is an int,
4353 * there is no atomicity issue.
4354 */
4368 }
4370 /* putfh target fh */
4374 /* access */
4378 /* getattr */
4383 }
4406 }
4407 }
4415 /*
4416 * This might generate over the wire calls throught
4417 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
4418 * here to avoid a deadlock.
4419 */
4422 }
4431 }
4435 /*
4436 * we just cached results with cred; if cred is the
4437 * adjusted credentials from crnetadjust, we do not want
4438 * to release them before exiting: hence setting ncrfree
4439 * to NULL
4440 */
4443 /* XXX check the supported bits too? */
4445 /*
4446 * The following code implements the semantic
4447 * that a setuid root program has *at least* the
4448 * permissions of the user that is running the
4449 * program. See rfs3call() for more portions
4450 * of the implementation of this functionality.
4451 */
4452 /* XXX-LP */
4458 }
4460 }
4461 }
4463 out:
4471 }
4473 /* ARGSUSED */
4474 static int
4476 {
4477 COMPOUND4args_clnt args;
4478 COMPOUND4res_clnt res;
4485 uint_t len;
4488 nfs4_recov_state_t recov_state;
4489 hrtime_t t;
4494 /*
4495 * Can't readlink anything other than a symbolic link.
4496 */
4511 }
4513 }
4517 recov_retry:
4525 }
4527 /* 0. putfh symlink fh */
4531 /* 1. readlink */
4534 /* 2. getattr */
4560 needrecov);
4562 }
4563 }
4570 /*
4571 * There is an path in the code below which calls
4572 * nfs4_purge_stale_fh(), which may generate otw calls through
4573 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
4574 * here to avoid nfs4_start_op() deadlock.
4575 */
4578 /*
4579 * either Putfh or Link failed
4580 */
4585 }
4590 /*
4591 * treat symlink names as data
4592 */
4596 /* len includes null byte, which we won't uiomove */
4608 }
4611 }
4612 }
4616 }
4621 /*
4622 * The over the wire error for attempting to readlink something
4623 * other than a symbolic link is ENXIO. However, we need to
4624 * return EINVAL instead of ENXIO, so we map it here.
4625 */
4627 }
4629 /*
4630 * Flush local dirty pages to stable storage on the server.
4631 *
4632 * If FNODSYNC is specified, then there is nothing to do because
4633 * metadata changes are not cached on the client before being
4634 * sent to the server.
4635 */
4636 /* ARGSUSED */
4637 static int
4639 {
4650 }
4652 /*
4653 * Weirdness: if the file was removed or the target of a rename
4654 * operation while it was open, it got renamed instead. Here we
4655 * remove the renamed file.
4656 */
4657 /* ARGSUSED */
4658 void
4660 {
4670 }
4672 /*
4673 * If this is coming from the wrong zone, we let someone in the right
4674 * zone take care of it asynchronously. We can get here due to
4675 * VN_RELE() being called from pageout() or fsflush(). This call may
4676 * potentially turn into an expensive no-op if, for instance, v_count
4677 * gets incremented in the meantime, but it's still correct.
4678 */
4682 }
4684 /*
4685 * Some of the cleanup steps might require over-the-wire
4686 * operations. Since fop_inactive can get called as a result of
4687 * other over-the-wire operations (e.g., an attribute cache update
4688 * can lead to a DNLC purge), doing those steps now would lead to a
4689 * nested call to the recovery framework, which can deadlock. So
4690 * do any over-the-wire cleanups asynchronously, in a separate
4691 * thread.
4692 */
4704 }
4713 }
4721 }
4727 }
4729 /*
4730 * nfs4_inactive_otw - nfs4_inactive, plus over-the-wire calls to free up
4731 * various bits of state. The caller must not refer to vp after this call.
4732 */
4734 void
4736 {
4738 nfs4_recov_state_t recov_state;
4743 COMPOUND4args_clnt args;
4747 #ifdef DEBUG
4749 #endif
4754 #ifdef DEBUG
4759 #endif
4766 /* Check to see if recovery failed */
4776 }
4781 }
4782 }
4783 }
4785 redo:
4789 }
4791 /*
4792 * Save the vnode pointer for the directory where the
4793 * unlinked-open file got renamed, then set it to NULL
4794 * to prevent another thread from getting here before
4795 * we're done with the remove. While we have the
4796 * statelock, make local copies of the pertinent rnode
4797 * fields. If we weren't to do this in an atomic way, the
4798 * the unl* fields could become inconsistent with respect
4799 * to each other due to a race condition between this
4800 * code and nfs_remove(). See bug report 1034328.
4801 */
4807 }
4817 /*
4818 * If there are any dirty pages left, then flush
4819 * them. This is unfortunate because they just
4820 * may get thrown away during the remove operation,
4821 * but we have to do this for correctness.
4822 */
4832 }
4833 }
4837 recov_retry_remove:
4838 /*
4839 * Do the remove operation on the renamed file
4840 */
4843 /*
4844 * Remove ops: putfh dir; remove
4845 */
4854 /*
4855 * Try again; this time around r_unldvp will be NULL, so we'll
4856 * just call rp4_addfree() and return.
4857 */
4859 }
4861 /* putfh directory */
4865 /* remove */
4873 /*
4874 * Can't do this yet. We may be being called from
4875 * dnlc_purge_XXX while that routine is holding a
4876 * mutex lock to the nc_rele list. The calls to
4877 * nfs3_cache_wcc_data may result in calls to
4878 * dnlc_purge_XXX. This will result in a deadlock.
4879 */
4887 /*
4888 * This code is inactive right now
4889 * but if made active there should
4890 * be a nfs4_end_op() call before
4891 * nfs4_purge_stale_fh to avoid start_op()
4892 * deadlock. See BugId: 4948726
4893 */
4901 /*
4902 * Update directory cache attribute,
4903 * readdir and dnlc caches.
4904 */
4906 }
4907 #else
4911 #endif
4921 }
4922 }
4925 /*
4926 * Release stuff held for the remove
4927 */
4935 }
4937 /*
4938 * Remote file system operations having to do with directory manipulation.
4939 */
4940 /* ARGSUSED3 */
4941 int
4945 {
4953 /*
4954 * if LOOKUP_XATTR, must replace dvp (object) with
4955 * object's attrdir before continuing with lookup
4956 */
4964 /*
4965 * If lookup is for "", just return dvp now. The attrdir
4966 * has already been activated (from nfs4lookup_xattr), and
4967 * the caller will RELE the original dvp -- not
4968 * the attrdir. So, set vpp and return.
4969 * Currently, when the LOOKUP_XATTR flag is
4970 * passed to fop_lookup, the name is always empty, and
4971 * shortcircuiting here avoids 3 unneeded lock/unlock
4972 * pairs.
4973 *
4974 * If a non-empty name was provided, then it is the
4975 * attribute name, and it will be looked up below.
4976 */
4980 }
4982 /*
4983 * The vfs layer never sends a name when asking for the
4984 * attrdir, so we should never get here (unless of course
4985 * name is passed at some time in future -- at which time
4986 * we'll blow up here).
4987 */
4989 }
4998 /*
4999 * If vnode is a device, create special vnode.
5000 */
5005 }
5008 }
5010 /* ARGSUSED */
5011 static int
5013 {
5029 /*
5030 * If the server doesn't support xattrs just return EINVAL
5031 */
5036 }
5038 /*
5039 * If there is a cached xattr directory entry,
5040 * use it as long as the attributes are valid. If the
5041 * attributes are not valid, take the simple approach and
5042 * free the cached value and re-fetch a new value.
5043 *
5044 * We don't negative entry cache for now, if we did we
5045 * would need to check if the file has changed on every
5046 * lookup. But xattrs don't exist very often and failing
5047 * an openattr is not much more expensive than and NVERIFY or GETATTR
5048 * so do an openattr over the wire for now.
5049 */
5057 }
5060 }
5068 }
5070 static int
5072 {
5078 /*
5079 * If lookup is for "", just return dvp. Don't need
5080 * to send it over the wire, look it up in the dnlc,
5081 * or perform any access checks.
5082 */
5087 }
5089 /*
5090 * Can't do lookups in non-directories.
5091 */
5095 /*
5096 * If lookup is for ".", just return dvp. Don't need
5097 * to send it over the wire or look it up in the dnlc,
5098 * just need to check access.
5099 */
5107 }
5114 }
5117 /*
5118 * Lookup this name in the DNLC. If there is no entry
5119 * lookup over the wire.
5120 */
5124 /*
5125 * We need to go over the wire to lookup the name.
5126 */
5128 }
5130 /*
5131 * We hit on the dnlc
5132 */
5135 /*
5136 * But our attrs may not be valid.
5137 */
5144 }
5146 /*
5147 * If after the purge completes, check to make sure
5148 * our attrs are still valid.
5149 */
5151 /*
5152 * If we waited for a purge we may have
5153 * lost our vnode so look it up again.
5154 */
5161 /*
5162 * The access cache should almost always hit
5163 */
5170 }
5175 }
5177 }
5178 }
5179 }
5183 /*
5184 * We may have gotten here we have one of the following cases:
5185 * 1) vpp != DNLC_NO_VNODE, our attrs have timed out so we
5186 * need to validate them.
5187 * 2) vpp == DNLC_NO_VNODE, a negative entry that we always
5188 * must validate.
5189 *
5190 * Go to the server and check if the directory has changed, if
5191 * it hasn't we are done and can use the dnlc entry.
5192 */
5194 }
5196 /*
5197 * Go to the server and check if the directory has changed, if
5198 * it hasn't we are done and can use the dnlc entry. If it
5199 * has changed we get a new copy of its attributes and check
5200 * the access for VEXEC, then relookup the filename and
5201 * get its filehandle and attributes.
5202 *
5203 * PUTFH dfh NVERIFY GETATTR ACCESS LOOKUP GETFH GETATTR
5204 * if the NVERIFY failed we must
5205 * purge the caches
5206 * cache new attributes (will set r_time_attr_inval)
5207 * cache new access
5208 * recheck VEXEC access
5209 * add name to dnlc, possibly negative
5210 * if LOOKUP succeeded
5211 * cache new attributes
5212 * else
5213 * set a new r_time_attr_inval for dvp
5214 * check to make sure we have access
5215 *
5216 * The vpp returned is the vnode passed in if the directory is valid,
5217 * a new vnode if successful lookup, or NULL on error.
5218 */
5219 static int
5221 {
5222 COMPOUND4args_clnt args;
5223 COMPOUND4res_clnt res;
5225 fattr4_change dchange;
5231 nfs4_recov_state_t recov_state;
5232 hrtime_t t;
5237 nfs4_access_type_t cacc;
5254 /*
5255 * If dvp were a stub, it should have triggered and caused
5256 * a mount for us to get this far.
5257 */
5262 }
5270 /* Save the original mount point security information */
5273 recov_retry:
5281 }
5285 /* PUTFH dfh NVERIFY GETATTR ACCESS LOOKUP GETFH GETATTR */
5289 /* 0. putfh file */
5293 /* 1. nverify the change info */
5302 /* 2. getattr directory */
5307 /* 3. access directory */
5312 /* 4. lookup name */
5318 }
5320 /* 5. resulting file handle */
5323 /* 6. resulting file attributes */
5342 }
5345 /*
5346 * For WRONGSEC of a non-dotdot case, send secinfo directly
5347 * from this thread, do not go thru the recovery thread since
5348 * we need the nm information.
5349 *
5350 * Not doing dotdot case because there is no specification
5351 * for (PUTFH, SECINFO "..") yet.
5352 */
5357 else
5368 }
5378 }
5379 }
5384 /*
5385 * If e.error isn't set, then reply has no ops (or we couldn't
5386 * be here). The only legal way to reply without an op array
5387 * is via NFS4ERR_MINOR_VERS_MISMATCH. An ops array should
5388 * be in the reply for all other status values.
5389 *
5390 * For valid replies without an ops array, return ENOTSUP
5391 * (geterrno4 xlation of VERS_MISMATCH). For illegal replies,
5392 * return EIO -- don't trust status.
5393 */
5402 }
5407 /*
5408 * The NVERIFY "failed" so the directory has changed
5409 * First make sure PUTFH succeeded and NVERIFY "failed"
5410 * cleanly.
5411 */
5418 }
5420 /*
5421 * We know the NVERIFY "failed" so we must:
5422 * purge the caches (access and indirectly dnlc if needed)
5423 */
5431 }
5433 /*
5434 * Install new cached attributes for the directory
5435 */
5446 }
5448 /*
5449 * Now we know the directory is valid,
5450 * cache new directory access
5451 */
5456 /*
5457 * recheck VEXEC access
5458 */
5461 /*
5462 * Directory permissions might have been revoked
5463 */
5469 }
5471 /*
5472 * Somehow we must not have asked for enough
5473 * so try a singleton ACCESS, should never happen.
5474 */
5480 }
5481 }
5485 /*
5486 * The lookup failed, probably no entry
5487 */
5491 /*
5492 * Might be some other error, so remove
5493 * the dnlc entry to make sure we start all
5494 * over again, next time.
5495 */
5497 }
5501 }
5504 /*
5505 * The file exists but we can't get its fh for
5506 * some unknown reason. Remove it from the dnlc
5507 * and error out to be safe.
5508 */
5513 }
5516 /*
5517 * The file exists but a bogus fh
5518 * some unknown reason. Remove it from the dnlc
5519 * and error out to be safe.
5520 */
5526 }
5532 /*
5533 * Make the new rnode
5534 */
5542 }
5543 /*
5544 * XXX if nfs4_make_dotdot uses an existing rnode
5545 * XXX it doesn't update the attributes.
5546 * XXX for now just save them again to save an OTW
5547 */
5552 /*
5553 * If v_type == VNON, then garp was NULL because
5554 * the last op in the compound failed and makenfs4node
5555 * could not find the vnode for sfhp. It created
5556 * a new vnode, so we have nothing to purge here.
5557 */
5559 vattr_t vattr;
5562 /*
5563 * N.B. We've already called nfs4_end_fop above.
5564 */
5572 }
5574 }
5575 }
5589 hrtime_t now;
5594 /*
5595 * Because the NVERIFY "succeeded" we know that the
5596 * directory attributes are still valid
5597 * so update r_time_attr_inval
5598 */
5607 }
5612 /*
5613 * Even though we have a valid directory attr cache
5614 * and dnlc entry, we may not have access.
5615 * This should almost always hit the cache.
5616 */
5621 }
5627 }
5628 }
5630 exit:
5635 }
5637 /*
5638 * We need to go over the wire to lookup the name, but
5639 * while we are there verify the directory has not
5640 * changed but if it has, get new attributes and check access
5641 *
5642 * PUTFH dfh SAVEFH LOOKUP nm GETFH GETATTR RESTOREFH
5643 * NVERIFY GETATTR ACCESS
5644 *
5645 * With the results:
5646 * if the NVERIFY failed we must purge the caches, add new attributes,
5647 * and cache new access.
5648 * set a new r_time_attr_inval
5649 * add name to dnlc, possibly negative
5650 * if LOOKUP succeeded
5651 * cache new attributes
5652 */
5653 static int
5655 {
5656 COMPOUND4args_clnt args;
5657 COMPOUND4res_clnt res;
5659 fattr4_change dchange;
5666 nfs4_recov_state_t recov_state;
5667 hrtime_t t;
5672 nfs4_access_type_t cacc;
5688 /*
5689 * If dvp were a stub, it should have triggered and caused
5690 * a mount for us to get this far.
5691 */
5696 }
5704 /* Save the original mount point security information */
5707 recov_retry:
5713 }
5717 /* PUTFH SAVEFH LOOKUP GETFH GETATTR RESTOREFH NVERIFY GETATTR ACCESS */
5721 /* 0. putfh file */
5725 /* 1. savefh for the nverify */
5728 /* 2. lookup name */
5734 }
5736 /* 3. resulting file handle */
5739 /* 4. resulting file attributes */
5744 /* 5. restorefh back the directory for the nverify */
5747 /* 6. nverify the change info */
5756 /* 7. getattr directory */
5761 /* 8. access directory */
5780 }
5783 /*
5784 * For WRONGSEC of a non-dotdot case, send secinfo directly
5785 * from this thread, do not go thru the recovery thread since
5786 * we need the nm information.
5787 *
5788 * Not doing dotdot case because there is no specification
5789 * for (PUTFH, SECINFO "..") yet.
5790 */
5795 else
5804 }
5814 }
5815 }
5820 /*
5821 * If e.error isn't set, then reply has no ops (or we couldn't
5822 * be here). The only legal way to reply without an op array
5823 * is via NFS4ERR_MINOR_VERS_MISMATCH. An ops array should
5824 * be in the reply for all other status values.
5825 *
5826 * For valid replies without an ops array, return ENOTSUP
5827 * (geterrno4 xlation of VERS_MISMATCH). For illegal replies,
5828 * return EIO -- don't trust status.
5829 */
5837 }
5841 /*
5842 * The PUTFH and SAVEFH may have failed.
5843 */
5848 }
5850 /*
5851 * Check if the file exists, if it does delay entering
5852 * into the dnlc until after we update the directory
5853 * attributes so we don't cause it to get purged immediately.
5854 */
5856 /*
5857 * The lookup failed, probably no entry
5858 */
5862 }
5865 /*
5866 * The file exists but we can't get its fh for
5867 * some unknown reason. Error out to be safe.
5868 */
5870 }
5874 /*
5875 * The file exists but a bogus fh
5876 * some unknown reason. Error out to be safe.
5877 */
5880 }
5886 }
5889 /*
5890 * The RESTOREFH may have failed
5891 */
5896 }
5899 /*
5900 * First make sure the NVERIFY failed as we expected,
5901 * if it didn't then be conservative and error out
5902 * as we can't trust the directory.
5903 */
5908 }
5910 /*
5911 * We know the NVERIFY "failed" so the directory has changed,
5912 * so we must:
5913 * purge the caches (access and indirectly dnlc if needed)
5914 */
5920 }
5930 }
5932 /*
5933 * Now we know the directory is valid,
5934 * cache new directory access
5935 */
5940 /*
5941 * recheck VEXEC access
5942 */
5945 /*
5946 * Directory permissions might have been revoked
5947 */
5952 }
5954 /*
5955 * Somehow we must not have asked for enough
5956 * so try a singleton ACCESS should never happen
5957 */
5962 }
5963 }
5967 hrtime_t now;
5972 /*
5973 * Because the NVERIFY "succeeded" we know that the
5974 * directory attributes are still valid
5975 * so update r_time_attr_inval
5976 */
5985 }
5989 /*
5990 * Even though we have a valid directory attr cache,
5991 * we may not have access.
5992 * This should almost always hit the cache.
5993 */
5998 }
5999 }
6001 /*
6002 * Now we have successfully completed the lookup, if the
6003 * directory has changed we now have the valid attributes.
6004 * We also know we have directory access.
6005 * Create the new rnode and insert it in the dnlc.
6006 */
6012 }
6013 /*
6014 * XXX if nfs4_make_dotdot uses an existing rnode
6015 * XXX it doesn't update the attributes.
6016 * XXX for now just save them again to save an OTW
6017 */
6022 }
6035 exit:
6040 }
6042 #ifdef DEBUG
6043 void
6045 {
6087 }
6088 }
6089 }
6090 #endif
6092 /*
6093 * nfs4lookup_setup - constructs a multi-lookup compound request.
6094 *
6095 * Given the path "nm1/nm2/.../nmn", the following compound requests
6096 * may be created:
6097 *
6098 * Note: Getfh is not be needed because filehandle attr is mandatory, but it
6099 * is faster, for now.
6100 *
6101 * l4_getattrs indicates the type of compound requested.
6102 *
6103 * LKP4_NO_ATTRIBUTE - no attributes (used by secinfo):
6104 *
6105 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Lookup {nmn} }
6106 *
6107 * total number of ops is n + 1.
6108 *
6109 * LKP4_LAST_NAMED_ATTR - multi-component path for a named
6110 * attribute: create lookups plus one OPENATTR/GETFH/GETATTR
6111 * before the last component, and only get attributes
6112 * for the last component. Note that the second-to-last
6113 * pathname component is XATTR_RPATH, which does NOT go
6114 * over-the-wire as a lookup.
6115 *
6116 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Lookup {nmn-2};
6117 * Openattr; Getfh; Getattr; Lookup {nmn}; Getfh; Getattr }
6118 *
6119 * and total number of ops is n + 5.
6120 *
6121 * LKP4_LAST_ATTRDIR - multi-component path for the hidden named
6122 * attribute directory: create lookups plus an OPENATTR
6123 * replacing the last lookup. Note that the last pathname
6124 * component is XATTR_RPATH, which does NOT go over-the-wire
6125 * as a lookup.
6126 *
6127 * compound { Put*fh; Lookup {nm1}; Lookup {nm2}; ... Getfh; Getattr;
6128 * Openattr; Getfh; Getattr }
6129 *
6130 * and total number of ops is n + 5.
6131 *
6132 * LKP4_ALL_ATTRIBUTES - create lookups and get attributes for intermediate
6133 * nodes too.
6134 *
6135 * compound { Put*fh; Lookup {nm1}; Getfh; Getattr;
6136 * Lookup {nm2}; ... Lookup {nmn}; Getfh; Getattr }
6137 *
6138 * and total number of ops is 3*n + 1.
6139 *
6140 * All cases: returns the index in the arg array of the final LOOKUP op, or
6141 * -1 if no LOOKUPs were used.
6142 */
6143 int
6145 {
6155 /* set lookuparg response result to 0 */
6158 /* skip leading "/" or "." e.g. ".//./" if there is */
6163 /* ".." is counted as 1 component */
6166 }
6168 /*
6169 * Find n = number of components - nm must be null terminated
6170 * Skip "." components.
6171 */
6178 n++;
6179 }
6180 else
6183 /*
6184 * nga is number of components that need Getfh+Getattr
6185 */
6192 /*
6193 * Always have at least 1 getfh, getattr pair
6194 */
6196 nga++;
6202 }
6204 /*
6205 * If change to use the filehandle attr instead of getfh
6206 * the following line can be deleted.
6207 */
6210 /*
6211 * calculate number of ops in request as
6212 * header + trailer + lookups + getattrs
6213 */
6223 /*
6224 * loop and create a lookup op and possibly getattr/getfh for
6225 * each component. Skip "." components.
6226 */
6228 /*
6229 * Set up a pathname struct for each component if needed
6230 */
6232 s++;
6237 ;
6244 }
6247 /* getfh XXX may not be needed in future */
6249 argop++;
6250 argcnt++;
6252 /* getattr */
6258 argop++;
6259 argcnt++;
6261 /* openattr */
6265 /* openattr */
6267 argop++;
6268 argcnt++;
6270 /* getfh XXX may not be needed in future */
6272 argop++;
6273 argcnt++;
6275 /* getattr */
6281 argop++;
6282 argcnt++;
6286 /* lookupp */
6289 /* lookup */
6293 }
6295 argop++;
6296 argcnt++;
6301 /* getfh XXX may not be needed in future */
6303 argop++;
6304 argcnt++;
6306 /* getattr */
6312 argop++;
6313 argcnt++;
6314 }
6315 }
6320 /* stick in a post-lookup getfh */
6322 argcnt++;
6323 argop++;
6324 }
6325 /* post-lookup getattr */
6330 argcnt++;
6331 }
6336 #ifdef DEBUG
6339 #endif
6342 }
6344 static int
6346 {
6347 COMPOUND4args_clnt args;
6348 COMPOUND4res_clnt res;
6353 hrtime_t t;
6354 nfs4_error_t e;
6360 nfs4_recov_state_t recov_state;
6368 recov_retry:
6369 /* COMPOUND: putfh, openattr, getfh, getattr */
6380 /* putfh */
6384 /* openattr */
6388 /* getfh */
6391 /* getattr */
6406 bool_t abort;
6418 }
6422 }
6427 }
6430 /*
6431 * If OTW errro is NOTSUPP, then it should be
6432 * translated to EINVAL. All Solaris file system
6433 * implementations return EINVAL to the syscall layer
6434 * when the attrdir cannot be created due to an
6435 * implementation restriction or noxattr mount option.
6436 */
6448 }
6453 needrecov);
6455 }
6456 }
6471 }
6494 /*
6495 * Invalidate pathconf4 cache because r_xattr_dir is no longer
6496 * NULL. xattrs could be created at any time, and we have no
6497 * way to update pc4_xattr_exists in the base object if/when
6498 * it happens.
6499 */
6509 }
6511 /* ARGSUSED */
6512 static int
6516 {
6531 }
6533 /* . and .. have special meaning in the protocol, reject them. */
6543 top:
6544 /*
6545 * We make a copy of the attributes because the caller does not
6546 * expect us to change what va points to.
6547 */
6550 /*
6551 * If the pathname is "", then dvp is the root vnode of
6552 * a remote file mounted over a local directory.
6553 * All that needs to be done is access
6554 * checking and truncation. Note that we avoid doing
6555 * open w/ create because the parent directory might
6556 * be in pseudo-fs and the open would fail.
6557 */
6564 /*
6565 * We need to go over the wire, just to be sure whether the
6566 * file exists or not. Using the DNLC can be dangerous in
6567 * this case when making a decision regarding existence.
6568 */
6570 }
6574 else
6577 /*
6578 * error would be set if the file does not exist on the
6579 * server, so lets go create it.
6580 */
6583 }
6585 /*
6586 * File does exist on the server
6587 */
6593 /*
6594 * If vnode is a device, create special vnode.
6595 */
6600 }
6605 /*
6606 * Check here for large file handled
6607 * by LF-unaware process (as
6608 * ufs_create() does)
6609 */
6615 }
6617 /* if error is set then we need to return */
6622 }
6627 NULL);
6629 /*
6630 * we know we have a regular file that already
6631 * exists and we may end up truncating the file
6632 * as a result of the open_otw, so flush out
6633 * any dirty pages for this file first.
6634 */
6647 error;
6650 }
6651 }
6658 }
6659 }
6660 }
6661 }
6673 }
6676 /*
6677 * existing file got truncated, notify.
6678 */
6680 }
6683 }
6686 create_otw:
6691 /*
6692 * If not a regular file let nfs4mknod() handle it.
6693 */
6698 }
6700 /*
6701 * It _is_ a regular file.
6702 */
6707 }
6709 /*
6710 * If this happens to be a mknod of a regular file, then flags will
6711 * have neither FREAD or FWRITE. However, we must set at least one
6712 * for the call to nfs4open_otw. If it's open(O_CREAT) driving
6713 * nfs4_create, then either FREAD, FWRITE, or FRDWR has already been
6714 * set (based on openmode specified by app).
6715 */
6722 /* if create was successful, throw away the file's pages */
6725 cr);
6726 /* release the lookup hold */
6729 }
6731 /*
6732 * validate that we opened a regular file. This handles a misbehaving
6733 * server that returns an incorrect FH.
6734 */
6738 }
6740 /*
6741 * If this is not an exclusive create, then the CREATE
6742 * request will be made with the GUARDED mode set. This
6743 * means that the server will return EEXIST if the file
6744 * exists. The file could exist because of a retransmitted
6745 * request. In this case, we recover by starting over and
6746 * checking to see whether the file exists. This second
6747 * time through it should and a CREATE request will not be
6748 * sent.
6749 *
6750 * This handles the problem of a dangling CREATE request
6751 * which contains attributes which indicate that the file
6752 * should be truncated. This retransmitted request could
6753 * possibly truncate valid data in the file if not caught
6754 * by the duplicate request mechanism on the server or if
6755 * not caught by other means. The scenario is:
6756 *
6757 * Client transmits CREATE request with size = 0
6758 * Client times out, retransmits request.
6759 * Response to the first request arrives from the server
6760 * and the client proceeds on.
6761 * Client writes data to the file.
6762 * The server now processes retransmitted CREATE request
6763 * and truncates file.
6764 *
6765 * The use of the GUARDED CREATE request prevents this from
6766 * happening because the retransmitted CREATE would fail
6767 * with EEXIST and would not truncate the file.
6768 */
6770 #ifdef DEBUG
6771 nfs4_create_misses++;
6772 #endif
6774 }
6779 /*
6780 * existing file got truncated, notify.
6781 */
6787 }
6789 }
6791 /*
6792 * Create compound (for mkdir, mknod, symlink):
6793 * { Putfh <dfh>; Create; Getfh; Getattr }
6794 * It's okay if setattr failed to set gid - this is not considered
6795 * an error, but purge attrs in that case.
6796 */
6797 static int
6800 {
6802 COMPOUND4args_clnt args;
6815 nfs4_recov_state_t recov_state;
6817 hrtime_t t;
6822 bitmap4 supp_attrs;
6829 /*
6830 * Make sure we properly deal with setting the right gid
6831 * on a new directory to reflect the parent's setgid bit
6832 */
6841 /*
6842 * If the parent's directory has the setgid bit set
6843 * _and_ the client was able to get a valid mapping
6844 * for the parent dir's owner_group, we want to
6845 * append NVERIFY(owner_group == dva.va_gid) and
6846 * SETTATTR to the CREATE compound.
6847 */
6854 }
6855 }
6856 }
6857 }
6859 /*
6860 * Create ops:
6861 * 0:putfh(dir) 1:savefh(dir) 2:create 3:getfh(new) 4:getattr(new)
6862 * 5:restorefh(dir) 6:getattr(dir)
6863 *
6864 * if (setgid)
6865 * 0:putfh(dir) 1:create 2:getfh(new) 3:getattr(new)
6866 * 4:savefh(new) 5:putfh(dir) 6:getattr(dir) 7:restorefh(new)
6867 * 8:nverify 9:setattr
6868 */
6877 }
6882 }
6889 recov_retry:
6894 else
6904 }
6908 /* 0: putfh directory */
6912 /* 1/2: Create object */
6917 /*
6918 * symlink, treat name as data
6919 */
6923 }
6928 }
6943 }
6945 /* 2/3: getfh fh of created object */
6949 /* 3/4: getattr of new object */
6955 vattr_t _v;
6968 /*
6969 * nverify
6970 *
6971 * XXX - Revisit the last argument to nfs4_end_op()
6972 * once 5020486 is fixed.
6973 */
6977 supp_attrs)) {
6983 }
6985 /*
6986 * setattr
6987 *
6988 * We _know_ we're not messing with AT_SIZE or AT_XTIME,
6989 * so no need for stateid or flags. Also we specify NULL
6990 * rp since we're only interested in setting owner_group
6991 * attributes.
6992 */
7003 }
7012 }
7025 }
7031 needrecov);
7037 }
7040 }
7041 }
7052 /*
7053 * This check is left over from when create was implemented
7054 * using a setattr op (instead of createattrs). If the
7055 * putfh/create/getfh failed, the error was returned. If
7056 * setattr/getattr failed, we keep going.
7057 *
7058 * It might be better to get rid of the GETFH also, and just
7059 * do PUTFH/CREATE/GETATTR since the FH attr is mandatory.
7060 * Then if any of the operations failed, we could return the
7061 * error now, and remove much of the error code below.
7062 */
7064 /*
7065 * Either Putfh, Create or Getfh failed.
7066 */
7068 /*
7069 * nfs4_purge_stale_fh() may generate otw calls through
7070 * nfs4_invalidate_pages. Hence the need to call
7071 * nfs4_end_op() here to avoid nfs4_start_op() deadlock.
7072 */
7074 needrecov);
7078 }
7079 }
7093 /*
7094 * Need to call nfs4_end_op before nfs4getattr to avoid
7095 * potential nfs4_start_op deadlock. See RFE 4777612.
7096 */
7098 needrecov);
7105 }
7107 }
7114 }
7116 /*
7117 * If compound succeeded, then update dir attrs
7118 */
7127 /* Update directory cache attribute, readdir and dnlc caches */
7130 out:
7138 }
7146 }
7148 /* ARGSUSED */
7149 static int
7152 {
7155 nfs_ftype4 type;
7178 }
7183 }
7185 /*
7186 * This might not be needed any more; special case to deal
7187 * with problematic v2/v3 servers. Since create was unable
7188 * to set group correctly, not sure what hope setattr has.
7189 */
7193 }
7195 /*
7196 * If vnode is a device create special vnode
7197 */
7203 }
7205 }
7207 /*
7208 * Remove requires that the current fh be the target directory.
7209 * After the operation, the current fh is unchanged.
7210 * The compound op structure is:
7211 * PUTFH(targetdir), REMOVE
7212 *
7213 * Weirdness: if the vnode to be removed is open
7214 * we rename it instead of removing it and nfs_inactive
7215 * will remove the new name.
7216 */
7217 /* ARGSUSED */
7218 static int
7220 {
7221 COMPOUND4args_clnt args;
7233 nfs4_recov_state_t recov_state;
7236 dirattr_info_t dinfo;
7248 }
7254 }
7256 /*
7257 * First just remove the entry from the name cache, as it
7258 * is most likely the only entry for this vp.
7259 */
7264 /*
7265 * For regular file types, check to see if the file is open by looking
7266 * at the open streams.
7267 * For all other types, check the reference count on the vnode. Since
7268 * they are not opened OTW they never have an open stream.
7269 *
7270 * If the file is open, rename it to .nfsXXXX.
7271 */
7273 /*
7274 * If the file has a v_count > 1 then there may be more than one
7275 * entry in the name cache due multiple links or an open file,
7276 * but we don't have the real reference count so flush all
7277 * possible entries.
7278 */
7282 /*
7283 * Now we have the real reference count.
7284 */
7290 }
7313 }
7315 }
7319 }
7320 /*
7321 * Actually remove the file/dir
7322 */
7325 /*
7326 * We need to flush any dirty pages which happen to
7327 * be hanging around before removing the file.
7328 * This shouldn't happen very often since in NFSv4
7329 * we should be close to open consistent.
7330 */
7339 }
7340 }
7348 recov_retry:
7349 /*
7350 * Remove ops: putfh dir; remove
7351 */
7361 }
7363 /* putfh directory */
7367 /* remove */
7371 /* getattr dir */
7392 needrecov);
7394 }
7395 }
7397 /*
7398 * Matching nfs4_end_op() for start_op() above.
7399 * There is a path in the code below which calls
7400 * nfs4_purge_stale_fh(), which may generate otw calls through
7401 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
7402 * here to avoid nfs4_start_op() deadlock.
7403 */
7421 /* Update directory attr, readdir and dnlc caches */
7424 }
7425 }
7438 }
7441 }
7443 /*
7444 * Link requires that the current fh be the target directory and the
7445 * saved fh be the source fh. After the operation, the current fh is unchanged.
7446 * Thus the compound op structure is:
7447 * PUTFH(file), SAVEFH, PUTFH(targetdir), LINK, RESTOREFH,
7448 * GETATTR(file)
7449 */
7450 /* ARGSUSED */
7451 static int
7454 {
7455 COMPOUND4args_clnt args;
7466 nfs4_recov_state_t recov_state;
7467 hrtime_t t;
7469 dirattr_info_t dinfo;
7481 }
7488 }
7495 recov_retry:
7500 /*
7501 * Link ops: putfh fl; savefh; putfh tdir; link; getattr(dir);
7502 * restorefh; getattr(fl)
7503 */
7512 }
7514 /* 0. putfh file */
7518 /* 1. save current fh to free up the space for the dir */
7521 /* 2. putfh targetdir */
7525 /* 3. link: current_fh is targetdir, saved_fh is source */
7529 /* 4. Get attributes of dir */
7534 /* 5. If link was successful, restore current vp to file */
7537 /* 6. Get attributes of linked object */
7555 }
7558 bool_t abort;
7564 needrecov);
7576 }
7577 /* fall through for res.status case */
7578 }
7579 }
7585 /* If link succeeded, then don't return error */
7588 /*
7589 * Either Putfh, Savefh, Putfh dir, or Link failed
7590 */
7597 }
7598 /* XXX-LP */
7602 }
7603 }
7605 /* either no error or one of the postop getattr failed */
7607 /*
7608 * XXX - if LINK succeeded, but no attrs were returned for link
7609 * file, purge its cache.
7610 *
7611 * XXX Perform a simplified version of wcc checking. Instead of
7612 * have another getattr to get pre-op, just purge cache if
7613 * any of the ops prior to and including the getattr failed.
7614 * If the getattr succeeded then update the attrcache accordingly.
7615 */
7617 /*
7618 * update cache with link file postattrs.
7619 * Note: at this point resop points to link res.
7620 */
7628 /*
7629 * Call makenfs4node to create the new shadow vp for tnm.
7630 * We pass NULL attrs because we just cached attrs for
7631 * the src object. All we're trying to accomplish is to
7632 * to create the new shadow vnode.
7633 */
7637 /* Update target cache attribute, readdir and dnlc caches */
7651 /*
7652 * Notify the source file of this link operation.
7653 */
7659 }
7660 out:
7668 }
7670 /* ARGSUSED */
7671 static int
7674 {
7683 }
7685 /*
7686 * nfs4rename does the real work of renaming in NFS Version 4.
7687 *
7688 * A file handle is considered volatile for renaming purposes if either
7689 * of the volatile bits are turned on. However, the compound may differ
7690 * based on the likelihood of the filehandle to change during rename.
7691 */
7692 static int
7695 {
7728 }
7735 }
7736 }
7738 /*
7739 * Lookup the target file. If it exists, it needs to be
7740 * checked to see whether it is a mount point and whether
7741 * it is active (open).
7742 */
7748 /*
7749 * If this file has been mounted on, then just
7750 * return busy because renaming to it would remove
7751 * the mounted file system from the name space.
7752 */
7758 }
7760 /*
7761 * First just remove the entry from the name cache, as it
7762 * is most likely the only entry for this vp.
7763 */
7769 /*
7770 * Purge the name cache of all references to this vnode
7771 * so that we can check the reference count to infer
7772 * whether it is active or not.
7773 */
7782 }
7784 /*
7785 * If the vnode is active and is not a directory,
7786 * arrange to rename it to a
7787 * temporary file so that it will continue to be
7788 * accessible. This implements the "unlink-open-file"
7789 * semantics for the target of a rename operation.
7790 * Before doing this though, make sure that the
7791 * source and target files are not already the same.
7792 */
7794 /*
7795 * Lookup the source name.
7796 */
7799 /*
7800 * The source name *should* already exist.
7801 */
7807 }
7811 /*
7812 * Compare the two vnodes. If they are the same,
7813 * just release all held vnodes and return success.
7814 */
7821 }
7823 /*
7824 * Can't mix and match directories and non-
7825 * directories in rename operations. We already
7826 * know that the target is not a directory. If
7827 * the source is a directory, return an error.
7828 */
7835 }
7836 link_call:
7837 /*
7838 * The target file exists, is not the same as
7839 * the source file, and is active. We first
7840 * try to Link it to a temporary filename to
7841 * avoid having the server removing the file
7842 * completely (which could cause data loss to
7843 * the user's POV in the event the Rename fails
7844 * -- see bug 1165874).
7845 */
7846 /*
7847 * The do_link and did_link booleans are
7848 * introduced in the event we get NFS4ERR_FILE_OPEN
7849 * returned for the Rename. Some servers can
7850 * not Rename over an Open file, so they return
7851 * this error. The client needs to Remove the
7852 * newly created Link and do two Renames, just
7853 * as if the server didn't support LINK.
7854 */
7861 }
7868 }
7876 }
7891 }
7893 }
7898 }
7901 /*
7902 * When renaming directories to be a subdirectory of a
7903 * different parent, the dnlc entry for ".." will no
7904 * longer be valid, so it must be removed.
7905 *
7906 * We do a lookup here to determine whether we are renaming
7907 * a directory and we need to check if we are renaming
7908 * an unlinked file. This might have already been done
7909 * in previous code, so we check ovp == NULL to avoid
7910 * doing it twice.
7911 */
7913 /*
7914 * The source name *should* already exist.
7915 */
7921 }
7923 }
7926 }
7928 /*
7929 * Is the object being renamed a dir, and if so, is
7930 * it being renamed to a child of itself? The underlying
7931 * fs should ultimately return EINVAL for this case;
7932 * however, buggy beta non-Solaris NFSv4 servers at
7933 * interop testing events have allowed this behavior,
7934 * and it caused our client to panic due to a recursive
7935 * mutex_enter in fn_move.
7936 *
7937 * The tedious locking in fn_move could be changed to
7938 * deal with this case, and the client could avoid the
7939 * panic; however, the client would just confuse itself
7940 * later and misbehave. A better way to handle the broken
7941 * server is to detect this condition and return EINVAL
7942 * without ever sending the the bogus rename to the server.
7943 * We know the rename is invalid -- just fail it now.
7944 */
7951 }
7953 }
7957 /*
7958 * If FH4_VOL_RENAME or FH4_VOLATILE_ANY bits are set, it is
7959 * possible for the filehandle to change due to the rename.
7960 * If neither of these bits is set, but FH4_VOL_MIGRATION is set,
7961 * the fh will not change because of the rename, but we still need
7962 * to update its rnode entry with the new name for
7963 * an eventual fh change due to migration. The FH4_NOEXPIRE_ON_OPEN
7964 * has no effect on these for now, but for future improvements,
7965 * we might want to use it too to simplify handling of files
7966 * that are open with that flag on. (XXX)
7967 */
7972 else
7982 /*
7983 * Before the 'link_call' code, we did a nfs4_lookup
7984 * that puts a VN_HOLD on nvp. After the nfs4_link
7985 * call we call VN_RELE to match that hold. We need
7986 * to place an additional VN_HOLD here since we will
7987 * be hitting that VN_RELE again.
7988 */
7993 /* Undo the unlinked file naming stuff we just did */
8001 /* rp->r_unlanme points to tmpname */
8005 }
8010 }
8012 }
8020 }
8022 }
8024 /*
8025 * when renaming directories to be a subdirectory of a
8026 * different parent, the dnlc entry for ".." will no
8027 * longer be valid, so it must be removed
8028 */
8035 }
8036 }
8038 /*
8039 * If we are renaming the unlinked file, update the
8040 * r_unldvp and r_unlname as needed.
8041 */
8051 }
8052 }
8053 }
8056 /*
8057 * Notify the rename vnevents to source vnode, and to the target
8058 * vnode if it already existed.
8059 */
8063 /*
8064 * Notify the vnode. Each links is represented by
8065 * a different vnode, in nfsv4.
8066 */
8073 }
8075 /*
8076 * if the source and destination directory are not the
8077 * same notify the destination directory.
8078 */
8085 }
8092 }
8096 }
8103 }
8105 /*
8106 * When the parent directory has changed, sv_dfh must be updated
8107 */
8108 static void
8110 {
8118 }
8120 /*
8121 * nfs4rename_persistent does the otw portion of renaming in NFS Version 4,
8122 * when it is known that the filehandle is persistent through rename.
8123 *
8124 * Rename requires that the current fh be the target directory and the
8125 * saved fh be the source directory. After the operation, the current fh
8126 * is unchanged.
8127 * The compound op structure for persistent fh rename is:
8128 * PUTFH(sourcdir), SAVEFH, PUTFH(targetdir), RENAME
8129 * Rather than bother with the directory postop args, we'll simply
8130 * update that a change occurred in the cache, so no post-op getattrs.
8131 */
8132 static int
8135 {
8136 COMPOUND4args_clnt args;
8145 bool_t needrecov;
8146 nfs4_recov_state_t recov_state;
8155 /*
8156 * Rename ops: putfh sdir; savefh; putfh tdir; rename; getattr tdir
8157 *
8158 * If source/target are different dirs, then append putfh(src); getattr
8159 */
8164 recov_retry:
8167 /* No need to Lookup the file, persistent fh */
8175 }
8177 /* 0: putfh source directory */
8181 /* 1: Save source fh to free up current for target */
8184 /* 2: putfh targetdir */
8188 /* 3: current_fh is targetdir, saved_fh is sourcedir */
8193 /* 4: getattr (targetdir) */
8200 /* 5: putfh (sourcedir) */
8204 /* 6: getattr (sourcedir) */
8208 }
8223 }
8232 }
8233 }
8237 /*
8238 * as long as OP_RENAME
8239 */
8244 /*
8245 * System V defines rename to return EEXIST, not
8246 * ENOTEMPTY if the target directory is not empty.
8247 * Over the wire, the error is NFSERR_ENOTEMPTY
8248 * which geterrno4 maps to ENOTEMPTY.
8249 */
8258 /*
8259 * Update target attribute, readdir and dnlc
8260 * caches.
8261 */
8272 /*
8273 * Update source attribute, readdir and dnlc caches
8274 *
8275 */
8286 }
8289 nnm);
8290 }
8291 }
8299 }
8301 /*
8302 * nfs4rename_volatile_fh does the otw part of renaming in NFS Version 4, when
8303 * it is possible for the filehandle to change due to the rename.
8304 *
8305 * The compound req in this case includes a post-rename lookup and getattr
8306 * to ensure that we have the correct fh and attributes for the object.
8307 *
8308 * Rename requires that the current fh be the target directory and the
8309 * saved fh be the source directory. After the operation, the current fh
8310 * is unchanged.
8311 *
8312 * We need the new filehandle (hence a LOOKUP and GETFH) so that we can
8313 * update the filehandle for the renamed object. We also get the old
8314 * filehandle for historical reasons; this should be taken out sometime.
8315 * This results in a rather cumbersome compound...
8316 *
8317 * PUTFH(sourcdir), SAVEFH, LOOKUP(src), GETFH(old),
8318 * PUTFH(targetdir), RENAME, LOOKUP(trgt), GETFH(new), GETATTR
8319 *
8320 */
8321 static int
8324 {
8325 COMPOUND4args_clnt args;
8337 bool_t needrecov;
8338 nfs4_recov_state_t recov_state;
8339 hrtime_t t;
8348 recov_retry:
8351 /*
8352 * There is a window between the RPC and updating the path and
8353 * filehandle stored in the rnode. Lock out the FHEXPIRED recovery
8354 * code, so that it doesn't try to use the old path during that
8355 * window.
8356 */
8368 }
8371 }
8382 /*
8383 * Rename ops:
8384 * PUTFH(sourcdir), SAVEFH, LOOKUP(src), GETFH(old),
8385 * PUTFH(targetdir), RENAME, GETATTR(targetdir)
8386 * LOOKUP(trgt), GETFH(new), GETATTR,
8387 *
8388 * if (odvp != ndvp)
8389 * add putfh(sourcedir), getattr(sourcedir) }
8390 */
8402 }
8404 /* 0: putfh source directory */
8408 /* 1: Save source fh to free up current for target */
8411 /* 2: Lookup pre-rename fh of renamed object */
8415 /* 3: getfh fh of renamed object (before rename) */
8418 /* 4: putfh targetdir */
8422 /* 5: current_fh is targetdir, saved_fh is sourcedir */
8427 /* 6: getattr of target dir (post op attrs) */
8432 /* 7: Lookup post-rename fh of renamed object */
8436 /* 8: getfh fh of renamed object (after rename) */
8439 /* 9: getattr of renamed object */
8444 /*
8445 * If source/target dirs are different, then get new post-op
8446 * attrs for source dir also.
8447 */
8449 /* 10: putfh (sourcedir) */
8453 /* 11: getattr (sourcedir) */
8457 }
8474 }
8477 }
8480 bool_t abort;
8500 }
8501 /* fall through for res.status case */
8502 }
8503 }
8506 /*
8507 * If OP_RENAME (or any prev op) failed, then return an error.
8508 * OP_RENAME is index 5, so if array len <= 6 we return an error.
8509 */
8511 /*
8512 * Error in an op other than last Getattr
8513 */
8517 /*
8518 * System V defines rename to return EEXIST, not
8519 * ENOTEMPTY if the target directory is not empty.
8520 * Over the wire, the error is NFSERR_ENOTEMPTY
8521 * which geterrno4 maps to ENOTEMPTY.
8522 */
8526 needrecov);
8528 }
8530 /* rename results */
8534 /* Update target attribute, readdir and dnlc caches */
8542 /* Update source cache attribute, readdir and dnlc caches */
8545 /* Update source cache attribute, readdir and dnlc caches */
8549 /*
8550 * If dinfop is non-NULL, then compound succeded, so
8551 * set di_garp to attrs for source dir. dinfop is only
8552 * set to NULL when compound fails.
8553 */
8558 dinfop);
8559 }
8561 /*
8562 * Update the rnode with the new component name and args,
8563 * and if the file handle changed, also update it with the new fh.
8564 * This is only necessary if the target object has an rnode
8565 * entry and there is no need to create one for it.
8566 */
8570 /*
8571 * Update the path and filehandle for the renamed object.
8572 */
8582 }
8584 out:
8594 }
8596 /* ARGSUSED */
8597 static int
8600 {
8606 /*
8607 * As ".." has special meaning and rather than send a mkdir
8608 * over the wire to just let the server freak out, we just
8609 * short circuit it here and return EEXIST
8610 */
8614 /*
8615 * Decision to get the right gid and setgid bit of the
8616 * new directory is now made in call_nfs4_create_req.
8617 */
8625 }
8628 /*
8629 * rmdir is using the same remove v4 op as does remove.
8630 * Remove requires that the current fh be the target directory.
8631 * After the operation, the current fh is unchanged.
8632 * The compound op structure is:
8633 * PUTFH(targetdir), REMOVE
8634 */
8635 /*ARGSUSED4*/
8636 static int
8639 {
8641 COMPOUND4args_clnt args;
8651 nfs4_recov_state_t recov_state;
8657 /*
8658 * As ".." has special meaning and rather than send a rmdir
8659 * over the wire to just let the server freak out, we just
8660 * short circuit it here and return EEXIST
8661 */
8669 /*
8670 * Attempt to prevent a rmdir(".") from succeeding.
8671 */
8676 }
8681 }
8683 /*
8684 * Since nfsv4 remove op works on both files and directories,
8685 * check that the removed object is indeed a directory.
8686 */
8691 }
8693 /*
8694 * First just remove the entry from the name cache, as it
8695 * is most likely an entry for this vp.
8696 */
8699 /*
8700 * If there vnode reference count is greater than one, then
8701 * there may be additional references in the DNLC which will
8702 * need to be purged. First, trying removing the entry for
8703 * the parent directory and see if that removes the additional
8704 * reference(s). If that doesn't do it, then use dnlc_purge_vp
8705 * to completely remove any references to the directory which
8706 * might still exist in the DNLC.
8707 */
8712 }
8718 recov_retry:
8721 /*
8722 * Rmdir ops: putfh dir; remove
8723 */
8731 }
8734 /* putfh directory */
8738 /* remove */
8742 /* getattr (postop attrs for dir that contained removed dir) */
8756 }
8765 needrecov);
8768 }
8769 }
8774 /*
8775 * Only return error if first 2 ops (OP_REMOVE or earlier)
8776 * failed.
8777 */
8785 /*
8786 * System V defines rmdir to return EEXIST, not
8787 * ENOTEMPTY if the directory is not empty. Over
8788 * the wire, the error is NFSERR_ENOTEMPTY which
8789 * geterrno4 maps to ENOTEMPTY.
8790 */
8806 /* Update dir attribute, readdir and dnlc caches */
8808 dinfop);
8810 /* destroy rddir cache for dir that was removed */
8813 }
8814 }
8832 }
8837 }
8839 /* ARGSUSED */
8840 static int
8843 {
8876 }
8877 }
8878 }
8882 }
8885 /*
8886 * Read directory entries.
8887 * There are some weird things to look out for here. The uio_loffset
8888 * field is either 0 or it is the offset returned from a previous
8889 * readdir. It is an opaque value used by the server to find the
8890 * correct directory block to read. The count field is the number
8891 * of blocks to read on the server. This is advisory only, the server
8892 * may return only one block's worth of entries. Entries may be compressed
8893 * on the server.
8894 */
8895 /* ARGSUSED */
8896 static int
8899 {
8901 uint_t count;
8912 /*
8913 * Make sure that the directory cache is valid.
8914 */
8917 /*
8918 * Setting nfs_disable_rddir_cache in /etc/system
8919 * allows interoperability with servers that do not
8920 * properly update the attributes of directories.
8921 * Any cached information gets purged before an
8922 * access is made to it.
8923 */
8925 }
8930 }
8934 /*
8935 * Short circuit last readdir which always returns 0 bytes.
8936 * This can be done after the directory has been read through
8937 * completely at least once. This will set r_direof which
8938 * can be used to find the value of the last cookie.
8939 */
8944 #ifdef DEBUG
8945 nfs4_readdir_cache_shorts++;
8946 #endif
8950 }
8952 /*
8953 * Look for a cache entry. Cache entries are identified
8954 * by the NFS cookie value and the byte count requested.
8955 */
8958 /*
8959 * If rdc is NULL then the lookup resulted in an unrecoverable error.
8960 */
8964 }
8966 /*
8967 * Check to see if we need to fill this entry in.
8968 */
8974 /*
8975 * Do the readdir.
8976 */
8979 /*
8980 * Reacquire the lock, so that we can continue
8981 */
8983 /*
8984 * The entry is now complete
8985 */
8987 }
8991 /*
8992 * If an error occurred while attempting
8993 * to fill the cache entry, mark the entry invalid and
8994 * just return the error.
8995 */
9002 }
9004 /*
9005 * The cache entry is complete and good,
9006 * copyout the dirent structs to the calling
9007 * thread.
9008 */
9011 /*
9012 * If no error occurred during the copyout,
9013 * update the offset in the uio struct to
9014 * contain the value of the next NFS 4 cookie
9015 * and set the eof value appropriately.
9016 */
9021 }
9023 /*
9024 * Decide whether to do readahead. Don't if we
9025 * have already read to the end of directory.
9026 */
9028 /*
9029 * Make the entry the direof only if it is cached
9030 */
9036 }
9038 /* Determine if a readdir readahead should be done */
9043 }
9045 /*
9046 * Now look for a readahead entry.
9047 *
9048 * Check to see whether we found an entry for the readahead.
9049 * If so, we don't need to do anything further, so free the new
9050 * entry if one was allocated. Otherwise, allocate a new entry, add
9051 * it to the cache, and then initiate an asynchronous readdir
9052 * operation to fill it.
9053 */
9056 /*
9057 * A readdir cache entry could not be obtained for the readahead. In
9058 * this case we skip the readahead and return.
9059 */
9064 }
9066 /*
9067 * Check to see if we need to fill this entry in.
9068 */
9074 #ifdef DEBUG
9075 nfs4_readdir_readahead++;
9076 #endif
9077 /*
9078 * Do the readdir.
9079 */
9082 }
9088 }
9090 static int
9092 {
9100 /*
9101 * Obtain the readdir results for the caller.
9102 */
9106 /*
9107 * The entry is now complete
9108 */
9118 }
9120 /*
9121 * Read directory entries.
9122 * There are some weird things to look out for here. The uio_loffset
9123 * field is either 0 or it is the offset returned from a previous
9124 * readdir. It is an opaque value used by the server to find the
9125 * correct directory block to read. The count field is the number
9126 * of blocks to read on the server. This is advisory only, the server
9127 * may return only one block's worth of entries. Entries may be compressed
9128 * on the server.
9129 *
9130 * Generates the following compound request:
9131 * 1. If readdir offset is zero and no dnlc entry for parent exists,
9132 * must include a Lookupp as well. In this case, send:
9133 * { Putfh <fh>; Readdir; Lookupp; Getfh; Getattr }
9134 * 2. Otherwise just do: { Putfh <fh>; Readdir }
9135 *
9136 * Get complete attributes and filehandles for entries if this is the
9137 * first read of the directory. Otherwise, just get fileid's.
9138 */
9139 static void
9141 {
9142 COMPOUND4args_clnt args;
9143 COMPOUND4res_clnt res;
9146 bitmap4 rd_bitsval;
9157 nfs4_recov_state_t recov_state;
9158 hrtime_t t;
9165 /*
9166 * If rp were a stub, it should have triggered and caused
9167 * a mount for us to get this far.
9168 */
9173 /*
9174 * Since nfsv4 readdir may not return entries for "." and "..",
9175 * the client must recreate them:
9176 * To find the correct nodeid, do the following:
9177 * For current node, get nodeid from dnlc.
9178 * - if current node is rootvp, set pnodeid to nodeid.
9179 * - else if parent is in the dnlc, get its nodeid from there.
9180 * - else add LOOKUPP+GETATTR to compound.
9181 */
9188 /* parent in dnlc cache - no need for otw */
9191 /*
9192 * parent not in dnlc cache,
9193 * do lookupp to get its id
9194 */
9197 }
9200 }
9201 }
9205 /* Save the original mount point security flavor */
9208 recov_retry:
9216 /*
9217 * If readdir a node that is a stub for a crossed mount point,
9218 * keep the original secinfo flavor for the current file
9219 * system, not the crossed one.
9220 */
9224 }
9226 /*
9227 * Determine which attrs to request for dirents. This code
9228 * must be protected by nfs4_start/end_fop because of r_server
9229 * (which will change during failover recovery).
9230 *
9231 */
9233 /*
9234 * Get all vattr attrs plus filehandle and rdattr_error
9235 */
9237 FATTR4_RDATTR_ERROR_MASK |
9238 FATTR4_FILEHANDLE_MASK;
9244 }
9248 /*
9249 * Already read directory. Use readdir with
9250 * no attrs (except for mounted_on_fileid) for updates.
9251 */
9254 /*
9255 * request mounted on fileid if supported, else request
9256 * fileid. maybe we should verify that fileid is supported
9257 * and request something else if not.
9258 */
9263 }
9265 /* putfh directory fh */
9271 /*
9272 * 1 and 2 are reserved for client "." and ".." entry offset.
9273 * cookie 0 should be used over-the-wire to start reading at
9274 * the beginning of the directory excluding "." and "..".
9275 */
9286 }
9296 /*
9297 * If count < than the minimum required, we return no entries
9298 * and fail with EINVAL
9299 */
9303 }
9306 /*
9307 * Add lookupp and getattr for parent nodeid.
9308 */
9313 /* getattr parent */
9317 }
9325 }
9327 /* capture the time of this call */
9336 }
9340 /*
9341 * If RPC error occurred and it isn't an error that
9342 * triggers recovery, then go ahead and fail now.
9343 */
9347 }
9350 bool_t abort;
9365 }
9367 }
9372 }
9374 /* fall through for res.status case */
9375 }
9379 /*
9380 * If compound failed first 2 ops (PUTFH+READDIR), then return
9381 * failure here. Subsequent ops are for filling out dot-dot
9382 * dirent, and if they fail, we still want to give the caller
9383 * the dirents returned by (the successful) READDIR op, so we need
9384 * to silently ignore failure for subsequent ops (LOOKUPP+GETATTR).
9385 *
9386 * One example where PUTFH+READDIR ops would succeed but
9387 * LOOKUPP+GETATTR would fail would be a dir that has r perm
9388 * but lacks x. In this case, a POSIX server's fop_readdir
9389 * would succeed; however, fop_lookup(..) would fail since no
9390 * x perm. We need to come up with a non-vendor-specific way
9391 * for a POSIX server to return d_ino from dotdot's dirent if
9392 * client only requests mounted_on_fileid, and just say the
9393 * LOOKUPP succeeded and fill out the GETATTR. However, if
9394 * client requested any mandatory attrs, server would be required
9395 * to fail the GETATTR op because it can't call fop_lookup+fop_getattr
9396 * for dotdot.
9397 */
9410 }
9411 /*
9412 * If readdir a node that is a stub for a
9413 * crossed mount point, keep the original
9414 * secinfo flavor for the current file system,
9415 * not the crossed one.
9416 */
9419 }
9420 }
9429 /*
9430 * For "." and ".." entries
9431 * e.g.
9432 * seek(cookie=0) -> "." entry with d_off = 1
9433 * seek(cookie=1) -> ".." entry with d_off = 2
9434 */
9440 }
9444 }
9447 /* LOOKUPP+GETATTR attemped */
9461 /*
9462 * First, take care of finishing the
9463 * readdir results.
9464 */
9466 /*
9467 * The d_ino of .. must be the inode number
9468 * of the mounted filesystem.
9469 */
9475 /*
9476 * Next, create the ".." dnlc entry
9477 */
9482 }
9484 }
9485 }
9492 }
9496 out:
9497 /*
9498 * If readdir a node that is a stub for a crossed mount point,
9499 * keep the original secinfo flavor for the current file system,
9500 * not the crossed one.
9501 */
9505 }
9508 static int
9510 {
9515 offset_t offset;
9526 read_again:
9527 /*
9528 * Releases the osp, if it is provided.
9529 * Puts a hold on the cred_otw and the new osp (if found).
9530 */
9539 /*
9540 * Didn't get it all because we hit EOF,
9541 * zero all the memory beyond the EOF.
9542 */
9543 /* bzero(rdaddr + */
9546 }
9550 /*
9551 * We didn't read anything at all as we are
9552 * past EOF. Return an error indicator back
9553 * but don't destroy the pages (yet).
9554 */
9556 }
9560 }
9563 write_again:
9564 /*
9565 * Releases the osp, if it is provided.
9566 * Puts a hold on the cred_otw and the new
9567 * osp (if found).
9568 */
9576 #ifdef DEBUG
9582 offset);
9590 }
9591 #endif
9597 }
9601 /*
9602 * Don't print EDQUOT errors on the console.
9603 * Don't print asynchronous EACCES errors.
9604 * Don't print EFBIG errors.
9605 * Print all other write errors.
9606 */
9612 /*
9613 * Update r_error and r_flags as appropriate.
9614 * If the error was ESTALE, then mark the
9615 * rnode as not being writeable and save
9616 * the error status. Otherwise, save any
9617 * errors which occur from asynchronous
9618 * page invalidations. Any errors occurring
9619 * from other operations should be saved
9620 * by the caller.
9621 */
9632 }
9634 }
9638 /*
9639 * A close may have cleared r_error, if so,
9640 * propagate ESTALE error return properly
9641 */
9644 }
9645 }
9656 }
9658 /* ARGSUSED */
9659 int
9661 {
9663 }
9665 /* ARGSUSED2 */
9666 int
9668 {
9674 }
9682 }
9686 }
9688 /* ARGSUSED */
9689 void
9691 {
9695 }
9697 /* ARGSUSED */
9698 static int
9700 {
9704 /*
9705 * Because we stuff the readdir cookie into the offset field
9706 * someone may attempt to do an lseek with the cookie which
9707 * we want to succeed.
9708 */
9714 }
9717 /*
9718 * Return all the pages from [off..off+len) in file
9719 */
9720 /* ARGSUSED */
9721 static int
9725 {
9742 /*
9743 * Now validate that the caches are up to date.
9744 */
9749 retry:
9752 /*
9753 * Don't create dirty pages faster than they
9754 * can be cleaned so that the system doesn't
9755 * get imbalanced. If the async queue is
9756 * maxed out, then wait for it to drain before
9757 * creating more dirty pages. Also, wait for
9758 * any threads doing pagewalks in the vop_getattr
9759 * entry points so that they don't block for
9760 * long periods.
9761 */
9767 }
9769 /*
9770 * If we are getting called as a side effect of an nfs_write()
9771 * operation the local file size might not be extended yet.
9772 * In this case we want to be able to return pages of zeroes.
9773 */
9781 }
9797 }
9800 }
9802 /*
9803 * Called from pvn_getpages to get a particular page.
9804 */
9805 /* ARGSUSED */
9806 static int
9810 {
9812 uint_t bsize;
9815 uoff_t lbn;
9816 uoff_t io_off;
9817 uoff_t blkoff;
9818 uoff_t rablkoff;
9820 uint_t blksize;
9835 reread:
9847 /*
9848 * Queueing up the readahead before doing the synchronous read
9849 * results in a significant increase in read throughput because
9850 * of the increased parallelism between the async threads and
9851 * the process context.
9852 */
9858 /*
9859 * Calculate the number of readaheads to do.
9860 * a) No readaheads at offset = 0.
9861 * b) Do maximum(nfs4_nra) readaheads when the readahead
9862 * window is closed.
9863 * c) Do readaheads between 1 to (nfs4_nra - 1) depending
9864 * upon how far the readahead window is open or close.
9865 * d) No readaheads if rp->r_nextr is not within the scope
9866 * of the readahead window (random i/o).
9867 */
9877 else
9888 }
9889 readahead--;
9891 /*
9892 * Indicate that we did a readahead so
9893 * readahead offset is not updated
9894 * by the synchronous read below.
9895 */
9898 /*
9899 * set readahead offset to
9900 * offset of last async readahead
9901 * request.
9902 */
9904 }
9906 }
9908 again:
9912 nfs4_readahead);
9914 /*
9915 * Block for this page is not allocated, or the offset
9916 * is beyond the current allocation size, or we're
9917 * allocating a swap slot and the page was not found,
9918 * so allocate it and return a zero page.
9919 */
9928 /*
9929 * Need to go to server to get a block
9930 */
9934 /*
9935 * If less than a block left in
9936 * file read less than a block.
9937 */
9939 /*
9940 * Trying to access beyond EOF,
9941 * set up to get at least one page.
9942 */
9957 /*
9958 * Some other thread has entered the page,
9959 * so just use it.
9960 */
9964 /*
9965 * Now round the request size up to page boundaries.
9966 * This ensures that the entire page will be
9967 * initialized to zeroes if EOF is encountered.
9968 */
9974 /*
9975 * pageio_setup should have set b_addr to 0. This
9976 * is correct since we want to do I/O on a page
9977 * boundary. bp_mapin will use this addr to calculate
9978 * an offset, and then set b_addr to the kernel virtual
9979 * address it allocated for us.
9980 */
9990 /*
9991 * If doing a write beyond what we believe is EOF,
9992 * don't bother trying to read the pages from the
9993 * server, we'll just zero the pages here. We
9994 * don't check that the rw flag is S_WRITE here
9995 * because some implementations may attempt a
9996 * read access to the buffer before copying data.
9997 */
10005 }
10007 /*
10008 * Unmap the buffer before freeing it.
10009 */
10019 /*
10020 * If doing a write system call just return
10021 * zeroed pages, else user tried to get pages
10022 * beyond EOF, return error. We don't check
10023 * that the rw flag is S_WRITE here because
10024 * some implementations may attempt a read
10025 * access to the buffer before copying data.
10026 */
10029 else
10031 }
10037 }
10038 }
10039 }
10041 out:
10049 }
10054 /*
10055 * Page exists in the cache, acquire the appropriate lock.
10056 * If this fails, start all over again.
10057 */
10059 #ifdef DEBUG
10060 nfs4_lostpage++;
10061 #endif
10063 }
10067 }
10073 }
10075 static void
10078 {
10081 uoff_t io_off;
10094 /*
10095 * If less than a block left in file read less
10096 * than a block.
10097 */
10105 /*
10106 * The isra flag passed to the kluster function is 1, we may have
10107 * gotten a return value of NULL for a variety of reasons (# of free
10108 * pages < minfree, someone entered the page on the vnode etc). In all
10109 * cases, we want to punt on the readahead.
10110 */
10114 /*
10115 * Now round the request size up to page boundaries.
10116 * This ensures that the entire page will be
10117 * initialized to zeroes if EOF is encountered.
10118 */
10124 /*
10125 * pageio_setup should have set b_addr to 0. This is correct since
10126 * we want to do I/O on a page boundary. bp_mapin() will use this addr
10127 * to calculate an offset, and then set b_addr to the kernel virtual
10128 * address it allocated for us.
10129 */
10139 /*
10140 * If doing a write beyond what we believe is EOF, don't bother trying
10141 * to read the pages from the server, we'll just zero the pages here.
10142 * We don't check that the rw flag is S_WRITE here because some
10143 * implementations may attempt a read access to the buffer before
10144 * copying data.
10145 */
10156 }
10158 /*
10159 * Unmap the buffer before freeing it.
10160 */
10171 /*
10172 * In case of error set readahead offset
10173 * to the lowest offset.
10174 * pvn_read_done() calls VN_DISPOSE to destroy the pages
10175 */
10181 }
10182 }
10184 /*
10185 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
10186 * If len == 0, do from off to EOF.
10187 *
10188 * The normal cases should be len == 0 && off == 0 (entire vp list) or
10189 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
10190 * (from pageout).
10191 */
10192 /* ARGSUSED */
10193 static int
10196 {
10209 /*
10210 * XXX - Why should this check be made here?
10211 */
10229 }
10231 /*
10232 * Write out a single page, possibly klustering adjacent dirty pages.
10233 */
10234 int
10237 {
10238 uoff_t io_off;
10239 uoff_t lbn_off;
10240 uoff_t lbn;
10242 uint_t bsize;
10259 /*
10260 * Find a kluster that fits in one block, or in
10261 * one page if pages are bigger than blocks. If
10262 * there is less file space allocated than a whole
10263 * page, we'll shorten the i/o request below.
10264 */
10268 /*
10269 * pvn_write_kluster shouldn't have returned a page with offset
10270 * behind the original page we were given. Verify that.
10271 */
10274 /*
10275 * Now pp will have the list of kept dirty pages marked for
10276 * write back. It will also handle invalidation and freeing
10277 * of pages that are not dirty. Check for page length rounding
10278 * problems.
10279 */
10283 }
10284 /*
10285 * The R4MODINPROGRESS flag makes sure that nfs4_bio() sees a
10286 * consistent value of r_size. R4MODINPROGRESS is set in writerp4().
10287 * When R4MODINPROGRESS is set it indicates that a uiomove() is in
10288 * progress and the r_size has not been made consistent with the
10289 * new size of the file. When the uiomove() completes the r_size is
10290 * updated and the R4MODINPROGRESS flag is cleared.
10291 *
10292 * The R4MODINPROGRESS flag makes sure that nfs4_bio() sees a
10293 * consistent value of r_size. Without this handshaking, it is
10294 * possible that nfs4_bio() picks up the old value of r_size
10295 * before the uiomove() in writerp4() completes. This will result
10296 * in the write through nfs4_bio() being dropped.
10297 *
10298 * More precisely, there is a window between the time the uiomove()
10299 * completes and the time the r_size is updated. If a fop_putpage()
10300 * operation intervenes in this window, the page will be picked up,
10301 * because it is dirty (it will be unlocked, unless it was
10302 * pagecreate'd). When the page is picked up as dirty, the dirty
10303 * bit is reset (pvn_getdirty()). In nfs4write(), r_size is
10304 * checked. This will still be the old size. Therefore the page will
10305 * not be written out. When segmap_release() calls fop_putpage(),
10306 * the page will be found to be clean and the write will be dropped.
10307 */
10314 /*
10315 * A write is in progress for this region of the file.
10316 * If we did not detect R4MODINPROGRESS here then this
10317 * path through nfs_putapage() would eventually go to
10318 * nfs4_bio() and may not write out all of the data
10319 * in the pages. We end up losing data. So we decide
10320 * to set the modified bit on each page in the page
10321 * list and mark the rnode with R4DIRTY. This write
10322 * will be restarted at some later time.
10323 */
10331 }
10339 }
10341 }
10345 nfs4_sync_putapage);
10354 }
10356 static int
10359 {
10378 }
10381 /*
10382 * If this was not an async thread, then try again to
10383 * write out the pages, but this time, also destroy
10384 * them whether or not the write is successful. This
10385 * will prevent memory from filling up with these
10386 * pages and destroying them is the only alternative
10387 * if they can't be written out.
10388 *
10389 * Don't do this if this is an async thread because
10390 * when the pages are unlocked in pvn_write_done,
10391 * some other thread could have come along, locked
10392 * them, and queued for an async thread. It would be
10393 * possible for all of the async threads to be tied
10394 * up waiting to lock the pages again and they would
10395 * all already be locked and waiting for an async
10396 * thread to handle them. Deadlock.
10397 */
10401 }
10409 }
10413 NFS4_WRITE_NOWAIT);
10414 }
10417 }
10419 #ifdef DEBUG
10421 #endif
10423 /* ARGSUSED */
10424 static int
10428 {
10446 /*
10447 * If the file is delegated to the client don't do anything.
10448 * If the file is not delegated, then validate the data cache.
10449 */
10458 }
10460 /*
10461 * Check to see if the vnode is currently marked as not cachable.
10462 * This means portions of the file are locked (through fop_frlock).
10463 * In this case the map request must be refused. We use
10464 * rp->r_lkserlock to avoid a race with concurrent lock requests.
10465 *
10466 * Atomically increment r_inmap after acquiring r_rwlock. The
10467 * idea here is to acquire r_rwlock to block read/write and
10468 * not to protect r_inmap. r_inmap will inform nfs4_read/write()
10469 * that we are in nfs4_map(). Now, r_rwlock is acquired in order
10470 * and we can prevent the deadlock that would have occurred
10471 * when nfs4_addmap() would have acquired it out of order.
10472 *
10473 * Since we are not protecting r_inmap by any lock, we do not
10474 * hold any lock when we decrement it. We atomically decrement
10475 * r_inmap after we release r_lkserlock.
10476 */
10486 }
10491 }
10493 /*
10494 * Don't allow concurrent locks and mapping if mandatory locking is
10495 * enabled.
10496 */
10506 }
10507 }
10509 /*
10510 * It is possible that the rnode has a lost lock request that we
10511 * are still trying to recover, and that the request conflicts with
10512 * this map request.
10513 *
10514 * An alternative approach would be for nfs4_safemap() to consider
10515 * queued lock requests when deciding whether to set or clear
10516 * VNOCACHE. This would require the frlock code path to call
10517 * nfs4_safemap() after enqueing a lost request.
10518 */
10522 }
10529 }
10532 /*
10533 * We need to retrieve the open stream
10534 */
10540 /* returns with 'os_sync_lock' held */
10543 }
10545 #ifdef DEBUG
10549 }
10550 #endif
10551 /* returns with 'os_sync_lock' held */
10555 "nfs4_map: we tried to OPEN the file "
10558 }
10559 }
10565 "nfs4_map: os_failed_reopen set on "
10570 }
10573 }
10589 done:
10593 }
10595 /*
10596 * We're most likely dealing with a kernel module that likes to READ
10597 * and mmap without OPENing the file (ie: lookup/read/mmap), so lets
10598 * officially OPEN the file to create the necessary client state
10599 * for bookkeeping of os_mmap_read/write counts.
10600 *
10601 * Since fop_map only passes in a pointer to the vnode rather than
10602 * a double pointer, we can't handle the case where nfs4open_otw()
10603 * returns a different vnode than the one passed into fop_map (since
10604 * fop_delmap will not see the vnode nfs4open_otw used). In this case,
10605 * we return NULL and let nfs4_map() fail. Note: the only case where
10606 * this should happen is if the file got removed and replaced with the
10607 * same name on the server (in addition to the fact that we're trying
10608 * to fop_map withouth fop_opening the file in the first place).
10609 */
10610 static int
10612 {
10632 }
10638 }
10646 /* This is needed so we don't bump the open ref count */
10651 }
10656 just_created);
10662 }
10667 /*
10668 * If nfs4open_otw() returned a different vnode then "undo"
10669 * the open and return failure to the caller.
10670 */
10672 nfs4_error_t e;
10676 /*
10677 * If there's an error, ignore it,
10678 * and let fop_inactive handle it.
10679 */
10684 }
10690 nfs4_error_t e;
10694 /*
10695 * If there's an error, ignore it,
10696 * and let fop_inactive handle it.
10697 */
10701 }
10706 }
10708 /*
10709 * Please be aware that when this function is called, the address space write
10710 * a_lock is held. Do not put over the wire calls in this function.
10711 */
10712 /* ARGSUSED */
10713 static int
10717 {
10730 /*
10731 * Don't need to update the open stream first, since this
10732 * mmap can't add any additional share access that isn't
10733 * already contained in the open stream (for the case where we
10734 * open/mmap/only update rp->r_mapcnt/server reboots/reopen doesn't
10735 * take into account os_mmap_read[write] counts).
10736 */
10740 /*
10741 * We need to retrieve the open stream and update the counts.
10742 * If there is no open stream here, something is wrong.
10743 */
10749 /* returns with 'os_sync_lock' held */
10752 }
10755 "nfs4_addmap: we should have an osp"
10759 }
10764 /*
10765 * Update the map count in the open stream.
10766 * This is necessary in the case where we
10767 * open/mmap/close/, then the server reboots, and we
10768 * attempt to reopen. If the mmap doesn't add share
10769 * access then we send an invalid reopen with
10770 * access = NONE.
10771 *
10772 * We need to specifically check each PROT_* so a mmap
10773 * call of (PROT_WRITE | PROT_EXEC) will ensure us both
10774 * read and write access. A simple comparison of prot
10775 * to ~PROT_WRITE to determine read access is insufficient
10776 * since prot can be |= with PROT_USER, etc.
10777 */
10779 /*
10780 * Unless we're MAP_SHARED, no sense in adding os_mmap_write
10781 */
10788 /*
10789 * Ensure that os_mmap_read gets incremented, even if
10790 * maxprot were to look like PROT_NONE.
10791 */
10798 }
10800 out:
10801 /*
10802 * If we got an error, then undo our
10803 * incrementing of 'r_mapcnt'.
10804 */
10809 }
10811 }
10813 /* ARGSUSED */
10814 static int
10816 {
10819 }
10821 /* ARGSUSED */
10822 static int
10826 {
10831 nfs4_error_t e;
10836 /* check for valid cmd parameter */
10840 /* Verify l_type. */
10856 }
10858 /* check the validity of the lock range */
10864 /*
10865 * If the filesystem is mounted using local locking, pass the
10866 * request off to the local locking code.
10867 */
10870 /*
10871 * For complete safety, we should be holding
10872 * r_lkserlock. However, we can't call
10873 * nfs4_safelock and then fs_frlock while
10874 * holding r_lkserlock, so just invoke
10875 * nfs4_safelock and expect that this will
10876 * catch enough of the cases.
10877 */
10880 }
10882 }
10886 /*
10887 * Check whether the given lock request can proceed, given the
10888 * current file mappings.
10889 */
10896 }
10897 }
10899 /*
10900 * Flush the cache after waiting for async I/O to finish. For new
10901 * locks, this is so that the process gets the latest bits from the
10902 * server. For unlocks, this is so that other clients see the
10903 * latest bits once the file has been unlocked. If currently dirty
10904 * pages can't be flushed, then don't allow a lock to be set. But
10905 * allow unlocks to succeed, to avoid having orphan locks on the
10906 * server.
10907 */
10922 }
10927 }
10928 }
10939 }
10943 }
10944 }
10945 }
10947 /*
10948 * Call the lock manager to do the real work of contacting
10949 * the server and obtaining the lock.
10950 */
10958 done:
10962 }
10964 /*
10965 * Free storage space associated with the specified vnode. The portion
10966 * to be freed is specified by bfp->l_start and bfp->l_len (already
10967 * normalized to a "whence" of 0).
10968 *
10969 * This is an experimental facility whose continued existence is not
10970 * guaranteed. Currently, we only support the special case
10971 * of l_len == 0, meaning free to end of file.
10972 */
10973 /* ARGSUSED */
10974 static int
10977 {
11000 }
11003 }
11005 /* ARGSUSED */
11006 int
11008 {
11014 }
11017 }
11019 /*
11020 * Setup and add an address space callback to do the work of the delmap call.
11021 * The callback will (and must be) deleted in the actual callback function.
11022 *
11023 * This is done in order to take care of the problem that we have with holding
11024 * the address space's a_lock for a long period of time (e.g. if the NFS server
11025 * is down). Callbacks will be executed in the address space code while the
11026 * a_lock is not held. Holding the address space's a_lock causes things such
11027 * as ps and fork to hang because they are trying to acquire this lock as well.
11028 */
11029 /* ARGSUSED */
11030 static int
11034 {
11044 /*
11045 * A process may not change zones if it has NFS pages mmap'ed
11046 * in, so we can't legitimately get here from the wrong zone.
11047 */
11052 /*
11053 * The way that the address space of this process deletes its mapping
11054 * of this file is via the following call chains:
11055 * - as_free()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs4_delmap()
11056 * - as_unmap()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs4_delmap()
11057 *
11058 * With the use of address space callbacks we are allowed to drop the
11059 * address space lock, a_lock, while executing the NFS operations that
11060 * need to go over the wire. Returning EAGAIN to the caller of this
11061 * function is what drives the execution of the callback that we add
11062 * below. The callback will be executed by the address space code
11063 * after dropping the a_lock. When the callback is finished, since
11064 * we dropped the a_lock, it must be re-acquired and segvn_unmap()
11065 * is called again on the same segment to finish the rest of the work
11066 * that needs to happen during unmapping.
11067 *
11068 * This action of calling back into the segment driver causes
11069 * nfs4_delmap() to get called again, but since the callback was
11070 * already executed at this point, it already did the work and there
11071 * is nothing left for us to do.
11072 *
11073 * To Summarize:
11074 * - The first time nfs4_delmap is called by the current thread is when
11075 * we add the caller associated with this delmap to the delmap caller
11076 * list, add the callback, and return EAGAIN.
11077 * - The second time in this call chain when nfs4_delmap is called we
11078 * will find this caller in the delmap caller list and realize there
11079 * is no more work to do thus removing this caller from the list and
11080 * returning the error that was set in the callback execution.
11081 */
11084 /*
11085 * 'error' is from the actual delmap operations. To avoid
11086 * hangs, we need to handle the return of EAGAIN differently
11087 * since this is what drives the callback execution.
11088 * In this case, we don't want to return EAGAIN and do the
11089 * callback execution because there are none to execute.
11090 */
11093 else
11095 }
11097 /* current caller was not in the list */
11120 }
11124 {
11132 }
11134 static void
11136 {
11138 }
11140 /*
11141 * Searches for the current delmap caller (based on curthread) in the list of
11142 * callers. If it is found, we remove it and free the delmap caller.
11143 * Returns:
11144 * 0 if the caller wasn't found
11145 * 1 if the caller was found, removed and freed. *errp will be set
11146 * to what the result of the delmap was.
11147 */
11148 static int
11150 {
11153 /*
11154 * If the list doesn't exist yet, we create it and return
11155 * that the caller wasn't found. No list = no callers.
11156 */
11159 /* The list does not exist */
11166 /* The list exists so search it */
11171 /* current caller is in the list */
11177 }
11178 }
11179 }
11182 }
11184 /*
11185 * Remove some pages from an mmap'd vnode. Just update the
11186 * count of pages. If doing close-to-open, then flush and
11187 * commit all of the pages associated with this file.
11188 * Otherwise, start an asynchronous page flush to write out
11189 * any dirty pages. This will also associate a credential
11190 * with the rnode which can be used to write the pages.
11191 */
11192 /* ARGSUSED */
11193 static void
11195 {
11207 /*
11208 * Initiate a page flush and potential commit if there are
11209 * pages, the file system was not mounted readonly, the segment
11210 * was mapped shared, and the pages themselves were writeable.
11211 */
11225 }
11238 }
11240 /* Check to see if we need to close the file */
11247 /*
11248 * Since it is possible that e.error == 0 and
11249 * e.stat != NFS4_OK (and vice versa),
11250 * we do the proper checking in order to get both
11251 * e.error and e.stat reporting the correct info.
11252 */
11261 }
11262 }
11266 }
11269 static uint_t
11271 {
11276 }
11280 }
11283 }
11286 }
11289 }
11292 }
11295 }
11297 }
11299 static int
11301 {
11312 }
11314 /* ARGSUSED */
11315 int
11318 {
11320 hrtime_t t;
11322 nfs4_ga_res_t gar;
11323 nfs4_ga_ext_res_t ger;
11332 }
11336 }
11340 /*
11341 * The existence of the xattr directory is not sufficient
11342 * for determining whether generic user attributes exists.
11343 * The attribute directory could only be a transient directory
11344 * used for Solaris sysattr support. Do a small readdir
11345 * to verify if the only entries are sysattrs or not.
11346 *
11347 * pc4_xattr_valid can be only be trusted when r_xattr_dir
11348 * is NULL. Once the xadir vp exists, we can create xattrs,
11349 * and we don't have any way to update the "base" object's
11350 * pc4_xattr_exists from the xattr or xadir. Maybe FEM
11351 * could help out.
11352 */
11356 }
11386 }
11388 #ifdef DEBUG
11389 nfs4_pathconf_cache_hits++;
11390 #endif
11392 }
11394 }
11395 }
11396 #ifdef DEBUG
11397 nfs4_pathconf_cache_misses++;
11398 #endif
11410 }
11412 /* interpret the max filesize */
11416 /* Store the attributes we just received */
11439 }
11443 }
11446 }
11448 /*
11449 * Called by async thread to do synchronous pageio. Do the i/o, wait
11450 * for it to complete, and cleanup the page list when done.
11451 */
11452 static int
11455 {
11463 else
11466 }
11468 /* ARGSUSED */
11469 static int
11472 {
11489 nfs4_sync_pageio);
11497 }
11499 /* ARGSUSED */
11500 static void
11503 {
11508 offset3 offset;
11509 count3 len;
11510 k_sigset_t smask;
11512 /*
11513 * We should get called with fl equal to either B_FREE or
11514 * B_INVAL. Any other value is illegal.
11515 *
11516 * The page that we are either supposed to free or destroy
11517 * should be exclusive locked and its io lock should not
11518 * be held.
11519 */
11525 /*
11526 * If the page doesn't need to be committed or we shouldn't
11527 * even bother attempting to commit it, then just make sure
11528 * that the p_fsdata byte is clear and then either free or
11529 * destroy the page as appropriate.
11530 */
11535 else
11538 }
11540 /*
11541 * If there is a page invalidation operation going on, then
11542 * if this is one of the pages being destroyed, then just
11543 * clear the p_fsdata byte and then either free or destroy
11544 * the page as appropriate.
11545 */
11552 else
11555 }
11557 /*
11558 * If we are freeing this page and someone else is already
11559 * waiting to do a commit, then just unlock the page and
11560 * return. That other thread will take care of commiting
11561 * this page. The page can be freed sometime after the
11562 * commit has finished. Otherwise, if the page is marked
11563 * as delay commit, then we may be getting called from
11564 * pvn_write_done, one page at a time. This could result
11565 * in one commit per page, so we end up doing lots of small
11566 * commits instead of fewer larger commits. This is bad,
11567 * we want do as few commits as possible.
11568 */
11574 }
11580 }
11581 }
11583 /*
11584 * Check to see if there is a signal which would prevent an
11585 * attempt to commit the pages from being successful. If so,
11586 * then don't bother with all of the work to gather pages and
11587 * generate the unsuccessful RPC. Just return from here and
11588 * let the page be committed at some later time.
11589 */
11596 }
11599 /*
11600 * We are starting to need to commit pages, so let's try
11601 * to commit as many as possible at once to reduce the
11602 * overhead.
11603 *
11604 * Set the `commit inprogress' state bit. We must
11605 * first wait until any current one finishes. Then
11606 * we initialize the c_pages list with this page.
11607 */
11612 }
11620 /*
11621 * Gather together all other pages which can be committed.
11622 * They will all be chained off r_commit.c_pages.
11623 */
11626 /*
11627 * Clear the `commit inprogress' status and disconnect
11628 * the list of pages to be committed from the rnode.
11629 * At this same time, we also save the starting offset
11630 * and length of data to be committed on the server.
11631 */
11646 }
11648 /*
11649 * Actually generate the COMMIT op over the wire operation.
11650 */
11653 /*
11654 * If we got an error during the commit, just unlock all
11655 * of the pages. The pages will get retransmitted to the
11656 * server during a putpage operation.
11657 */
11663 }
11665 }
11667 /*
11668 * We've tried as hard as we can to commit the data to stable
11669 * storage on the server. We just unlock the rest of the pages
11670 * and clear the commit required state. They will be put
11671 * onto the tail of the cachelist if they are nolonger
11672 * mapped.
11673 */
11679 }
11681 /*
11682 * It is possible that nfs4_commit didn't return error but
11683 * some other thread has modified the page we are going
11684 * to free/destroy.
11685 * In this case we need to rewrite the page. Do an explicit check
11686 * before attempting to free/destroy the page. If modified, needs to
11687 * be rewritten so unlock the page and return.
11688 */
11693 }
11695 /*
11696 * Now, as appropriate, either free or destroy the page
11697 * that we were called with.
11698 */
11702 else
11704 }
11706 /*
11707 * Commit requires that the current fh be the file written to.
11708 * The compound op structure is:
11709 * PUTFH(file), COMMIT
11710 */
11711 static int
11713 {
11714 COMPOUND4args_clnt args;
11715 COMPOUND4res_clnt res;
11724 nfs4_recov_state_t recov_state;
11737 get_commit_cred:
11738 /*
11739 * Releases the osp, if a valid open stream is provided.
11740 * Puts a hold on the cred_otw and the new osp (if found).
11741 */
11745 recov_retry:
11746 /*
11747 * Commit ops: putfh file; commit
11748 */
11759 }
11761 /* putfh directory */
11765 /* commit */
11776 needrecov);
11783 }
11793 }
11801 }
11802 /* fall through for res.status case */
11803 }
11813 }
11814 /*
11815 * Can't do a nfs4_purge_stale_fh here because this
11816 * can cause a deadlock. nfs4_commit can
11817 * be called from nfs4_dispose which can be called
11818 * indirectly via pvn_vplist_dirty. nfs4_purge_stale_fh
11819 * can call back to pvn_vplist_dirty.
11820 */
11833 }
11848 }
11853 }
11862 }
11864 static void
11866 {
11869 /* make sure we're looking at the master vnode, not a shadow */
11871 }
11873 /*
11874 * This function is used to gather a page list of the pages which
11875 * can be committed on the server.
11876 *
11877 * The calling thread must have set R4COMMIT. This bit is used to
11878 * serialize access to the commit structure in the rnode. As long
11879 * as the thread has set R4COMMIT, then it can manipulate the commit
11880 * structure without requiring any other locks.
11881 *
11882 * When this function is called from nfs4_dispose() the page passed
11883 * into nfs4_dispose() will be SE_EXCL locked, and so this function
11884 * will skip it. This is not a problem since we initially add the
11885 * page to the r_commit page list.
11886 *
11887 */
11888 static void
11890 {
11898 /* make sure we're looking at the master vnode, not a shadow */
11905 /*
11906 * Step through all of the pages associated with this vnode
11907 * looking for pages which need to be committed.
11908 */
11912 /* Skip marker pages. */
11916 /*
11917 * First short-cut everything (without the page_lock)
11918 * and see if this page does not need to be committed
11919 * or is modified if so then we'll just skip it.
11920 */
11924 /*
11925 * Attempt to lock the page. If we can't, then
11926 * someone else is messing with it or we have been
11927 * called from nfs4_dispose and this is the page that
11928 * nfs4_dispose was called with.. anyway just skip it.
11929 */
11933 /*
11934 * Lets check again now that we have the page lock.
11935 */
11939 }
11941 /* this had better not be a free page */
11944 /*
11945 * The page needs to be committed and we locked it.
11946 * Update the base and length parameters and add it
11947 * to r_pages.
11948 */
11960 }
11962 }
11965 }
11967 /*
11968 * This routine is used to gather together a page list of the pages
11969 * which are to be committed on the server. This routine must not
11970 * be called if the calling thread holds any locked pages.
11971 *
11972 * The calling thread must have set R4COMMIT. This bit is used to
11973 * serialize access to the commit structure in the rnode. As long
11974 * as the thread has set R4COMMIT, then it can manipulate the commit
11975 * structure without requiring any other locks.
11976 */
11977 static void
11979 {
11983 uoff_t end;
11984 uoff_t off;
11991 /* make sure we're looking at the master vnode, not a shadow */
11996 /*
11997 * If there are no pages associated with this vnode, then
11998 * just return.
11999 */
12002 /*
12003 * Calculate the ending offset.
12004 */
12007 /*
12008 * Lookup each page by vp, offset.
12009 */
12012 /*
12013 * If this page does not need to be committed or is
12014 * modified, then just skip it.
12015 */
12019 }
12022 /*
12023 * The page needs to be committed and we locked it.
12024 * Update the base and length parameters and add it
12025 * to r_pages.
12026 */
12033 }
12035 }
12036 }
12038 /*
12039 * Called from nfs4_close(), nfs4_fsync() and nfs4_delmap().
12040 * Flushes and commits data to the server.
12041 */
12042 static int
12044 {
12046 verifier4 write_verf;
12051 /*
12052 * Flush the data portion of the file and then commit any
12053 * portions which need to be committed. This may need to
12054 * be done twice if the server has changed state since
12055 * data was last written. The data will need to be
12056 * rewritten to the server and then a new commit done.
12057 *
12058 * In fact, this may need to be done several times if the
12059 * server is having problems and crashing while we are
12060 * attempting to do this.
12061 */
12063 top:
12064 /*
12065 * Do a flush based on the poff and plen arguments. This
12066 * will synchronously write out any modified pages in the
12067 * range specified by (poff, plen). This starts all of the
12068 * i/o operations which will be waited for in the next
12069 * call to nfs4_putpage
12070 */
12080 /*
12081 * Do a flush based on the poff and plen arguments. This
12082 * will synchronously write out any modified pages in the
12083 * range specified by (poff, plen) and wait until all of
12084 * the asynchronous i/o's in that range are done as well.
12085 */
12096 }
12099 /*
12100 * Now commit any pages which might need to be committed.
12101 * If the error, NFS_VERF_MISMATCH, is returned, then
12102 * start over with the flush operation.
12103 */
12110 }
12112 /*
12113 * nfs4_commit_vp() will wait for other pending commits and
12114 * will either commit the whole file or a range, plen dictates
12115 * if we commit whole file. a value of zero indicates the whole
12116 * file. Called from nfs4_putpage_commit() or nfs4_sync_putapage()
12117 */
12118 static int
12121 {
12124 offset3 offset;
12125 count3 len;
12131 /*
12132 * before we gather commitable pages make
12133 * sure there are no outstanding async writes
12134 */
12139 }
12141 }
12143 /*
12144 * Set the `commit inprogress' state bit. We must
12145 * first wait until any current one finishes.
12146 */
12152 }
12156 /*
12157 * Gather all of the pages which need to be
12158 * committed.
12159 */
12162 else
12165 /*
12166 * Clear the `commit inprogress' bit and disconnect the
12167 * page list which was gathered by nfs4_get_commit.
12168 */
12178 /*
12179 * If any pages need to be committed, commit them and
12180 * then unlock them so that they can be freed some
12181 * time later.
12182 */
12186 /*
12187 * No error occurred during the flush portion
12188 * of this operation, so now attempt to commit
12189 * the data to stable storage on the server.
12190 *
12191 * This will unlock all of the pages on the list.
12192 */
12194 }
12196 static int
12199 {
12207 /*
12208 * If we got an error, then just unlock all of the pages
12209 * on the list.
12210 */
12216 }
12218 }
12219 /*
12220 * We've tried as hard as we can to commit the data to stable
12221 * storage on the server. We just unlock the pages and clear
12222 * the commit required state. They will get freed later.
12223 */
12229 }
12232 }
12234 static void
12237 {
12240 }
12242 /*ARGSUSED*/
12243 static int
12246 {
12249 vattr_t va;
12250 vsecattr_t nfsace4_vsap;
12256 /* if we have a delegation, return it */
12262 NFS4_ACL_SET);
12267 /*
12268 * These are aclent_t type entries.
12269 */
12275 /*
12276 * These are ace_t type entries.
12277 */
12279 FALSE);
12282 }
12287 }
12289 }
12291 /* ARGSUSED */
12292 int
12295 {
12298 nfs4_ga_res_t gar;
12308 /*
12309 * vsecattr->vsa_mask holds the original acl request mask.
12310 * This is needed when determining what to return.
12311 * (See: nfs4_create_getsecattr_return())
12312 */
12317 /*
12318 * If this is a referral stub, don't try to go OTW for an ACL
12319 */
12324 /*
12325 * Check if the data is cached and the cache is valid. If it
12326 * is we don't go over the wire.
12327 */
12338 }
12339 }
12341 }
12343 /*
12344 * The getattr otw call will always get both the acl, in
12345 * the form of a list of nfsace4's, and the number of acl
12346 * entries; independent of the value of gar.n4g_va.va_mask.
12347 */
12354 }
12357 /*
12358 * No error was returned, but according to the response
12359 * bitmap, neither was an acl.
12360 */
12364 }
12366 /*
12367 * Update the cache with the ACL.
12368 */
12379 }
12381 }
12384 }
12386 /*
12387 * The function returns:
12388 * - 0 (zero) if the passed in "acl_mask" is a valid request.
12389 * - EINVAL if the passed in "acl_mask" is an invalid request.
12390 *
12391 * In the case of getting an acl (op == NFS4_ACL_GET) the mask is invalid if:
12392 * - We have a mixture of ACE and ACL requests (e.g. VSA_ACL | VSA_ACE)
12393 *
12394 * In the case of setting an acl (op == NFS4_ACL_SET) the mask is invalid if:
12395 * - We have a mixture of ACE and ACL requests (e.g. VSA_ACL | VSA_ACE)
12396 * - We have a count field set without the corresponding acl field set. (e.g. -
12397 * VSA_ACECNT is set, but VSA_ACE is not)
12398 */
12399 static int
12401 {
12402 /* Shortcut the masks that are always valid. */
12409 /*
12410 * We can't have any VSA_ACL type stuff in the mask now.
12411 */
12413 VSA_DFACLCNT))
12419 }
12420 }
12423 /*
12424 * We can't have any VSA_ACE type stuff in the mask now.
12425 */
12436 }
12437 }
12439 }
12441 /*
12442 * The theory behind creating the correct getsecattr return is simply this:
12443 * "Don't return anything that the caller is not expecting to have to free."
12444 */
12445 static int
12448 {
12450 /* Save the mask since the translators modify it. */
12459 /*
12460 * If the caller only asked for the ace count (VSA_ACECNT)
12461 * don't give them the full acl (VSA_ACE), free it.
12462 */
12468 }
12469 }
12473 VSA_DFACLCNT)) {
12480 /*
12481 * If the caller only asked for the acl count (VSA_ACLCNT)
12482 * and/or the default acl count (VSA_DFACLCNT) don't give them
12483 * the acl (VSA_ACL) or default acl (VSA_DFACL), free it.
12484 */
12490 }
12491 }
12498 }
12499 }
12501 }
12503 }
12505 /* ARGSUSED */
12506 int
12509 {
12514 /*
12515 * check for valid cmd parameter
12516 */
12520 /*
12521 * Check access permissions
12522 */
12528 /*
12529 * If the filesystem is mounted using local locking, pass the
12530 * request off to the local share code.
12531 */
12538 /*
12539 * This will be properly implemented later,
12540 * see RFE: 4823948 .
12541 */
12546 /*
12547 * NFS client can't store remote locks itself
12548 */
12556 }
12559 }
12561 /*
12562 * Common code called by directory ops to update the attrcache
12563 */
12564 static int
12567 {
12573 /* getattr not done or failed */
12576 }
12582 }
12584 }
12586 /*
12587 * Update directory caches for directory modification ops (link, rename, etc.)
12588 * When dinfo is NULL, manage dircaches in the old way.
12589 */
12590 static void
12593 {
12598 /* Purge rddir cache for dir since it changed */
12602 /*
12603 * If caller provided dinfo, then use it to manage dir caches.
12604 */
12612 /*
12613 * XXX don't update if the created_v4 flag is
12614 * set
12615 */
12620 }
12621 }
12627 }
12629 /*
12630 * Caller didn't provide dinfo, then check change_info4 to update DNLC.
12631 * Since caller modified dir but didn't receive post-dirmod-op dir
12632 * attrs, the dir's attrs must be purged.
12633 *
12634 * XXX this check and dnlc update/purge should really be atomic,
12635 * XXX but can't use rnode statelock because it'll deadlock in
12636 * XXX dnlc_purge_vp, however, the risk is minimal even if a race
12637 * XXX does occur.
12638 *
12639 * XXX We also may want to check that atomic is true in the
12640 * XXX change_info struct. If it is not, the change_info may
12641 * XXX reflect changes by more than one clients which means that
12642 * XXX our cache may not be valid.
12643 */
12646 /* no changes took place in the directory prior to our link */
12653 /*
12654 * XXX dont' update if the created_v4 flag
12655 * is set
12656 */
12659 "nfs4_update_dircaches: don't"
12661 }
12662 }
12664 /* Another client modified directory - purge its dnlc cache */
12666 }
12667 }
12669 /*
12670 * The OPEN_CONFIRM operation confirms the sequence number used in OPENing a
12671 * file.
12672 *
12673 * The 'reopening_file' boolean should be set to TRUE if we are reopening this
12674 * file (ie: client recovery) and otherwise set to FALSE.
12675 *
12676 * 'nfs4_start/end_op' should have been called by the proper (ie: not recovery
12677 * initiated) calling functions.
12678 *
12679 * 'resend' is set to TRUE if this is a OPEN_CONFIRM issued as a result
12680 * of resending a 'lost' open request.
12681 *
12682 * 'num_bseqid_retryp' makes sure we don't loop forever on a broken
12683 * server that hands out BAD_SEQID on open confirm.
12684 *
12685 * Errors are returned via the nfs4_error_t parameter.
12686 */
12687 void
12691 {
12692 COMPOUND4args_clnt args;
12693 COMPOUND4res_clnt res;
12702 #if DEBUG
12706 #endif
12708 recov_retry_confirm:
12714 else
12720 /* putfh target fh */
12737 }
12761 }
12762 }
12771 }
12772 /* State may have changed so retry the entire OPEN op */
12775 else
12780 }
12785 }
12792 }
12794 /*
12795 * Return the credentials associated with a client state object. The
12796 * caller is responsible for freeing the credentials.
12797 */
12801 {
12804 /*
12805 * It's ok to not lock the open stream and open owner to get
12806 * the oo_cred since this is only written once (upon creation)
12807 * and will not change.
12808 */
12813 }
12815 /*
12816 * nfs4_find_sysid
12817 *
12818 * Find the sysid for the knetconfig associated with the given mi.
12819 */
12822 {
12825 /*
12826 * Switch from RDMA knconf to original mount knconf
12827 */
12830 }
12832 #ifdef DEBUG
12833 /*
12834 * Return a string version of the call type for easy reading.
12835 */
12838 {
12852 }
12853 }
12854 #endif
12856 /*
12857 * Map the frlock cmd and lock type to the NFSv4 over-the-wire lock type
12858 * Unlock requests don't have an over-the-wire locktype, so we just return
12859 * something non-threatening.
12860 */
12862 static nfs_lock_type4
12864 {
12873 else
12878 else
12880 }
12882 /*NOTREACHED*/
12883 }
12885 /*
12886 * Do some preliminary checks for nfs4frlock.
12887 */
12888 static int
12890 uoff_t offset)
12891 {
12894 /*
12895 * If we are setting a lock, check that the file is opened
12896 * with the correct mode.
12897 */
12902 "nfs4frlock_validate_args: file was opened with "
12905 }
12906 }
12908 /* Convert the offset. It may need to be restored before returning. */
12912 error));
12914 }
12917 }
12919 /*
12920 * Set the flock64's lm_sysid for nfs4frlock.
12921 */
12922 static int
12924 {
12927 /* Find the lm_sysid */
12934 }
12939 }
12941 /*
12942 * Do the remaining preliminary setup for nfs4frlock.
12943 */
12944 static void
12948 {
12949 /*
12950 * set tick_delay to the base delay time.
12951 * (NFS4_BASE_WAIT_TIME is in secs)
12952 */
12956 /*
12957 * If lock is relative to EOF, we need the newest length of the
12958 * file. Therefore invalidate the ATTR_CACHE.
12959 */
12969 }
12971 /*
12972 * Initialize and allocate the data structures necessary for
12973 * the nfs4frlock call.
12974 * Allocates argsp's op array.
12975 */
12976 static void
12981 {
12990 /* fill array with zero */
12999 /* initialize in case of error; will get real value down below */
13004 else
13006 }
13008 /*
13009 * Call the nfs4_start_fop() for nfs4frlock, if necessary. Assign
13010 * the proper nfs4_server_t for this instance of nfs4frlock.
13011 * Returns 0 (success) or an errno value.
13012 */
13013 static int
13017 {
13032 }
13037 /* If the file failed recovery, just quit. */
13041 }
13043 }
13046 }
13048 /*
13049 * Setup the LOCK4/LOCKU4 arguments for resending a lost lock request. A
13050 * resend nfs4frlock call is initiated by the recovery framework.
13051 * Acquires the lop and oop seqid synchronization.
13052 */
13053 static void
13058 {
13074 }
13076 /* Must resend this lost lock/locku request. */
13115 }
13142 }
13143 }
13144 }
13146 /*
13147 * Setup the LOCKT4 arguments.
13148 */
13149 static void
13153 {
13162 /*
13163 * The locktype will be READ_LT unless it's
13164 * a write lock. We do this because the Solaris
13165 * system call allows the combination of
13166 * F_UNLCK and F_GETLK* and so in that case the
13167 * unlock is mapped to a read.
13168 */
13171 else
13175 /* set the lock owner4 args */
13185 }
13187 /*
13188 * If the client is holding a delegation, and the open stream to be used
13189 * with this lock request is a delegation open stream, then re-open the stream.
13190 * Sets the nfs4_error_t to all zeros unless the open stream has already
13191 * failed a reopen or we couldn't find the open stream. NFS4ERR_DELAY
13192 * means the caller should retry (like a recovery retry).
13193 */
13194 static void
13196 {
13197 open_delegation_type4 dt;
13200 open_claim_type4 oclaim;
13219 }
13220 /* returns with 'os_sync_lock' held */
13226 }
13231 "nfs4frlock_check_deleg: os_failed_reopen set "
13239 }
13241 /*
13242 * Determine whether a reopen is needed. If this
13243 * is a delegation open stream, then send the open
13244 * to the server to give visibility to the open owner.
13245 * Even if it isn't a delegation open stream, we need
13246 * to check if the previous open CLAIM_DELEGATE_CUR
13247 * was sufficient.
13248 */
13260 /*
13261 * Always use CLAIM_PREVIOUS after server reboot.
13262 * The server will reject CLAIM_DELEGATE_CUR if
13263 * it is used during the grace period.
13264 */
13272 }
13279 }
13280 }
13283 }
13284 }
13286 /*
13287 * Setup the LOCKU4 arguments.
13288 * Returns errors via the nfs4_error_t.
13289 * NFS4_OK no problems. *go_otwp is TRUE if call should go
13290 * over-the-wire. The caller must release the
13291 * reference on *lopp.
13292 * NFS4ERR_DELAY caller should retry (like recovery retry)
13293 * (other) unrecoverable error.
13294 */
13295 static void
13301 {
13304 pid_t pid;
13318 else
13323 /* locktype should be set to any legal value */
13329 /*
13330 * Get the lock owner stateid. If no lock owner
13331 * exists, return success.
13332 */
13338 /*
13339 * No lock owner so no locks to unlock.
13340 * Return success. If there was a failed
13341 * reclaim earlier, the lock might still be
13342 * registered with the local locking code,
13343 * so notify it of the unlock.
13344 *
13345 * If the lockowner is using a special stateid,
13346 * then the original lock request (that created
13347 * this lockowner) was never successful, so we
13348 * have no lock to undo OTW.
13349 */
13351 "nfs4frlock_setup_locku_args: LOCKU: no lock owner "
13357 /*
13358 * Release our hold and NULL out so final_cleanup
13359 * doesn't try to end a lock seqid sync we
13360 * never started.
13361 */
13365 }
13369 }
13376 }
13383 /* leave the ref count on lop, rele after RPC call */
13391 }
13393 /*
13394 * Setup the LOCK4 arguments.
13395 *
13396 * Returns errors via the nfs4_error_t.
13397 * NFS4_OK no problems
13398 * NFS4ERR_DELAY caller should retry (like recovery retry)
13399 * (other) unrecoverable error
13400 */
13401 static void
13406 {
13411 pid_t pid;
13425 else
13430 /*
13431 * Get the lock owner. If no lock owner exists,
13432 * create a 'temporary' one and grab the open seqid
13433 * synchronization (which puts a hold on the open
13434 * owner and open stream).
13435 * This also grabs the lock seqid synchronization.
13436 */
13452 out:
13456 }
13458 /*
13459 * After we get the reply from the server, record the proper information
13460 * for possible resend lock requests.
13461 */
13462 static void
13467 {
13477 "nfs4frlock_save_lost_rqst: set lo_pending_rqsts to 1 "
13483 }
13488 /*
13489 * For lock/locku requests, we treat EINTR as ETIMEDOUT for
13490 * recovery purposes so that the lock request that was sent
13491 * can be saved and re-issued later. Ditto for EIO from a forced
13492 * unmount. This is done to have the client's local locking state
13493 * match the v4 server's state; that is, the request was
13494 * potentially received and accepted by the server but the client
13495 * thinks it was not.
13496 */
13501 "nfs4frlock_save_lost_rqst: got a lost %s lock for "
13509 }
13510 /*
13511 * Objects are held and rele'd via the recovery code.
13512 * See nfs4_save_lost_rqst.
13513 */
13531 }
13533 }
13534 }
13536 /*
13537 * Update lop's seqid. Also update the seqid stored in a resend request,
13538 * if any. (Some recovery errors increment the seqid, and we may have to
13539 * send the resend request again.)
13540 */
13542 static void
13545 {
13552 }
13556 }
13557 }
13559 /*
13560 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13561 * COMPOUND4 args/res for calls that need to retry.
13562 * Switches the *cred_otwp to base_cr.
13563 */
13564 static void
13570 {
13578 needrecov);
13580 }
13596 }
13598 /* need to free up the reference on osp for lock args */
13602 }
13604 /* need to free up the reference on oop for lock args */
13609 }
13614 }
13616 /*
13617 * Function to process the client's recovery for nfs4frlock.
13618 * Returns TRUE if we should retry the lock request; FALSE otherwise.
13619 *
13620 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13621 * COMPOUND4 args/res for calls that need to retry.
13622 *
13623 * Note: the rp's r_lkserlock is *not* dropped during this path.
13624 */
13625 static bool_t
13633 {
13653 nfs_opnum4 op;
13658 seqid4 seqid;
13664 else
13671 }
13675 }
13684 }
13686 /*
13687 * Return that we do not want to retry the request for 3 cases:
13688 * 1. If we received EINTR or are bailing out because of a forced
13689 * unmount, we came into this code path just for the sake of
13690 * initiating recovery, we now need to return the error.
13691 * 2. If we have aborted recovery.
13692 * 3. We received NFS4ERR_BAD_SEQID.
13693 */
13700 needrecov);
13702 }
13719 }
13724 }
13728 /* need to free up the reference on osp for lock args */
13732 }
13734 /* need to free up the reference on oop for lock args */
13739 }
13742 }
13744 /*
13745 * Handles the successful reply from the server for nfs4frlock.
13746 */
13747 static void
13751 {
13757 /*
13758 * We do not register lost locks locally in
13759 * the 'resend' case since the user/application
13760 * doesn't think we have the lock.
13761 */
13764 }
13765 }
13766 }
13768 /*
13769 * Handle the DENIED reply from the server for nfs4frlock.
13770 * Returns TRUE if we should retry the request; FALSE otherwise.
13771 *
13772 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13773 * COMPOUND4 args/res for calls that need to retry. Can also
13774 * drop and regrab the r_lkserlock.
13775 */
13776 static bool_t
13786 {
13795 /*
13796 * Blocking lock needs to sleep and retry from the request.
13797 *
13798 * Do not block and wait for 'resend' or 'reinstate'
13799 * lock requests, just return the error.
13800 *
13801 * Note: reclaim requests have cmd == F_SETLK, not F_SETLKW.
13802 */
13829 }
13834 }
13845 }
13850 /*
13851 * Make sure we are still safe to lock with
13852 * regards to mmapping.
13853 */
13857 }
13860 }
13874 /* according to NLM code */
13879 }
13881 }
13883 /*
13884 * Handles all NFS4 errors besides NFS4_OK and NFS4ERR_DENIED for nfs4frlock.
13885 */
13886 static void
13888 {
13922 "nfs4frlock_results_default: got unrecognizable "
13925 }
13926 }
13928 /*
13929 * The lock request was successful, so update the client's state.
13930 */
13931 static void
13936 {
13943 /* update the stateid with server's response */
13949 }
13953 /*
13954 * If the lock was the result of a resending a lost
13955 * request, we've synched up the stateid and seqid
13956 * with the server, but now the server might be out of sync
13957 * with what the application thinks it has for locks.
13958 * Clean that up here. It's unclear whether we should do
13959 * this even if the filesystem has been forcibly unmounted.
13960 * For most servers, it's probably wasted effort, but
13961 * RFC 7530 lets servers require that unlocks exactly match
13962 * the locks that are held.
13963 */
13969 }
13975 /* Update the stateid with the server's response */
13978 /* Switch the lock type to express success, see fcntl */
13981 }
13982 }
13984 /*
13985 * Do final cleanup before exiting nfs4frlock.
13986 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13987 * COMPOUND4 args/res for calls that haven't already.
13988 */
13989 static void
13998 {
14006 /*
14007 * The client recovery code wants the raw status information,
14008 * so don't map the NFS status code to an errno value for
14009 * non-normal call types.
14010 */
14016 needrecov);
14018 /*
14019 * We've established a new lock on the server, so invalidate
14020 * the pages associated with the vnode to get the most up to
14021 * date pages from the server after acquiring the lock. We
14022 * want to be sure that the read operation gets the newest data.
14023 * N.B.
14024 * We used to do this in nfs4frlock_results_ok but that doesn't
14025 * work since fop_putpage can call nfs4_commit which calls
14026 * nfs4_start_fop. We flush the pages below after calling
14027 * nfs4_end_fop above
14028 * The flush of the page cache must be done after
14029 * nfs4_end_open_seqid_sync() to avoid a 4-way hang.
14030 */
14033 }
14044 }
14046 /* free the reference on the lock owner */
14050 }
14052 /* need to free up the reference on osp for lock args */
14056 /* need to free up the reference on oop for lock args */
14060 }
14069 /*
14070 * Record debug information in the event we get EINVAL.
14071 */
14077 "%s operation failed with "
14078 "EINVAL probably since the server, %s,"
14083 }
14084 }
14089 }
14091 /*
14092 * This calls the server and the local locking code.
14093 *
14094 * Client locks are registerred locally by oring the sysid with
14095 * LM_SYSID_CLIENT. The server registers locks locally using just the sysid.
14096 * We need to distinguish between the two to avoid collision in case one
14097 * machine is used as both client and server.
14098 *
14099 * Blocking lock requests will continually retry to acquire the lock
14100 * forever.
14101 *
14102 * The ctype is defined as follows:
14103 * NFS4_LCK_CTYPE_NORM: normal lock request.
14104 *
14105 * NFS4_LCK_CTYPE_RECLAIM: bypass the usual calls for synchronizing with client
14106 * recovery, get the pid from flk instead of curproc, and don't reregister
14107 * the lock locally.
14108 *
14109 * NFS4_LCK_CTYPE_RESEND: same as NFS4_LCK_CTYPE_RECLAIM, with the addition
14110 * that we will use the information passed in via resend_rqstp to setup the
14111 * lock/locku request. This resend is the exact same request as the 'lost
14112 * lock', and is initiated by the recovery framework. A successful resend
14113 * request can initiate one or more reinstate requests.
14114 *
14115 * NFS4_LCK_CTYPE_REINSTATE: same as NFS4_LCK_CTYPE_RESEND, except that it
14116 * does not trigger additional reinstate requests. This lock call type is
14117 * set for setting the v4 server's locking state back to match what the
14118 * client's local locking state is in the event of a received 'lost lock'.
14119 *
14120 * Errors are returned via the nfs4_error_t parameter.
14121 */
14122 void
14126 {
14142 nfs4_recov_state_t recov_state;
14144 nfs4_op_hint_t op_hint;
14145 nfs4_lost_rqst_t lost_rqst;
14152 #ifdef DEBUG
14154 #endif
14158 #ifdef DEBUG
14168 #endif
14180 recov_retry:
14192 /*
14193 * Leave the request for the recovery system to deal with.
14194 */
14212 }
14216 }
14218 /* putfh directory fh */
14222 /*
14223 * Set up the over-the-wire arguments and get references to the
14224 * open owner, etc.
14225 */
14249 else
14261 /* recov thread never gets this error */
14278 }
14285 }
14289 }
14291 /* XXX should we use the local reclock as a cache ? */
14292 /*
14293 * Unregister the lock with the local locking code before
14294 * contacting the server. This avoids a potential race where
14295 * another process gets notified that it has been granted a lock
14296 * before we can unregister ourselves locally.
14297 */
14302 }
14304 /*
14305 * Send the server the lock request. Continually loop with a delay
14306 * if get error NFS4ERR_DENIED (for blocking locks) or NFS4ERR_GRACE.
14307 */
14322 }
14324 /*
14325 * Do the OTW call.
14326 */
14340 /*
14341 * Check if one of these mutually exclusive error cases has
14342 * happened:
14343 * need to swap credentials due to access error
14344 * recovery is needed
14345 * different error (only known case is missing Kerberos ticket)
14346 */
14355 }
14358 /*
14359 * LOCKT requests don't need to recover from lost
14360 * requests since they don't create/modify state.
14361 */
14364 lockt_args)
14366 /*
14367 * Do not attempt recovery for requests initiated by
14368 * the recovery framework. Let the framework redrive them.
14369 */
14374 }
14390 }
14392 }
14394 /*
14395 * Bail out if have reached this point with ep->error set. Can
14396 * happen if (ep->error == EACCES && !needrecov && cred_otw == cr).
14397 * This happens if Kerberos ticket has expired or has been
14398 * destroyed.
14399 */
14403 /*
14404 * Process the reply.
14405 */
14410 resend_rqstp);
14411 /*
14412 * Have a successful lock operation, now update state.
14413 */
14431 }
14433 /*
14434 * If the server won't let us reclaim, fall-back to trying to lock
14435 * the file from scratch. Code elsewhere will check the changeinfo
14436 * to ensure the file hasn't been changed.
14437 */
14444 /* clean up before retrying */
14450 }
14451 /* FALLTHROUGH */
14456 }
14457 out:
14458 /*
14459 * Process and cleanup from error. Make interrupted unlock
14460 * requests look successful, since they will be handled by the
14461 * client recovery code.
14462 */
14471 }
14473 /*
14474 * nfs4_safelock:
14475 *
14476 * Return non-zero if the given lock request can be handled without
14477 * violating the constraints on concurrent mapping and locking.
14478 */
14480 static int
14482 {
14497 /*
14498 * If the file is already mapped and there are locks, then they
14499 * should be all safe locks. So adding or removing a lock is safe
14500 * as long as the new request is safe (i.e., whole-file, meaning
14501 * length and starting offset are both zero).
14502 */
14506 "cannot lock a memory mapped file unless locking the "
14510 }
14512 /* mandatory locking and mapping don't mix */
14519 }
14524 }
14527 }
14530 /*
14531 * Register the lock locally within Solaris.
14532 * As the client, we "or" the sysid with LM_SYSID_CLIENT when
14533 * recording locks locally.
14534 *
14535 * This should handle conflicts/cooperation with NFS v2/v3 since all locks
14536 * are registered locally.
14537 */
14538 void
14540 uoff_t offset)
14541 {
14544 #ifdef DEBUG
14546 #endif
14550 #ifdef DEBUG
14558 #endif
14560 /* register the lock with local locking */
14564 #ifdef DEBUG
14567 "nfs4_register_lock_locally: could not register with"
14577 "blocked by pid %d sysid 0x%x type %d "
14581 }
14582 #endif
14584 }
14586 /*
14587 * nfs4_lockrelease:
14588 *
14589 * Release any locks on the given vnode that are held by the current
14590 * process. Also removes the lock owner (if one exists) from the rnode's
14591 * list.
14592 */
14593 static int
14595 {
14596 flock64_t ld;
14600 nfs4_recov_state_t recov_state;
14603 bool_t recovonly;
14611 /*
14612 * If we have not locked anything then we can
14613 * just return since we have no work to do.
14614 */
14617 }
14619 /*
14620 * We need to comprehend that another thread may
14621 * kick off recovery and the lock_owner we have stashed
14622 * in lop might be invalid so we should NOT cache it
14623 * locally!
14624 */
14634 }
14638 /*
14639 * Check if the lock owner might have a lock (request was sent but
14640 * no response was received). Also check if there are any remote
14641 * locks on the file. (In theory we shouldn't have to make this
14642 * second check if there's no lock owner, but for now we'll be
14643 * conservative and do it anyway.) If either condition is true,
14644 * send an unlock for the entire file to the server.
14645 *
14646 * Note that no explicit synchronization is needed here. At worst,
14647 * flk_has_remote_locks() will return a false positive, in which case
14648 * the unlock call wastes time but doesn't harm correctness.
14649 */
14656 }
14661 "nfs4_lockrelease: possible orphan %d, remote locks %d, for "
14675 /*
14676 * If fop_frlock fails, make sure we unregister
14677 * local locks before we continue.
14678 */
14682 "nfs4_lockrelease: lock release error on vp"
14684 }
14685 }
14696 }
14698 /*
14699 * So, here we're going to need to retrieve the lock-owner
14700 * again (in case recovery has done a switch-a-roo) and
14701 * remove it because we can.
14702 */
14708 }
14712 }
14714 /*
14715 * Wait for 'tick_delay' clock ticks.
14716 * Implement exponential backoff until hit the lease_time of this nfs4_server.
14717 * NOTE: lock_lease_time is in seconds.
14718 *
14719 * XXX For future improvements, should implement a waiting queue scheme.
14720 */
14721 static int
14723 {
14727 /* wait tick_delay clock ticks or siginteruptus */
14730 }
14732 "reissue the lock request: blocked for %ld clock ticks: %ld "
14735 /* get the lease time */
14738 /* drv_hztousec converts ticks to microseconds */
14744 }
14746 }
14749 void
14751 {
14752 }
14754 void
14756 {
14757 }
14759 /*
14760 * Return a reference to the directory (parent) vnode for a given vnode,
14761 * using the saved pathname information and the directory file handle. The
14762 * caller is responsible for disposing of the reference.
14763 * Returns zero or an errno value.
14764 *
14765 * Caller should set need_start_op to FALSE if it is the recovery
14766 * thread, or if a start_fop has already been done. Otherwise, TRUE.
14767 */
14768 int
14770 {
14781 nfs_fh4 fh;
14802 }
14810 }
14816 }
14824 }
14829 }
14837 }
14840 }
14842 /*
14843 * Copy the (final) component name of vp to fnamep. maxlen is the maximum
14844 * length that fnamep can accept, including the trailing null.
14845 * Returns 0 if okay, returns an errno value if there was a problem.
14846 */
14848 int
14850 {
14856 /*
14857 * If the file being opened has VROOT set, then this is
14858 * a "file" mount. sv_name will not be interesting, so
14859 * go back to the servinfo4 to get the original mount
14860 * path and strip off all but the final edge. Otherwise
14861 * just return the name from the shadow vnode.
14862 */
14872 else
14873 fn++;
14877 }
14882 else
14887 else
14891 }
14893 /*
14894 * Bookkeeping for a close that doesn't need to go over the wire.
14895 * *have_lockp is set to 0 if 'os_sync_lock' is released; otherwise
14896 * it is left at 1.
14897 */
14898 void
14900 {
14916 }
14918 /*
14919 * This removes the reference obtained at OPEN; ie,
14920 * when the open stream structure was created.
14921 *
14922 * We don't have to worry about calling 'open_stream_rele'
14923 * since we our currently holding a reference to this
14924 * open stream which means the count can not go to 0 with
14925 * this decrement.
14926 */
14934 }
14936 /*
14937 * Close all remaining open streams on the rnode. These open streams
14938 * could be here because:
14939 * - The close attempted at either close or delmap failed
14940 * - Some kernel entity did fop_open but never did fop_close
14941 * - Someone did mknod on a regular file but never opened it
14942 */
14943 int
14945 {
14956 /*
14957 * At this point, all we know is that the last time
14958 * someone called vn_rele, the count was 1. Since then,
14959 * the vnode could have been re-activated. We want to
14960 * loop through the open streams and close each one, but
14961 * we have to be careful since once we release the rnode
14962 * hash bucket lock, someone else is free to come in and
14963 * re-activate the rnode and add new open streams. The
14964 * strategy is take the rnode hash bucket lock, verify that
14965 * the count is still 1, grab the open stream off the
14966 * head of the list and mark it invalid, then release the
14967 * rnode hash bucket lock and proceed with that open stream.
14968 * This is ok because nfs4close_one() will acquire the proper
14969 * open/create to close/destroy synchronization for open
14970 * streams, and will ensure that if someone has reopened
14971 * the open stream after we've dropped the hash bucket lock
14972 * then we'll just simply return without destroying the
14973 * open stream.
14974 * Repeat until the list is empty.
14975 */
14979 /* make sure vnode hasn't been reactivated */
14986 }
14987 /*
14988 * Grabbing r_os_lock before releasing v_lock prevents
14989 * a window where the rnode/open stream could get
14990 * reactivated (and os_force_close set to 0) before we
14991 * had a chance to set os_force_close to 1.
14992 */
14998 /* nothing left to CLOSE OTW, so return */
15002 }
15005 /* the file can't still be mem mapped */
15011 /*
15012 * Grab a ref on this open stream; nfs4close_one
15013 * will mark it as invalid
15014 */
15024 /* Update error if it isn't already non-zero */
15030 }
15032 #ifdef DEBUG
15033 nfs4close_all_cnt++;
15034 #endif
15035 /* Release the ref on osp acquired above. */
15038 /* Proceed to the next open stream, if any */
15039 }
15041 }
15043 /*
15044 * nfs4close_one - close one open stream for a file if needed.
15045 *
15046 * "close_type" indicates which close path this is:
15047 * CLOSE_NORM: close initiated via fop_close.
15048 * CLOSE_DELMAP: close initiated via fop_delmap.
15049 * CLOSE_FORCE: close initiated via fop_inactive. This path forces
15050 * the close and release of client state for this open stream
15051 * (unless someone else has the open stream open).
15052 * CLOSE_RESEND: indicates the request is a replay of an earlier request
15053 * (e.g., due to abort because of a signal).
15054 * CLOSE_AFTER_RESEND: close initiated to "undo" a successful resent OPEN.
15055 *
15056 * CLOSE_RESEND and CLOSE_AFTER_RESEND will not attempt to retry after client
15057 * recovery. Instead, the caller is expected to deal with retries.
15058 *
15059 * The caller can either pass in the osp ('provided_osp') or not.
15060 *
15061 * 'access_bits' represents the access we are closing/downgrading.
15062 *
15063 * 'len', 'prot', and 'mmap_flags' are used for CLOSE_DELMAP. 'len' is the
15064 * number of bytes we are unmapping, 'maxprot' is the mmap protection, and
15065 * 'mmap_flags' tells us the type of sharing (MAP_PRIVATE or MAP_SHARED).
15066 *
15067 * Errors are returned via the nfs4_error_t.
15068 */
15069 void
15073 uint_t mmap_flags)
15074 {
15081 nfs4_recov_state_t recov_state;
15106 /*
15107 * First get the open owner.
15108 */
15115 }
15119 "nfs4close_one: no oop, rp %p, mi %p, cr %p, osp %p, "
15124 }
15127 recov_retry:
15140 /*
15141 * Second synchronize with recovery.
15142 */
15150 /*
15151 * If we couldn't get start_fop, but have to
15152 * cleanup state, then at least acquire the
15153 * mi_recovlock so we can synchronize with
15154 * recovery.
15155 */
15162 }
15163 }
15165 /*
15166 * We cannot attempt to get the open seqid sync if nfs4_start_fop
15167 * set 'recovonly' to TRUE since most likely this is due to
15168 * reovery being active (MI4_RECOV_ACTIV). If recovery is active,
15169 * nfs4_start_open_seqid_sync() will fail with EAGAIN asking us
15170 * to retry, causing us to loop until recovery finishes. Plus we
15171 * don't need protection over the open seqid since we're not going
15172 * OTW, hence don't need to use the seqid.
15173 */
15175 /* need to grab the open owner sync before 'os_sync_lock' */
15185 }
15187 }
15189 /*
15190 * Third get an open stream and acquire 'os_sync_lock' to
15191 * sychronize the opening/creating of an open stream with the
15192 * closing/destroying of an open stream.
15193 */
15195 /* returns with 'os_sync_lock' held */
15200 }
15205 }
15210 /*
15211 * Fourth, do any special pre-OTW CLOSE processing
15212 * based on the specific close type.
15213 */
15221 }
15224 /* see if somebody reopened the open stream. */
15227 "nfs4close_one: skip CLOSE_FORCE as osp %p "
15232 }
15237 }
15239 /*
15240 * We can't depend on os_open_ref_count being 0 due to the
15241 * way executables are opened (VN_RELE to match a fop_open).
15242 */
15243 #ifdef NOTYET
15245 #endif
15248 "nfs4close_one: should panic here on an "
15249 "ASSERT(osp->os_open_ref_count == 0). Ignoring "
15253 }
15255 /*
15256 * There is the possibility that nfs4close_one()
15257 * for close_type == CLOSE_DELMAP couldn't find the
15258 * open stream, thus couldn't decrement its os_mapcnt;
15259 * therefore we can't use this ASSERT yet.
15260 */
15261 #ifdef NOTYET
15263 #endif
15265 }
15276 /* mirror the PROT_NONE check in nfs4_addmap() */
15282 }
15285 nfs4_lost_rqst_t lost_rqst;
15287 /* request should not already be in recovery queue */
15300 }
15302 /*
15303 * If a previous OTW call got NFS4ERR_BAD_SEQID, then
15304 * we stopped operating on the open owner's <old oo_name, old seqid>
15305 * space, which means we stopped operating on the open stream
15306 * too. So don't go OTW (as the seqid is likely bad, and the
15307 * stateid could be stale, potentially triggering a false
15308 * setclientid), and just clean up the client's internal state.
15309 */
15318 }
15320 /* If the file failed recovery, just quit. */
15324 }
15327 /*
15328 * If the force close path failed to obtain start_fop
15329 * then skip the OTW close and just remove the state.
15330 */
15334 /*
15335 * Fifth, check to see if there are still mapped pages or other
15336 * opens using this open stream. If there are then we can't
15337 * close yet but we can see if an OPEN_DOWNGRADE is necessary.
15338 */
15340 nfs4_lost_rqst_t new_lost_rqst;
15346 /*
15347 * If this open stream was never OPENed OTW then we
15348 * surely can't DOWNGRADE it (especially since the
15349 * osp->open_stateid is really a delegation stateid
15350 * when os_delegation is 1).
15351 */
15359 }
15364 bool_t abort;
15371 open_dg_seqid);
15392 }
15405 }
15407 }
15409 /*
15410 * If this open stream was created as the results of an open
15411 * while holding a delegation, then just release it; no need
15412 * to do an OTW close. Otherwise do a "normal" OTW close.
15413 */
15418 }
15420 /*
15421 * If this stream is not valid, we're done.
15422 */
15426 }
15428 /*
15429 * Last open or mmap ref has vanished, need to do an OTW close.
15430 * First check to see if a close is still necessary.
15431 */
15436 /*
15437 * Reopen of the open stream failed, hence the
15438 * stateid of the open stream is invalid/stale, and
15439 * sending this OTW would incorrectly cause another
15440 * round of recovery. In this case, we need to set
15441 * the 'os_valid' bit to 0 so another thread doesn't
15442 * come in and re-open this open stream before
15443 * this "closing" thread cleans up state (decrementing
15444 * the nfs4_server_t's state_ref_count and decrementing
15445 * the os_ref_count).
15446 */
15448 /*
15449 * This removes the reference obtained at OPEN; ie,
15450 * when the open stream structure was created.
15451 *
15452 * We don't have to worry about calling 'open_stream_rele'
15453 * since we our currently holding a reference to this
15454 * open stream which means the count can not go to 0 with
15455 * this decrement.
15456 */
15462 }
15466 /*
15467 * Sixth, try the CLOSE OTW.
15468 */
15473 /*
15474 * Let the recovery thread be responsible for
15475 * removing the state for CLOSE.
15476 */
15480 }
15482 /* See if we need to retry with a different cred */
15490 }
15499 }
15503 }
15512 "nfs4close_one: need to retry the close "
15515 }
15516 close_cleanup:
15517 /*
15518 * Seventh and lastly, process our results.
15519 */
15521 /*
15522 * It's ok to drop and regrab the 'os_sync_lock' since
15523 * nfs4close_notw() will recheck to make sure the
15524 * "close"/removal of state should happen.
15525 */
15529 }
15530 /*
15531 * This is last call, remove the ref on the open
15532 * stream created by open and clean everything up.
15533 */
15537 }
15548 }
15555 }
15557 }
15559 out:
15575 }
15576 }
15578 /*
15579 * Convert information returned by the server in the LOCK4denied
15580 * structure to the form required by fcntl.
15581 */
15582 static void
15584 {
15587 #ifdef DEBUG
15591 }
15592 #endif
15599 /*
15600 * If the blocking clientid matches our client id, then we can
15601 * interpret the lockowner (since we built it). If not, then
15602 * fabricate a sysid and pid. Note that the l_sysid field
15603 * in *flk already has the local sysid.
15604 */
15618 }
15623 /*
15624 * Construct a new sysid which should be different from
15625 * sysids of other systems.
15626 */
15630 }
15631 }
15633 static pid_t
15635 {
15651 }
15653 /*
15654 * Given a lock pointer, returns the length of that lock.
15655 * "end" is the last locked offset the "l_len" covers from
15656 * the start of the lock.
15657 */
15658 static off64_t
15660 {
15661 off64_t lock_end;
15665 else
15669 }
15671 /*
15672 * Given the end of a lock, it will return you the length "l_len" for that lock.
15673 */
15674 static off64_t
15676 {
15677 off64_t lock_len;
15682 else
15686 }
15688 /*
15689 * On given end for a lock it determines if it is the last locked offset
15690 * or not, if so keeps it as is, else adds one to return the length for
15691 * valid start.
15692 */
15693 static off64_t
15695 {
15698 else
15700 }
15702 /*
15703 * See if these two locks overlap, and if so return 1;
15704 * otherwise, return 0.
15705 */
15706 static int
15708 {
15719 }
15721 /*
15722 * Determine what the intersecting lock region is, and add that to the
15723 * 'nl_llpp' locklist in increasing order (by l_start).
15724 */
15725 static void
15728 {
15743 /* Find the starting point of the intersecting region */
15746 else
15749 /* Find the lenght of the intersecting region */
15752 else
15755 /*
15756 * Prepare the flock structure for the intersection found and insert
15757 * it into the new list in increasing l_start order. This list contains
15758 * intersections of locks registered by the client with the local host
15759 * and the lost lock.
15760 * The lock type of this lock is the same as that of the local_flp.
15761 */
15777 }
15779 /* first on the list */
15785 }
15792 }
15794 /*
15795 * Our local locking current state is potentially different than
15796 * what the NFSv4 server thinks we have due to a lost lock that was
15797 * resent and then received. We need to reset our "NFSv4" locking
15798 * state to match the current local locking state for this pid since
15799 * that is what the user/application sees as what the world is.
15800 *
15801 * We cannot afford to drop the open/lock seqid sync since then we can
15802 * get confused about what the current local locking state "is" versus
15803 * "was".
15804 *
15805 * If we are unable to fix up the locks, we send SIGLOST to the affected
15806 * process. This is not done if the filesystem has been forcibly
15807 * unmounted, in case the process has already exited and a new process
15808 * exists with the same pid.
15809 */
15810 static void
15813 {
15818 flock64_t ul_fl;
15823 /*
15824 * Find active locks for this vp from the local locking code.
15825 * Scan through this list and find out the locks that intersect with
15826 * the lost lock. Once we find the lock that intersects, add the
15827 * intersection area as a new lock to a new list "ri_llp". The lock
15828 * type of the intersection region lock added to ri_llp is the same
15829 * as that found in the active lock list, "list". The intersecting
15830 * region locks are added to ri_llp in increasing l_start order.
15831 */
15839 /*
15840 * Pick locks that belong to this pid/lockowner
15841 */
15846 }
15848 /*
15849 * Now we have the list of intersections with the lost lock. These are
15850 * the locks that were/are active before the server replied to the
15851 * last/lost lock. Issue these locks to the server here. Playing these
15852 * locks to the server will re-establish our current local locking state
15853 * with the v4 server.
15854 * If we get an error, send SIGLOST to the application for that lock.
15855 */
15859 "nfs4_reinstitute_local_lock_state: need to issue "
15865 /*
15866 * No need to relock what we already have
15867 */
15872 }
15874 /*
15875 * Now keeping the start of the lost lock as our reference parse the
15876 * newly created ri_llp locklist to find the ranges that we have locked
15877 * with the v4 server but not in the current local locking. We need
15878 * to unlock these ranges.
15879 * These ranges can also be reffered to as those ranges, where the lost
15880 * lock does not overlap with the locks in the ri_llp but are locked
15881 * since the server replied to the lost lock.
15882 */
15897 }
15899 "nfs4_reinstitute_local_lock_state: "
15909 }
15911 /*
15912 * In the case where the lost lock ends after all intersecting locks,
15913 * unlock the last part of the lost lock range.
15914 */
15917 "nfs4_reinstitute_local_lock_state: UNLOCK end of the "
15922 /*
15923 * Is it an to-EOF lock? if so unlock till the end
15924 */
15927 else
15931 }
15936 /* Free up our newly created locklist */
15941 }
15943 /*
15944 * Now return back to the original calling nfs4frlock()
15945 * and let us naturally drop our seqid syncs.
15946 */
15947 }
15949 /*
15950 * Create a lost state record for the given lock reinstantiation request
15951 * and push it onto the lost state queue.
15952 */
15953 static void
15956 {
15957 nfs4_lost_rqst_t req;
15958 nfs_lock_type4 locktype;
15970 }