| blob | 270247fa1a6e69139b8af88197c71395474e6bc7 |
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 VATTR_SIZE or
1131 * VATTR_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 VATTR_GID and VATTR_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 VATTR_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 }
6609 NULL);
6611 /*
6612 * we know we have a regular file that already
6613 * exists and we may end up truncating the file
6614 * as a result of the open_otw, so flush out
6615 * any dirty pages for this file first.
6616 */
6629 error;
6632 }
6633 }
6640 }
6641 }
6642 }
6643 }
6655 }
6658 /*
6659 * existing file got truncated, notify.
6660 */
6662 }
6665 }
6668 create_otw:
6673 /*
6674 * If not a regular file let nfs4mknod() handle it.
6675 */
6680 }
6682 /*
6683 * It _is_ a regular file.
6684 */
6689 }
6691 /*
6692 * If this happens to be a mknod of a regular file, then flags will
6693 * have neither FREAD or FWRITE. However, we must set at least one
6694 * for the call to nfs4open_otw. If it's open(O_CREAT) driving
6695 * nfs4_create, then either FREAD, FWRITE, or FRDWR has already been
6696 * set (based on openmode specified by app).
6697 */
6704 /* if create was successful, throw away the file's pages */
6707 cr);
6708 /* release the lookup hold */
6711 }
6713 /*
6714 * validate that we opened a regular file. This handles a misbehaving
6715 * server that returns an incorrect FH.
6716 */
6720 }
6722 /*
6723 * If this is not an exclusive create, then the CREATE
6724 * request will be made with the GUARDED mode set. This
6725 * means that the server will return EEXIST if the file
6726 * exists. The file could exist because of a retransmitted
6727 * request. In this case, we recover by starting over and
6728 * checking to see whether the file exists. This second
6729 * time through it should and a CREATE request will not be
6730 * sent.
6731 *
6732 * This handles the problem of a dangling CREATE request
6733 * which contains attributes which indicate that the file
6734 * should be truncated. This retransmitted request could
6735 * possibly truncate valid data in the file if not caught
6736 * by the duplicate request mechanism on the server or if
6737 * not caught by other means. The scenario is:
6738 *
6739 * Client transmits CREATE request with size = 0
6740 * Client times out, retransmits request.
6741 * Response to the first request arrives from the server
6742 * and the client proceeds on.
6743 * Client writes data to the file.
6744 * The server now processes retransmitted CREATE request
6745 * and truncates file.
6746 *
6747 * The use of the GUARDED CREATE request prevents this from
6748 * happening because the retransmitted CREATE would fail
6749 * with EEXIST and would not truncate the file.
6750 */
6752 #ifdef DEBUG
6753 nfs4_create_misses++;
6754 #endif
6756 }
6761 /*
6762 * existing file got truncated, notify.
6763 */
6769 }
6771 }
6773 /*
6774 * Create compound (for mkdir, mknod, symlink):
6775 * { Putfh <dfh>; Create; Getfh; Getattr }
6776 * It's okay if setattr failed to set gid - this is not considered
6777 * an error, but purge attrs in that case.
6778 */
6779 static int
6782 {
6784 COMPOUND4args_clnt args;
6797 nfs4_recov_state_t recov_state;
6799 hrtime_t t;
6804 bitmap4 supp_attrs;
6811 /*
6812 * Make sure we properly deal with setting the right gid
6813 * on a new directory to reflect the parent's setgid bit
6814 */
6823 /*
6824 * If the parent's directory has the setgid bit set
6825 * _and_ the client was able to get a valid mapping
6826 * for the parent dir's owner_group, we want to
6827 * append NVERIFY(owner_group == dva.va_gid) and
6828 * SETTATTR to the CREATE compound.
6829 */
6836 }
6837 }
6838 }
6839 }
6841 /*
6842 * Create ops:
6843 * 0:putfh(dir) 1:savefh(dir) 2:create 3:getfh(new) 4:getattr(new)
6844 * 5:restorefh(dir) 6:getattr(dir)
6845 *
6846 * if (setgid)
6847 * 0:putfh(dir) 1:create 2:getfh(new) 3:getattr(new)
6848 * 4:savefh(new) 5:putfh(dir) 6:getattr(dir) 7:restorefh(new)
6849 * 8:nverify 9:setattr
6850 */
6859 }
6864 }
6871 recov_retry:
6876 else
6886 }
6890 /* 0: putfh directory */
6894 /* 1/2: Create object */
6899 /*
6900 * symlink, treat name as data
6901 */
6905 }
6910 }
6925 }
6927 /* 2/3: getfh fh of created object */
6931 /* 3/4: getattr of new object */
6937 vattr_t _v;
6950 /*
6951 * nverify
6952 *
6953 * XXX - Revisit the last argument to nfs4_end_op()
6954 * once 5020486 is fixed.
6955 */
6959 supp_attrs)) {
6965 }
6967 /*
6968 * setattr
6969 *
6970 * We _know_ we're not messing with VATTR_SIZE or
6971 * VATTR_XTIME, so no need for stateid or flags. Also we
6972 * specify NULL rp since we're only interested in setting
6973 * owner_group attributes.
6974 */
6985 }
6994 }
7007 }
7013 needrecov);
7019 }
7022 }
7023 }
7034 /*
7035 * This check is left over from when create was implemented
7036 * using a setattr op (instead of createattrs). If the
7037 * putfh/create/getfh failed, the error was returned. If
7038 * setattr/getattr failed, we keep going.
7039 *
7040 * It might be better to get rid of the GETFH also, and just
7041 * do PUTFH/CREATE/GETATTR since the FH attr is mandatory.
7042 * Then if any of the operations failed, we could return the
7043 * error now, and remove much of the error code below.
7044 */
7046 /*
7047 * Either Putfh, Create or Getfh failed.
7048 */
7050 /*
7051 * nfs4_purge_stale_fh() may generate otw calls through
7052 * nfs4_invalidate_pages. Hence the need to call
7053 * nfs4_end_op() here to avoid nfs4_start_op() deadlock.
7054 */
7056 needrecov);
7060 }
7061 }
7075 /*
7076 * Need to call nfs4_end_op before nfs4getattr to avoid
7077 * potential nfs4_start_op deadlock. See RFE 4777612.
7078 */
7080 needrecov);
7087 }
7089 }
7096 }
7098 /*
7099 * If compound succeeded, then update dir attrs
7100 */
7109 /* Update directory cache attribute, readdir and dnlc caches */
7112 out:
7120 }
7128 }
7130 /* ARGSUSED */
7131 static int
7134 {
7137 nfs_ftype4 type;
7160 }
7165 }
7167 /*
7168 * This might not be needed any more; special case to deal
7169 * with problematic v2/v3 servers. Since create was unable
7170 * to set group correctly, not sure what hope setattr has.
7171 */
7175 }
7177 /*
7178 * If vnode is a device create special vnode
7179 */
7185 }
7187 }
7189 /*
7190 * Remove requires that the current fh be the target directory.
7191 * After the operation, the current fh is unchanged.
7192 * The compound op structure is:
7193 * PUTFH(targetdir), REMOVE
7194 *
7195 * Weirdness: if the vnode to be removed is open
7196 * we rename it instead of removing it and nfs_inactive
7197 * will remove the new name.
7198 */
7199 /* ARGSUSED */
7200 static int
7202 {
7203 COMPOUND4args_clnt args;
7215 nfs4_recov_state_t recov_state;
7218 dirattr_info_t dinfo;
7230 }
7236 }
7238 /*
7239 * First just remove the entry from the name cache, as it
7240 * is most likely the only entry for this vp.
7241 */
7246 /*
7247 * For regular file types, check to see if the file is open by looking
7248 * at the open streams.
7249 * For all other types, check the reference count on the vnode. Since
7250 * they are not opened OTW they never have an open stream.
7251 *
7252 * If the file is open, rename it to .nfsXXXX.
7253 */
7255 /*
7256 * If the file has a v_count > 1 then there may be more than one
7257 * entry in the name cache due multiple links or an open file,
7258 * but we don't have the real reference count so flush all
7259 * possible entries.
7260 */
7264 /*
7265 * Now we have the real reference count.
7266 */
7272 }
7295 }
7297 }
7301 }
7302 /*
7303 * Actually remove the file/dir
7304 */
7307 /*
7308 * We need to flush any dirty pages which happen to
7309 * be hanging around before removing the file.
7310 * This shouldn't happen very often since in NFSv4
7311 * we should be close to open consistent.
7312 */
7321 }
7322 }
7330 recov_retry:
7331 /*
7332 * Remove ops: putfh dir; remove
7333 */
7343 }
7345 /* putfh directory */
7349 /* remove */
7353 /* getattr dir */
7374 needrecov);
7376 }
7377 }
7379 /*
7380 * Matching nfs4_end_op() for start_op() above.
7381 * There is a path in the code below which calls
7382 * nfs4_purge_stale_fh(), which may generate otw calls through
7383 * nfs4_invalidate_pages. Hence we need to call nfs4_end_op()
7384 * here to avoid nfs4_start_op() deadlock.
7385 */
7403 /* Update directory attr, readdir and dnlc caches */
7406 }
7407 }
7420 }
7423 }
7425 /*
7426 * Link requires that the current fh be the target directory and the
7427 * saved fh be the source fh. After the operation, the current fh is unchanged.
7428 * Thus the compound op structure is:
7429 * PUTFH(file), SAVEFH, PUTFH(targetdir), LINK, RESTOREFH,
7430 * GETATTR(file)
7431 */
7432 /* ARGSUSED */
7433 static int
7436 {
7437 COMPOUND4args_clnt args;
7448 nfs4_recov_state_t recov_state;
7449 hrtime_t t;
7451 dirattr_info_t dinfo;
7463 }
7470 }
7477 recov_retry:
7482 /*
7483 * Link ops: putfh fl; savefh; putfh tdir; link; getattr(dir);
7484 * restorefh; getattr(fl)
7485 */
7494 }
7496 /* 0. putfh file */
7500 /* 1. save current fh to free up the space for the dir */
7503 /* 2. putfh targetdir */
7507 /* 3. link: current_fh is targetdir, saved_fh is source */
7511 /* 4. Get attributes of dir */
7516 /* 5. If link was successful, restore current vp to file */
7519 /* 6. Get attributes of linked object */
7537 }
7540 bool_t abort;
7546 needrecov);
7558 }
7559 /* fall through for res.status case */
7560 }
7561 }
7567 /* If link succeeded, then don't return error */
7570 /*
7571 * Either Putfh, Savefh, Putfh dir, or Link failed
7572 */
7579 }
7580 /* XXX-LP */
7584 }
7585 }
7587 /* either no error or one of the postop getattr failed */
7589 /*
7590 * XXX - if LINK succeeded, but no attrs were returned for link
7591 * file, purge its cache.
7592 *
7593 * XXX Perform a simplified version of wcc checking. Instead of
7594 * have another getattr to get pre-op, just purge cache if
7595 * any of the ops prior to and including the getattr failed.
7596 * If the getattr succeeded then update the attrcache accordingly.
7597 */
7599 /*
7600 * update cache with link file postattrs.
7601 * Note: at this point resop points to link res.
7602 */
7610 /*
7611 * Call makenfs4node to create the new shadow vp for tnm.
7612 * We pass NULL attrs because we just cached attrs for
7613 * the src object. All we're trying to accomplish is to
7614 * to create the new shadow vnode.
7615 */
7619 /* Update target cache attribute, readdir and dnlc caches */
7633 /*
7634 * Notify the source file of this link operation.
7635 */
7641 }
7642 out:
7650 }
7652 /* ARGSUSED */
7653 static int
7656 {
7665 }
7667 /*
7668 * nfs4rename does the real work of renaming in NFS Version 4.
7669 *
7670 * A file handle is considered volatile for renaming purposes if either
7671 * of the volatile bits are turned on. However, the compound may differ
7672 * based on the likelihood of the filehandle to change during rename.
7673 */
7674 static int
7677 {
7710 }
7717 }
7718 }
7720 /*
7721 * Lookup the target file. If it exists, it needs to be
7722 * checked to see whether it is a mount point and whether
7723 * it is active (open).
7724 */
7730 /*
7731 * If this file has been mounted on, then just
7732 * return busy because renaming to it would remove
7733 * the mounted file system from the name space.
7734 */
7740 }
7742 /*
7743 * First just remove the entry from the name cache, as it
7744 * is most likely the only entry for this vp.
7745 */
7751 /*
7752 * Purge the name cache of all references to this vnode
7753 * so that we can check the reference count to infer
7754 * whether it is active or not.
7755 */
7764 }
7766 /*
7767 * If the vnode is active and is not a directory,
7768 * arrange to rename it to a
7769 * temporary file so that it will continue to be
7770 * accessible. This implements the "unlink-open-file"
7771 * semantics for the target of a rename operation.
7772 * Before doing this though, make sure that the
7773 * source and target files are not already the same.
7774 */
7776 /*
7777 * Lookup the source name.
7778 */
7781 /*
7782 * The source name *should* already exist.
7783 */
7789 }
7793 /*
7794 * Compare the two vnodes. If they are the same,
7795 * just release all held vnodes and return success.
7796 */
7803 }
7805 /*
7806 * Can't mix and match directories and non-
7807 * directories in rename operations. We already
7808 * know that the target is not a directory. If
7809 * the source is a directory, return an error.
7810 */
7817 }
7818 link_call:
7819 /*
7820 * The target file exists, is not the same as
7821 * the source file, and is active. We first
7822 * try to Link it to a temporary filename to
7823 * avoid having the server removing the file
7824 * completely (which could cause data loss to
7825 * the user's POV in the event the Rename fails
7826 * -- see bug 1165874).
7827 */
7828 /*
7829 * The do_link and did_link booleans are
7830 * introduced in the event we get NFS4ERR_FILE_OPEN
7831 * returned for the Rename. Some servers can
7832 * not Rename over an Open file, so they return
7833 * this error. The client needs to Remove the
7834 * newly created Link and do two Renames, just
7835 * as if the server didn't support LINK.
7836 */
7843 }
7850 }
7858 }
7873 }
7875 }
7880 }
7883 /*
7884 * When renaming directories to be a subdirectory of a
7885 * different parent, the dnlc entry for ".." will no
7886 * longer be valid, so it must be removed.
7887 *
7888 * We do a lookup here to determine whether we are renaming
7889 * a directory and we need to check if we are renaming
7890 * an unlinked file. This might have already been done
7891 * in previous code, so we check ovp == NULL to avoid
7892 * doing it twice.
7893 */
7895 /*
7896 * The source name *should* already exist.
7897 */
7903 }
7905 }
7908 }
7910 /*
7911 * Is the object being renamed a dir, and if so, is
7912 * it being renamed to a child of itself? The underlying
7913 * fs should ultimately return EINVAL for this case;
7914 * however, buggy beta non-Solaris NFSv4 servers at
7915 * interop testing events have allowed this behavior,
7916 * and it caused our client to panic due to a recursive
7917 * mutex_enter in fn_move.
7918 *
7919 * The tedious locking in fn_move could be changed to
7920 * deal with this case, and the client could avoid the
7921 * panic; however, the client would just confuse itself
7922 * later and misbehave. A better way to handle the broken
7923 * server is to detect this condition and return EINVAL
7924 * without ever sending the the bogus rename to the server.
7925 * We know the rename is invalid -- just fail it now.
7926 */
7933 }
7935 }
7939 /*
7940 * If FH4_VOL_RENAME or FH4_VOLATILE_ANY bits are set, it is
7941 * possible for the filehandle to change due to the rename.
7942 * If neither of these bits is set, but FH4_VOL_MIGRATION is set,
7943 * the fh will not change because of the rename, but we still need
7944 * to update its rnode entry with the new name for
7945 * an eventual fh change due to migration. The FH4_NOEXPIRE_ON_OPEN
7946 * has no effect on these for now, but for future improvements,
7947 * we might want to use it too to simplify handling of files
7948 * that are open with that flag on. (XXX)
7949 */
7954 else
7964 /*
7965 * Before the 'link_call' code, we did a nfs4_lookup
7966 * that puts a VN_HOLD on nvp. After the nfs4_link
7967 * call we call VN_RELE to match that hold. We need
7968 * to place an additional VN_HOLD here since we will
7969 * be hitting that VN_RELE again.
7970 */
7975 /* Undo the unlinked file naming stuff we just did */
7983 /* rp->r_unlanme points to tmpname */
7987 }
7992 }
7994 }
8002 }
8004 }
8006 /*
8007 * when renaming directories to be a subdirectory of a
8008 * different parent, the dnlc entry for ".." will no
8009 * longer be valid, so it must be removed
8010 */
8017 }
8018 }
8020 /*
8021 * If we are renaming the unlinked file, update the
8022 * r_unldvp and r_unlname as needed.
8023 */
8033 }
8034 }
8035 }
8038 /*
8039 * Notify the rename vnevents to source vnode, and to the target
8040 * vnode if it already existed.
8041 */
8045 /*
8046 * Notify the vnode. Each links is represented by
8047 * a different vnode, in nfsv4.
8048 */
8055 }
8057 /*
8058 * if the source and destination directory are not the
8059 * same notify the destination directory.
8060 */
8067 }
8074 }
8078 }
8085 }
8087 /*
8088 * When the parent directory has changed, sv_dfh must be updated
8089 */
8090 static void
8092 {
8100 }
8102 /*
8103 * nfs4rename_persistent does the otw portion of renaming in NFS Version 4,
8104 * when it is known that the filehandle is persistent through rename.
8105 *
8106 * Rename requires that the current fh be the target directory and the
8107 * saved fh be the source directory. After the operation, the current fh
8108 * is unchanged.
8109 * The compound op structure for persistent fh rename is:
8110 * PUTFH(sourcdir), SAVEFH, PUTFH(targetdir), RENAME
8111 * Rather than bother with the directory postop args, we'll simply
8112 * update that a change occurred in the cache, so no post-op getattrs.
8113 */
8114 static int
8117 {
8118 COMPOUND4args_clnt args;
8127 bool_t needrecov;
8128 nfs4_recov_state_t recov_state;
8137 /*
8138 * Rename ops: putfh sdir; savefh; putfh tdir; rename; getattr tdir
8139 *
8140 * If source/target are different dirs, then append putfh(src); getattr
8141 */
8146 recov_retry:
8149 /* No need to Lookup the file, persistent fh */
8157 }
8159 /* 0: putfh source directory */
8163 /* 1: Save source fh to free up current for target */
8166 /* 2: putfh targetdir */
8170 /* 3: current_fh is targetdir, saved_fh is sourcedir */
8175 /* 4: getattr (targetdir) */
8182 /* 5: putfh (sourcedir) */
8186 /* 6: getattr (sourcedir) */
8190 }
8205 }
8214 }
8215 }
8219 /*
8220 * as long as OP_RENAME
8221 */
8226 /*
8227 * System V defines rename to return EEXIST, not
8228 * ENOTEMPTY if the target directory is not empty.
8229 * Over the wire, the error is NFSERR_ENOTEMPTY
8230 * which geterrno4 maps to ENOTEMPTY.
8231 */
8240 /*
8241 * Update target attribute, readdir and dnlc
8242 * caches.
8243 */
8254 /*
8255 * Update source attribute, readdir and dnlc caches
8256 *
8257 */
8268 }
8271 nnm);
8272 }
8273 }
8281 }
8283 /*
8284 * nfs4rename_volatile_fh does the otw part of renaming in NFS Version 4, when
8285 * it is possible for the filehandle to change due to the rename.
8286 *
8287 * The compound req in this case includes a post-rename lookup and getattr
8288 * to ensure that we have the correct fh and attributes for the object.
8289 *
8290 * Rename requires that the current fh be the target directory and the
8291 * saved fh be the source directory. After the operation, the current fh
8292 * is unchanged.
8293 *
8294 * We need the new filehandle (hence a LOOKUP and GETFH) so that we can
8295 * update the filehandle for the renamed object. We also get the old
8296 * filehandle for historical reasons; this should be taken out sometime.
8297 * This results in a rather cumbersome compound...
8298 *
8299 * PUTFH(sourcdir), SAVEFH, LOOKUP(src), GETFH(old),
8300 * PUTFH(targetdir), RENAME, LOOKUP(trgt), GETFH(new), GETATTR
8301 *
8302 */
8303 static int
8306 {
8307 COMPOUND4args_clnt args;
8319 bool_t needrecov;
8320 nfs4_recov_state_t recov_state;
8321 hrtime_t t;
8330 recov_retry:
8333 /*
8334 * There is a window between the RPC and updating the path and
8335 * filehandle stored in the rnode. Lock out the FHEXPIRED recovery
8336 * code, so that it doesn't try to use the old path during that
8337 * window.
8338 */
8350 }
8353 }
8364 /*
8365 * Rename ops:
8366 * PUTFH(sourcdir), SAVEFH, LOOKUP(src), GETFH(old),
8367 * PUTFH(targetdir), RENAME, GETATTR(targetdir)
8368 * LOOKUP(trgt), GETFH(new), GETATTR,
8369 *
8370 * if (odvp != ndvp)
8371 * add putfh(sourcedir), getattr(sourcedir) }
8372 */
8384 }
8386 /* 0: putfh source directory */
8390 /* 1: Save source fh to free up current for target */
8393 /* 2: Lookup pre-rename fh of renamed object */
8397 /* 3: getfh fh of renamed object (before rename) */
8400 /* 4: putfh targetdir */
8404 /* 5: current_fh is targetdir, saved_fh is sourcedir */
8409 /* 6: getattr of target dir (post op attrs) */
8414 /* 7: Lookup post-rename fh of renamed object */
8418 /* 8: getfh fh of renamed object (after rename) */
8421 /* 9: getattr of renamed object */
8426 /*
8427 * If source/target dirs are different, then get new post-op
8428 * attrs for source dir also.
8429 */
8431 /* 10: putfh (sourcedir) */
8435 /* 11: getattr (sourcedir) */
8439 }
8456 }
8459 }
8462 bool_t abort;
8482 }
8483 /* fall through for res.status case */
8484 }
8485 }
8488 /*
8489 * If OP_RENAME (or any prev op) failed, then return an error.
8490 * OP_RENAME is index 5, so if array len <= 6 we return an error.
8491 */
8493 /*
8494 * Error in an op other than last Getattr
8495 */
8499 /*
8500 * System V defines rename to return EEXIST, not
8501 * ENOTEMPTY if the target directory is not empty.
8502 * Over the wire, the error is NFSERR_ENOTEMPTY
8503 * which geterrno4 maps to ENOTEMPTY.
8504 */
8508 needrecov);
8510 }
8512 /* rename results */
8516 /* Update target attribute, readdir and dnlc caches */
8524 /* Update source cache attribute, readdir and dnlc caches */
8527 /* Update source cache attribute, readdir and dnlc caches */
8531 /*
8532 * If dinfop is non-NULL, then compound succeded, so
8533 * set di_garp to attrs for source dir. dinfop is only
8534 * set to NULL when compound fails.
8535 */
8540 dinfop);
8541 }
8543 /*
8544 * Update the rnode with the new component name and args,
8545 * and if the file handle changed, also update it with the new fh.
8546 * This is only necessary if the target object has an rnode
8547 * entry and there is no need to create one for it.
8548 */
8552 /*
8553 * Update the path and filehandle for the renamed object.
8554 */
8564 }
8566 out:
8576 }
8578 /* ARGSUSED */
8579 static int
8582 {
8588 /*
8589 * As ".." has special meaning and rather than send a mkdir
8590 * over the wire to just let the server freak out, we just
8591 * short circuit it here and return EEXIST
8592 */
8596 /*
8597 * Decision to get the right gid and setgid bit of the
8598 * new directory is now made in call_nfs4_create_req.
8599 */
8607 }
8610 /*
8611 * rmdir is using the same remove v4 op as does remove.
8612 * Remove requires that the current fh be the target directory.
8613 * After the operation, the current fh is unchanged.
8614 * The compound op structure is:
8615 * PUTFH(targetdir), REMOVE
8616 */
8617 /*ARGSUSED4*/
8618 static int
8621 {
8623 COMPOUND4args_clnt args;
8633 nfs4_recov_state_t recov_state;
8639 /*
8640 * As ".." has special meaning and rather than send a rmdir
8641 * over the wire to just let the server freak out, we just
8642 * short circuit it here and return EEXIST
8643 */
8651 /*
8652 * Attempt to prevent a rmdir(".") from succeeding.
8653 */
8658 }
8663 }
8665 /*
8666 * Since nfsv4 remove op works on both files and directories,
8667 * check that the removed object is indeed a directory.
8668 */
8673 }
8675 /*
8676 * First just remove the entry from the name cache, as it
8677 * is most likely an entry for this vp.
8678 */
8681 /*
8682 * If there vnode reference count is greater than one, then
8683 * there may be additional references in the DNLC which will
8684 * need to be purged. First, trying removing the entry for
8685 * the parent directory and see if that removes the additional
8686 * reference(s). If that doesn't do it, then use dnlc_purge_vp
8687 * to completely remove any references to the directory which
8688 * might still exist in the DNLC.
8689 */
8694 }
8700 recov_retry:
8703 /*
8704 * Rmdir ops: putfh dir; remove
8705 */
8713 }
8716 /* putfh directory */
8720 /* remove */
8724 /* getattr (postop attrs for dir that contained removed dir) */
8738 }
8747 needrecov);
8750 }
8751 }
8756 /*
8757 * Only return error if first 2 ops (OP_REMOVE or earlier)
8758 * failed.
8759 */
8767 /*
8768 * System V defines rmdir to return EEXIST, not
8769 * ENOTEMPTY if the directory is not empty. Over
8770 * the wire, the error is NFSERR_ENOTEMPTY which
8771 * geterrno4 maps to ENOTEMPTY.
8772 */
8788 /* Update dir attribute, readdir and dnlc caches */
8790 dinfop);
8792 /* destroy rddir cache for dir that was removed */
8795 }
8796 }
8814 }
8819 }
8821 /* ARGSUSED */
8822 static int
8825 {
8858 }
8859 }
8860 }
8864 }
8867 /*
8868 * Read directory entries.
8869 * There are some weird things to look out for here. The uio_loffset
8870 * field is either 0 or it is the offset returned from a previous
8871 * readdir. It is an opaque value used by the server to find the
8872 * correct directory block to read. The count field is the number
8873 * of blocks to read on the server. This is advisory only, the server
8874 * may return only one block's worth of entries. Entries may be compressed
8875 * on the server.
8876 */
8877 /* ARGSUSED */
8878 static int
8881 {
8883 uint_t count;
8894 /*
8895 * Make sure that the directory cache is valid.
8896 */
8899 /*
8900 * Setting nfs_disable_rddir_cache in /etc/system
8901 * allows interoperability with servers that do not
8902 * properly update the attributes of directories.
8903 * Any cached information gets purged before an
8904 * access is made to it.
8905 */
8907 }
8912 }
8916 /*
8917 * Short circuit last readdir which always returns 0 bytes.
8918 * This can be done after the directory has been read through
8919 * completely at least once. This will set r_direof which
8920 * can be used to find the value of the last cookie.
8921 */
8926 #ifdef DEBUG
8927 nfs4_readdir_cache_shorts++;
8928 #endif
8932 }
8934 /*
8935 * Look for a cache entry. Cache entries are identified
8936 * by the NFS cookie value and the byte count requested.
8937 */
8940 /*
8941 * If rdc is NULL then the lookup resulted in an unrecoverable error.
8942 */
8946 }
8948 /*
8949 * Check to see if we need to fill this entry in.
8950 */
8956 /*
8957 * Do the readdir.
8958 */
8961 /*
8962 * Reacquire the lock, so that we can continue
8963 */
8965 /*
8966 * The entry is now complete
8967 */
8969 }
8973 /*
8974 * If an error occurred while attempting
8975 * to fill the cache entry, mark the entry invalid and
8976 * just return the error.
8977 */
8984 }
8986 /*
8987 * The cache entry is complete and good,
8988 * copyout the dirent structs to the calling
8989 * thread.
8990 */
8993 /*
8994 * If no error occurred during the copyout,
8995 * update the offset in the uio struct to
8996 * contain the value of the next NFS 4 cookie
8997 * and set the eof value appropriately.
8998 */
9003 }
9005 /*
9006 * Decide whether to do readahead. Don't if we
9007 * have already read to the end of directory.
9008 */
9010 /*
9011 * Make the entry the direof only if it is cached
9012 */
9018 }
9020 /* Determine if a readdir readahead should be done */
9025 }
9027 /*
9028 * Now look for a readahead entry.
9029 *
9030 * Check to see whether we found an entry for the readahead.
9031 * If so, we don't need to do anything further, so free the new
9032 * entry if one was allocated. Otherwise, allocate a new entry, add
9033 * it to the cache, and then initiate an asynchronous readdir
9034 * operation to fill it.
9035 */
9038 /*
9039 * A readdir cache entry could not be obtained for the readahead. In
9040 * this case we skip the readahead and return.
9041 */
9046 }
9048 /*
9049 * Check to see if we need to fill this entry in.
9050 */
9056 #ifdef DEBUG
9057 nfs4_readdir_readahead++;
9058 #endif
9059 /*
9060 * Do the readdir.
9061 */
9064 }
9070 }
9072 static int
9074 {
9082 /*
9083 * Obtain the readdir results for the caller.
9084 */
9088 /*
9089 * The entry is now complete
9090 */
9100 }
9102 /*
9103 * Read directory entries.
9104 * There are some weird things to look out for here. The uio_loffset
9105 * field is either 0 or it is the offset returned from a previous
9106 * readdir. It is an opaque value used by the server to find the
9107 * correct directory block to read. The count field is the number
9108 * of blocks to read on the server. This is advisory only, the server
9109 * may return only one block's worth of entries. Entries may be compressed
9110 * on the server.
9111 *
9112 * Generates the following compound request:
9113 * 1. If readdir offset is zero and no dnlc entry for parent exists,
9114 * must include a Lookupp as well. In this case, send:
9115 * { Putfh <fh>; Readdir; Lookupp; Getfh; Getattr }
9116 * 2. Otherwise just do: { Putfh <fh>; Readdir }
9117 *
9118 * Get complete attributes and filehandles for entries if this is the
9119 * first read of the directory. Otherwise, just get fileid's.
9120 */
9121 static void
9123 {
9124 COMPOUND4args_clnt args;
9125 COMPOUND4res_clnt res;
9128 bitmap4 rd_bitsval;
9139 nfs4_recov_state_t recov_state;
9140 hrtime_t t;
9147 /*
9148 * If rp were a stub, it should have triggered and caused
9149 * a mount for us to get this far.
9150 */
9155 /*
9156 * Since nfsv4 readdir may not return entries for "." and "..",
9157 * the client must recreate them:
9158 * To find the correct nodeid, do the following:
9159 * For current node, get nodeid from dnlc.
9160 * - if current node is rootvp, set pnodeid to nodeid.
9161 * - else if parent is in the dnlc, get its nodeid from there.
9162 * - else add LOOKUPP+GETATTR to compound.
9163 */
9170 /* parent in dnlc cache - no need for otw */
9173 /*
9174 * parent not in dnlc cache,
9175 * do lookupp to get its id
9176 */
9179 }
9182 }
9183 }
9187 /* Save the original mount point security flavor */
9190 recov_retry:
9198 /*
9199 * If readdir a node that is a stub for a crossed mount point,
9200 * keep the original secinfo flavor for the current file
9201 * system, not the crossed one.
9202 */
9206 }
9208 /*
9209 * Determine which attrs to request for dirents. This code
9210 * must be protected by nfs4_start/end_fop because of r_server
9211 * (which will change during failover recovery).
9212 *
9213 */
9215 /*
9216 * Get all vattr attrs plus filehandle and rdattr_error
9217 */
9219 FATTR4_RDATTR_ERROR_MASK |
9220 FATTR4_FILEHANDLE_MASK;
9226 }
9230 /*
9231 * Already read directory. Use readdir with
9232 * no attrs (except for mounted_on_fileid) for updates.
9233 */
9236 /*
9237 * request mounted on fileid if supported, else request
9238 * fileid. maybe we should verify that fileid is supported
9239 * and request something else if not.
9240 */
9245 }
9247 /* putfh directory fh */
9253 /*
9254 * 1 and 2 are reserved for client "." and ".." entry offset.
9255 * cookie 0 should be used over-the-wire to start reading at
9256 * the beginning of the directory excluding "." and "..".
9257 */
9268 }
9278 /*
9279 * If count < than the minimum required, we return no entries
9280 * and fail with EINVAL
9281 */
9285 }
9288 /*
9289 * Add lookupp and getattr for parent nodeid.
9290 */
9295 /* getattr parent */
9299 }
9307 }
9309 /* capture the time of this call */
9318 }
9322 /*
9323 * If RPC error occurred and it isn't an error that
9324 * triggers recovery, then go ahead and fail now.
9325 */
9329 }
9332 bool_t abort;
9347 }
9349 }
9354 }
9356 /* fall through for res.status case */
9357 }
9361 /*
9362 * If compound failed first 2 ops (PUTFH+READDIR), then return
9363 * failure here. Subsequent ops are for filling out dot-dot
9364 * dirent, and if they fail, we still want to give the caller
9365 * the dirents returned by (the successful) READDIR op, so we need
9366 * to silently ignore failure for subsequent ops (LOOKUPP+GETATTR).
9367 *
9368 * One example where PUTFH+READDIR ops would succeed but
9369 * LOOKUPP+GETATTR would fail would be a dir that has r perm
9370 * but lacks x. In this case, a POSIX server's fop_readdir
9371 * would succeed; however, fop_lookup(..) would fail since no
9372 * x perm. We need to come up with a non-vendor-specific way
9373 * for a POSIX server to return d_ino from dotdot's dirent if
9374 * client only requests mounted_on_fileid, and just say the
9375 * LOOKUPP succeeded and fill out the GETATTR. However, if
9376 * client requested any mandatory attrs, server would be required
9377 * to fail the GETATTR op because it can't call fop_lookup+fop_getattr
9378 * for dotdot.
9379 */
9392 }
9393 /*
9394 * If readdir a node that is a stub for a
9395 * crossed mount point, keep the original
9396 * secinfo flavor for the current file system,
9397 * not the crossed one.
9398 */
9401 }
9402 }
9411 /*
9412 * For "." and ".." entries
9413 * e.g.
9414 * seek(cookie=0) -> "." entry with d_off = 1
9415 * seek(cookie=1) -> ".." entry with d_off = 2
9416 */
9422 }
9426 }
9429 /* LOOKUPP+GETATTR attemped */
9443 /*
9444 * First, take care of finishing the
9445 * readdir results.
9446 */
9448 /*
9449 * The d_ino of .. must be the inode number
9450 * of the mounted filesystem.
9451 */
9457 /*
9458 * Next, create the ".." dnlc entry
9459 */
9464 }
9466 }
9467 }
9474 }
9478 out:
9479 /*
9480 * If readdir a node that is a stub for a crossed mount point,
9481 * keep the original secinfo flavor for the current file system,
9482 * not the crossed one.
9483 */
9487 }
9490 static int
9492 {
9497 offset_t offset;
9508 read_again:
9509 /*
9510 * Releases the osp, if it is provided.
9511 * Puts a hold on the cred_otw and the new osp (if found).
9512 */
9521 /*
9522 * Didn't get it all because we hit EOF,
9523 * zero all the memory beyond the EOF.
9524 */
9525 /* bzero(rdaddr + */
9528 }
9532 /*
9533 * We didn't read anything at all as we are
9534 * past EOF. Return an error indicator back
9535 * but don't destroy the pages (yet).
9536 */
9538 }
9542 }
9545 write_again:
9546 /*
9547 * Releases the osp, if it is provided.
9548 * Puts a hold on the cred_otw and the new
9549 * osp (if found).
9550 */
9558 #ifdef DEBUG
9564 offset);
9572 }
9573 #endif
9579 }
9583 /*
9584 * Don't print EDQUOT errors on the console.
9585 * Don't print asynchronous EACCES errors.
9586 * Don't print EFBIG errors.
9587 * Print all other write errors.
9588 */
9594 /*
9595 * Update r_error and r_flags as appropriate.
9596 * If the error was ESTALE, then mark the
9597 * rnode as not being writeable and save
9598 * the error status. Otherwise, save any
9599 * errors which occur from asynchronous
9600 * page invalidations. Any errors occurring
9601 * from other operations should be saved
9602 * by the caller.
9603 */
9614 }
9616 }
9620 /*
9621 * A close may have cleared r_error, if so,
9622 * propagate ESTALE error return properly
9623 */
9626 }
9627 }
9638 }
9640 /* ARGSUSED */
9641 int
9643 {
9645 }
9647 /* ARGSUSED2 */
9648 int
9650 {
9656 }
9664 }
9668 }
9670 /* ARGSUSED */
9671 void
9673 {
9677 }
9679 /* ARGSUSED */
9680 static int
9682 {
9686 /*
9687 * Because we stuff the readdir cookie into the offset field
9688 * someone may attempt to do an lseek with the cookie which
9689 * we want to succeed.
9690 */
9696 }
9699 /*
9700 * Return all the pages from [off..off+len) in file
9701 */
9702 /* ARGSUSED */
9703 static int
9707 {
9724 /*
9725 * Now validate that the caches are up to date.
9726 */
9731 retry:
9734 /*
9735 * Don't create dirty pages faster than they
9736 * can be cleaned so that the system doesn't
9737 * get imbalanced. If the async queue is
9738 * maxed out, then wait for it to drain before
9739 * creating more dirty pages. Also, wait for
9740 * any threads doing pagewalks in the vop_getattr
9741 * entry points so that they don't block for
9742 * long periods.
9743 */
9749 }
9751 /*
9752 * If we are getting called as a side effect of an nfs_write()
9753 * operation the local file size might not be extended yet.
9754 * In this case we want to be able to return pages of zeroes.
9755 */
9763 }
9779 }
9782 }
9784 /*
9785 * Called from pvn_getpages to get a particular page.
9786 */
9787 /* ARGSUSED */
9788 static int
9792 {
9794 uint_t bsize;
9797 uoff_t lbn;
9798 uoff_t io_off;
9799 uoff_t blkoff;
9800 uoff_t rablkoff;
9802 uint_t blksize;
9817 reread:
9829 /*
9830 * Queueing up the readahead before doing the synchronous read
9831 * results in a significant increase in read throughput because
9832 * of the increased parallelism between the async threads and
9833 * the process context.
9834 */
9840 /*
9841 * Calculate the number of readaheads to do.
9842 * a) No readaheads at offset = 0.
9843 * b) Do maximum(nfs4_nra) readaheads when the readahead
9844 * window is closed.
9845 * c) Do readaheads between 1 to (nfs4_nra - 1) depending
9846 * upon how far the readahead window is open or close.
9847 * d) No readaheads if rp->r_nextr is not within the scope
9848 * of the readahead window (random i/o).
9849 */
9859 else
9870 }
9871 readahead--;
9873 /*
9874 * Indicate that we did a readahead so
9875 * readahead offset is not updated
9876 * by the synchronous read below.
9877 */
9880 /*
9881 * set readahead offset to
9882 * offset of last async readahead
9883 * request.
9884 */
9886 }
9888 }
9890 again:
9894 nfs4_readahead);
9896 /*
9897 * Block for this page is not allocated, or the offset
9898 * is beyond the current allocation size, or we're
9899 * allocating a swap slot and the page was not found,
9900 * so allocate it and return a zero page.
9901 */
9910 /*
9911 * Need to go to server to get a block
9912 */
9916 /*
9917 * If less than a block left in
9918 * file read less than a block.
9919 */
9921 /*
9922 * Trying to access beyond EOF,
9923 * set up to get at least one page.
9924 */
9939 /*
9940 * Some other thread has entered the page,
9941 * so just use it.
9942 */
9946 /*
9947 * Now round the request size up to page boundaries.
9948 * This ensures that the entire page will be
9949 * initialized to zeroes if EOF is encountered.
9950 */
9956 /*
9957 * pageio_setup should have set b_addr to 0. This
9958 * is correct since we want to do I/O on a page
9959 * boundary. bp_mapin will use this addr to calculate
9960 * an offset, and then set b_addr to the kernel virtual
9961 * address it allocated for us.
9962 */
9972 /*
9973 * If doing a write beyond what we believe is EOF,
9974 * don't bother trying to read the pages from the
9975 * server, we'll just zero the pages here. We
9976 * don't check that the rw flag is S_WRITE here
9977 * because some implementations may attempt a
9978 * read access to the buffer before copying data.
9979 */
9987 }
9989 /*
9990 * Unmap the buffer before freeing it.
9991 */
10001 /*
10002 * If doing a write system call just return
10003 * zeroed pages, else user tried to get pages
10004 * beyond EOF, return error. We don't check
10005 * that the rw flag is S_WRITE here because
10006 * some implementations may attempt a read
10007 * access to the buffer before copying data.
10008 */
10011 else
10013 }
10019 }
10020 }
10021 }
10023 out:
10031 }
10036 /*
10037 * Page exists in the cache, acquire the appropriate lock.
10038 * If this fails, start all over again.
10039 */
10041 #ifdef DEBUG
10042 nfs4_lostpage++;
10043 #endif
10045 }
10049 }
10055 }
10057 static void
10060 {
10063 uoff_t io_off;
10076 /*
10077 * If less than a block left in file read less
10078 * than a block.
10079 */
10087 /*
10088 * The isra flag passed to the kluster function is 1, we may have
10089 * gotten a return value of NULL for a variety of reasons (# of free
10090 * pages < minfree, someone entered the page on the vnode etc). In all
10091 * cases, we want to punt on the readahead.
10092 */
10096 /*
10097 * Now round the request size up to page boundaries.
10098 * This ensures that the entire page will be
10099 * initialized to zeroes if EOF is encountered.
10100 */
10106 /*
10107 * pageio_setup should have set b_addr to 0. This is correct since
10108 * we want to do I/O on a page boundary. bp_mapin() will use this addr
10109 * to calculate an offset, and then set b_addr to the kernel virtual
10110 * address it allocated for us.
10111 */
10121 /*
10122 * If doing a write beyond what we believe is EOF, don't bother trying
10123 * to read the pages from the server, we'll just zero the pages here.
10124 * We don't check that the rw flag is S_WRITE here because some
10125 * implementations may attempt a read access to the buffer before
10126 * copying data.
10127 */
10138 }
10140 /*
10141 * Unmap the buffer before freeing it.
10142 */
10153 /*
10154 * In case of error set readahead offset
10155 * to the lowest offset.
10156 * pvn_read_done() calls VN_DISPOSE to destroy the pages
10157 */
10163 }
10164 }
10166 /*
10167 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
10168 * If len == 0, do from off to EOF.
10169 *
10170 * The normal cases should be len == 0 && off == 0 (entire vp list) or
10171 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
10172 * (from pageout).
10173 */
10174 /* ARGSUSED */
10175 static int
10178 {
10191 /*
10192 * XXX - Why should this check be made here?
10193 */
10211 }
10213 /*
10214 * Write out a single page, possibly klustering adjacent dirty pages.
10215 */
10216 int
10219 {
10220 uoff_t io_off;
10221 uoff_t lbn_off;
10222 uoff_t lbn;
10224 uint_t bsize;
10241 /*
10242 * Find a kluster that fits in one block, or in
10243 * one page if pages are bigger than blocks. If
10244 * there is less file space allocated than a whole
10245 * page, we'll shorten the i/o request below.
10246 */
10250 /*
10251 * pvn_write_kluster shouldn't have returned a page with offset
10252 * behind the original page we were given. Verify that.
10253 */
10256 /*
10257 * Now pp will have the list of kept dirty pages marked for
10258 * write back. It will also handle invalidation and freeing
10259 * of pages that are not dirty. Check for page length rounding
10260 * problems.
10261 */
10265 }
10266 /*
10267 * The R4MODINPROGRESS flag makes sure that nfs4_bio() sees a
10268 * consistent value of r_size. R4MODINPROGRESS is set in writerp4().
10269 * When R4MODINPROGRESS is set it indicates that a uiomove() is in
10270 * progress and the r_size has not been made consistent with the
10271 * new size of the file. When the uiomove() completes the r_size is
10272 * updated and the R4MODINPROGRESS flag is cleared.
10273 *
10274 * The R4MODINPROGRESS flag makes sure that nfs4_bio() sees a
10275 * consistent value of r_size. Without this handshaking, it is
10276 * possible that nfs4_bio() picks up the old value of r_size
10277 * before the uiomove() in writerp4() completes. This will result
10278 * in the write through nfs4_bio() being dropped.
10279 *
10280 * More precisely, there is a window between the time the uiomove()
10281 * completes and the time the r_size is updated. If a fop_putpage()
10282 * operation intervenes in this window, the page will be picked up,
10283 * because it is dirty (it will be unlocked, unless it was
10284 * pagecreate'd). When the page is picked up as dirty, the dirty
10285 * bit is reset (pvn_getdirty()). In nfs4write(), r_size is
10286 * checked. This will still be the old size. Therefore the page will
10287 * not be written out. When segmap_release() calls fop_putpage(),
10288 * the page will be found to be clean and the write will be dropped.
10289 */
10296 /*
10297 * A write is in progress for this region of the file.
10298 * If we did not detect R4MODINPROGRESS here then this
10299 * path through nfs_putapage() would eventually go to
10300 * nfs4_bio() and may not write out all of the data
10301 * in the pages. We end up losing data. So we decide
10302 * to set the modified bit on each page in the page
10303 * list and mark the rnode with R4DIRTY. This write
10304 * will be restarted at some later time.
10305 */
10313 }
10321 }
10323 }
10327 nfs4_sync_putapage);
10336 }
10338 static int
10341 {
10360 }
10363 /*
10364 * If this was not an async thread, then try again to
10365 * write out the pages, but this time, also destroy
10366 * them whether or not the write is successful. This
10367 * will prevent memory from filling up with these
10368 * pages and destroying them is the only alternative
10369 * if they can't be written out.
10370 *
10371 * Don't do this if this is an async thread because
10372 * when the pages are unlocked in pvn_write_done,
10373 * some other thread could have come along, locked
10374 * them, and queued for an async thread. It would be
10375 * possible for all of the async threads to be tied
10376 * up waiting to lock the pages again and they would
10377 * all already be locked and waiting for an async
10378 * thread to handle them. Deadlock.
10379 */
10383 }
10391 }
10395 NFS4_WRITE_NOWAIT);
10396 }
10399 }
10401 #ifdef DEBUG
10403 #endif
10405 /* ARGSUSED */
10406 static int
10410 {
10428 /*
10429 * If the file is delegated to the client don't do anything.
10430 * If the file is not delegated, then validate the data cache.
10431 */
10440 }
10442 /*
10443 * Check to see if the vnode is currently marked as not cachable.
10444 * This means portions of the file are locked (through fop_frlock).
10445 * In this case the map request must be refused. We use
10446 * rp->r_lkserlock to avoid a race with concurrent lock requests.
10447 *
10448 * Atomically increment r_inmap after acquiring r_rwlock. The
10449 * idea here is to acquire r_rwlock to block read/write and
10450 * not to protect r_inmap. r_inmap will inform nfs4_read/write()
10451 * that we are in nfs4_map(). Now, r_rwlock is acquired in order
10452 * and we can prevent the deadlock that would have occurred
10453 * when nfs4_addmap() would have acquired it out of order.
10454 *
10455 * Since we are not protecting r_inmap by any lock, we do not
10456 * hold any lock when we decrement it. We atomically decrement
10457 * r_inmap after we release r_lkserlock.
10458 */
10468 }
10473 }
10475 /*
10476 * Don't allow concurrent locks and mapping if mandatory locking is
10477 * enabled.
10478 */
10488 }
10489 }
10491 /*
10492 * It is possible that the rnode has a lost lock request that we
10493 * are still trying to recover, and that the request conflicts with
10494 * this map request.
10495 *
10496 * An alternative approach would be for nfs4_safemap() to consider
10497 * queued lock requests when deciding whether to set or clear
10498 * VNOCACHE. This would require the frlock code path to call
10499 * nfs4_safemap() after enqueing a lost request.
10500 */
10504 }
10511 }
10514 /*
10515 * We need to retrieve the open stream
10516 */
10522 /* returns with 'os_sync_lock' held */
10525 }
10527 #ifdef DEBUG
10531 }
10532 #endif
10533 /* returns with 'os_sync_lock' held */
10537 "nfs4_map: we tried to OPEN the file "
10540 }
10541 }
10547 "nfs4_map: os_failed_reopen set on "
10552 }
10555 }
10571 done:
10575 }
10577 /*
10578 * We're most likely dealing with a kernel module that likes to READ
10579 * and mmap without OPENing the file (ie: lookup/read/mmap), so lets
10580 * officially OPEN the file to create the necessary client state
10581 * for bookkeeping of os_mmap_read/write counts.
10582 *
10583 * Since fop_map only passes in a pointer to the vnode rather than
10584 * a double pointer, we can't handle the case where nfs4open_otw()
10585 * returns a different vnode than the one passed into fop_map (since
10586 * fop_delmap will not see the vnode nfs4open_otw used). In this case,
10587 * we return NULL and let nfs4_map() fail. Note: the only case where
10588 * this should happen is if the file got removed and replaced with the
10589 * same name on the server (in addition to the fact that we're trying
10590 * to fop_map withouth fop_opening the file in the first place).
10591 */
10592 static int
10594 {
10614 }
10620 }
10628 /* This is needed so we don't bump the open ref count */
10633 }
10638 just_created);
10644 }
10649 /*
10650 * If nfs4open_otw() returned a different vnode then "undo"
10651 * the open and return failure to the caller.
10652 */
10654 nfs4_error_t e;
10658 /*
10659 * If there's an error, ignore it,
10660 * and let fop_inactive handle it.
10661 */
10666 }
10672 nfs4_error_t e;
10676 /*
10677 * If there's an error, ignore it,
10678 * and let fop_inactive handle it.
10679 */
10683 }
10688 }
10690 /*
10691 * Please be aware that when this function is called, the address space write
10692 * a_lock is held. Do not put over the wire calls in this function.
10693 */
10694 /* ARGSUSED */
10695 static int
10699 {
10712 /*
10713 * Don't need to update the open stream first, since this
10714 * mmap can't add any additional share access that isn't
10715 * already contained in the open stream (for the case where we
10716 * open/mmap/only update rp->r_mapcnt/server reboots/reopen doesn't
10717 * take into account os_mmap_read[write] counts).
10718 */
10722 /*
10723 * We need to retrieve the open stream and update the counts.
10724 * If there is no open stream here, something is wrong.
10725 */
10731 /* returns with 'os_sync_lock' held */
10734 }
10737 "nfs4_addmap: we should have an osp"
10741 }
10746 /*
10747 * Update the map count in the open stream.
10748 * This is necessary in the case where we
10749 * open/mmap/close/, then the server reboots, and we
10750 * attempt to reopen. If the mmap doesn't add share
10751 * access then we send an invalid reopen with
10752 * access = NONE.
10753 *
10754 * We need to specifically check each PROT_* so a mmap
10755 * call of (PROT_WRITE | PROT_EXEC) will ensure us both
10756 * read and write access. A simple comparison of prot
10757 * to ~PROT_WRITE to determine read access is insufficient
10758 * since prot can be |= with PROT_USER, etc.
10759 */
10761 /*
10762 * Unless we're MAP_SHARED, no sense in adding os_mmap_write
10763 */
10770 /*
10771 * Ensure that os_mmap_read gets incremented, even if
10772 * maxprot were to look like PROT_NONE.
10773 */
10780 }
10782 out:
10783 /*
10784 * If we got an error, then undo our
10785 * incrementing of 'r_mapcnt'.
10786 */
10791 }
10793 }
10795 /* ARGSUSED */
10796 static int
10798 {
10801 }
10803 /* ARGSUSED */
10804 static int
10808 {
10813 nfs4_error_t e;
10818 /* check for valid cmd parameter */
10822 /* Verify l_type. */
10838 }
10840 /* check the validity of the lock range */
10846 /*
10847 * If the filesystem is mounted using local locking, pass the
10848 * request off to the local locking code.
10849 */
10852 /*
10853 * For complete safety, we should be holding
10854 * r_lkserlock. However, we can't call
10855 * nfs4_safelock and then fs_frlock while
10856 * holding r_lkserlock, so just invoke
10857 * nfs4_safelock and expect that this will
10858 * catch enough of the cases.
10859 */
10862 }
10864 }
10868 /*
10869 * Check whether the given lock request can proceed, given the
10870 * current file mappings.
10871 */
10878 }
10879 }
10881 /*
10882 * Flush the cache after waiting for async I/O to finish. For new
10883 * locks, this is so that the process gets the latest bits from the
10884 * server. For unlocks, this is so that other clients see the
10885 * latest bits once the file has been unlocked. If currently dirty
10886 * pages can't be flushed, then don't allow a lock to be set. But
10887 * allow unlocks to succeed, to avoid having orphan locks on the
10888 * server.
10889 */
10904 }
10909 }
10910 }
10921 }
10925 }
10926 }
10927 }
10929 /*
10930 * Call the lock manager to do the real work of contacting
10931 * the server and obtaining the lock.
10932 */
10940 done:
10944 }
10946 /*
10947 * Free storage space associated with the specified vnode. The portion
10948 * to be freed is specified by bfp->l_start and bfp->l_len (already
10949 * normalized to a "whence" of 0).
10950 *
10951 * This is an experimental facility whose continued existence is not
10952 * guaranteed. Currently, we only support the special case
10953 * of l_len == 0, meaning free to end of file.
10954 */
10955 /* ARGSUSED */
10956 static int
10959 {
10982 }
10985 }
10987 /* ARGSUSED */
10988 int
10990 {
10996 }
10999 }
11001 /*
11002 * Setup and add an address space callback to do the work of the delmap call.
11003 * The callback will (and must be) deleted in the actual callback function.
11004 *
11005 * This is done in order to take care of the problem that we have with holding
11006 * the address space's a_lock for a long period of time (e.g. if the NFS server
11007 * is down). Callbacks will be executed in the address space code while the
11008 * a_lock is not held. Holding the address space's a_lock causes things such
11009 * as ps and fork to hang because they are trying to acquire this lock as well.
11010 */
11011 /* ARGSUSED */
11012 static int
11016 {
11026 /*
11027 * A process may not change zones if it has NFS pages mmap'ed
11028 * in, so we can't legitimately get here from the wrong zone.
11029 */
11034 /*
11035 * The way that the address space of this process deletes its mapping
11036 * of this file is via the following call chains:
11037 * - as_free()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs4_delmap()
11038 * - as_unmap()->segop_unmap()/segvn_unmap()->fop_delmap()/nfs4_delmap()
11039 *
11040 * With the use of address space callbacks we are allowed to drop the
11041 * address space lock, a_lock, while executing the NFS operations that
11042 * need to go over the wire. Returning EAGAIN to the caller of this
11043 * function is what drives the execution of the callback that we add
11044 * below. The callback will be executed by the address space code
11045 * after dropping the a_lock. When the callback is finished, since
11046 * we dropped the a_lock, it must be re-acquired and segvn_unmap()
11047 * is called again on the same segment to finish the rest of the work
11048 * that needs to happen during unmapping.
11049 *
11050 * This action of calling back into the segment driver causes
11051 * nfs4_delmap() to get called again, but since the callback was
11052 * already executed at this point, it already did the work and there
11053 * is nothing left for us to do.
11054 *
11055 * To Summarize:
11056 * - The first time nfs4_delmap is called by the current thread is when
11057 * we add the caller associated with this delmap to the delmap caller
11058 * list, add the callback, and return EAGAIN.
11059 * - The second time in this call chain when nfs4_delmap is called we
11060 * will find this caller in the delmap caller list and realize there
11061 * is no more work to do thus removing this caller from the list and
11062 * returning the error that was set in the callback execution.
11063 */
11066 /*
11067 * 'error' is from the actual delmap operations. To avoid
11068 * hangs, we need to handle the return of EAGAIN differently
11069 * since this is what drives the callback execution.
11070 * In this case, we don't want to return EAGAIN and do the
11071 * callback execution because there are none to execute.
11072 */
11075 else
11077 }
11079 /* current caller was not in the list */
11102 }
11106 {
11114 }
11116 static void
11118 {
11120 }
11122 /*
11123 * Searches for the current delmap caller (based on curthread) in the list of
11124 * callers. If it is found, we remove it and free the delmap caller.
11125 * Returns:
11126 * 0 if the caller wasn't found
11127 * 1 if the caller was found, removed and freed. *errp will be set
11128 * to what the result of the delmap was.
11129 */
11130 static int
11132 {
11135 /*
11136 * If the list doesn't exist yet, we create it and return
11137 * that the caller wasn't found. No list = no callers.
11138 */
11141 /* The list does not exist */
11148 /* The list exists so search it */
11153 /* current caller is in the list */
11159 }
11160 }
11161 }
11164 }
11166 /*
11167 * Remove some pages from an mmap'd vnode. Just update the
11168 * count of pages. If doing close-to-open, then flush and
11169 * commit all of the pages associated with this file.
11170 * Otherwise, start an asynchronous page flush to write out
11171 * any dirty pages. This will also associate a credential
11172 * with the rnode which can be used to write the pages.
11173 */
11174 /* ARGSUSED */
11175 static void
11177 {
11189 /*
11190 * Initiate a page flush and potential commit if there are
11191 * pages, the file system was not mounted readonly, the segment
11192 * was mapped shared, and the pages themselves were writeable.
11193 */
11207 }
11220 }
11222 /* Check to see if we need to close the file */
11229 /*
11230 * Since it is possible that e.error == 0 and
11231 * e.stat != NFS4_OK (and vice versa),
11232 * we do the proper checking in order to get both
11233 * e.error and e.stat reporting the correct info.
11234 */
11243 }
11244 }
11248 }
11251 static uint_t
11253 {
11258 }
11262 }
11265 }
11268 }
11271 }
11274 }
11277 }
11279 }
11281 static int
11283 {
11294 }
11296 /* ARGSUSED */
11297 int
11300 {
11302 hrtime_t t;
11304 nfs4_ga_res_t gar;
11305 nfs4_ga_ext_res_t ger;
11314 }
11318 }
11322 /*
11323 * The existence of the xattr directory is not sufficient
11324 * for determining whether generic user attributes exists.
11325 * The attribute directory could only be a transient directory
11326 * used for Solaris sysattr support. Do a small readdir
11327 * to verify if the only entries are sysattrs or not.
11328 *
11329 * pc4_xattr_valid can be only be trusted when r_xattr_dir
11330 * is NULL. Once the xadir vp exists, we can create xattrs,
11331 * and we don't have any way to update the "base" object's
11332 * pc4_xattr_exists from the xattr or xadir. Maybe FEM
11333 * could help out.
11334 */
11338 }
11368 }
11370 #ifdef DEBUG
11371 nfs4_pathconf_cache_hits++;
11372 #endif
11374 }
11376 }
11377 }
11378 #ifdef DEBUG
11379 nfs4_pathconf_cache_misses++;
11380 #endif
11392 }
11394 /* interpret the max filesize */
11398 /* Store the attributes we just received */
11421 }
11425 }
11428 }
11430 /*
11431 * Called by async thread to do synchronous pageio. Do the i/o, wait
11432 * for it to complete, and cleanup the page list when done.
11433 */
11434 static int
11437 {
11445 else
11448 }
11450 /* ARGSUSED */
11451 static int
11454 {
11471 nfs4_sync_pageio);
11479 }
11481 /* ARGSUSED */
11482 static void
11485 {
11490 offset3 offset;
11491 count3 len;
11492 k_sigset_t smask;
11494 /*
11495 * We should get called with fl equal to either B_FREE or
11496 * B_INVAL. Any other value is illegal.
11497 *
11498 * The page that we are either supposed to free or destroy
11499 * should be exclusive locked and its io lock should not
11500 * be held.
11501 */
11507 /*
11508 * If the page doesn't need to be committed or we shouldn't
11509 * even bother attempting to commit it, then just make sure
11510 * that the p_fsdata byte is clear and then either free or
11511 * destroy the page as appropriate.
11512 */
11517 else
11520 }
11522 /*
11523 * If there is a page invalidation operation going on, then
11524 * if this is one of the pages being destroyed, then just
11525 * clear the p_fsdata byte and then either free or destroy
11526 * the page as appropriate.
11527 */
11534 else
11537 }
11539 /*
11540 * If we are freeing this page and someone else is already
11541 * waiting to do a commit, then just unlock the page and
11542 * return. That other thread will take care of commiting
11543 * this page. The page can be freed sometime after the
11544 * commit has finished. Otherwise, if the page is marked
11545 * as delay commit, then we may be getting called from
11546 * pvn_write_done, one page at a time. This could result
11547 * in one commit per page, so we end up doing lots of small
11548 * commits instead of fewer larger commits. This is bad,
11549 * we want do as few commits as possible.
11550 */
11556 }
11562 }
11563 }
11565 /*
11566 * Check to see if there is a signal which would prevent an
11567 * attempt to commit the pages from being successful. If so,
11568 * then don't bother with all of the work to gather pages and
11569 * generate the unsuccessful RPC. Just return from here and
11570 * let the page be committed at some later time.
11571 */
11578 }
11581 /*
11582 * We are starting to need to commit pages, so let's try
11583 * to commit as many as possible at once to reduce the
11584 * overhead.
11585 *
11586 * Set the `commit inprogress' state bit. We must
11587 * first wait until any current one finishes. Then
11588 * we initialize the c_pages list with this page.
11589 */
11594 }
11602 /*
11603 * Gather together all other pages which can be committed.
11604 * They will all be chained off r_commit.c_pages.
11605 */
11608 /*
11609 * Clear the `commit inprogress' status and disconnect
11610 * the list of pages to be committed from the rnode.
11611 * At this same time, we also save the starting offset
11612 * and length of data to be committed on the server.
11613 */
11628 }
11630 /*
11631 * Actually generate the COMMIT op over the wire operation.
11632 */
11635 /*
11636 * If we got an error during the commit, just unlock all
11637 * of the pages. The pages will get retransmitted to the
11638 * server during a putpage operation.
11639 */
11645 }
11647 }
11649 /*
11650 * We've tried as hard as we can to commit the data to stable
11651 * storage on the server. We just unlock the rest of the pages
11652 * and clear the commit required state. They will be put
11653 * onto the tail of the cachelist if they are nolonger
11654 * mapped.
11655 */
11661 }
11663 /*
11664 * It is possible that nfs4_commit didn't return error but
11665 * some other thread has modified the page we are going
11666 * to free/destroy.
11667 * In this case we need to rewrite the page. Do an explicit check
11668 * before attempting to free/destroy the page. If modified, needs to
11669 * be rewritten so unlock the page and return.
11670 */
11675 }
11677 /*
11678 * Now, as appropriate, either free or destroy the page
11679 * that we were called with.
11680 */
11684 else
11686 }
11688 /*
11689 * Commit requires that the current fh be the file written to.
11690 * The compound op structure is:
11691 * PUTFH(file), COMMIT
11692 */
11693 static int
11695 {
11696 COMPOUND4args_clnt args;
11697 COMPOUND4res_clnt res;
11706 nfs4_recov_state_t recov_state;
11719 get_commit_cred:
11720 /*
11721 * Releases the osp, if a valid open stream is provided.
11722 * Puts a hold on the cred_otw and the new osp (if found).
11723 */
11727 recov_retry:
11728 /*
11729 * Commit ops: putfh file; commit
11730 */
11741 }
11743 /* putfh directory */
11747 /* commit */
11758 needrecov);
11765 }
11775 }
11783 }
11784 /* fall through for res.status case */
11785 }
11795 }
11796 /*
11797 * Can't do a nfs4_purge_stale_fh here because this
11798 * can cause a deadlock. nfs4_commit can
11799 * be called from nfs4_dispose which can be called
11800 * indirectly via pvn_vplist_dirty. nfs4_purge_stale_fh
11801 * can call back to pvn_vplist_dirty.
11802 */
11815 }
11830 }
11835 }
11844 }
11846 static void
11848 {
11851 /* make sure we're looking at the master vnode, not a shadow */
11853 }
11855 /*
11856 * This function is used to gather a page list of the pages which
11857 * can be committed on the server.
11858 *
11859 * The calling thread must have set R4COMMIT. This bit is used to
11860 * serialize access to the commit structure in the rnode. As long
11861 * as the thread has set R4COMMIT, then it can manipulate the commit
11862 * structure without requiring any other locks.
11863 *
11864 * When this function is called from nfs4_dispose() the page passed
11865 * into nfs4_dispose() will be SE_EXCL locked, and so this function
11866 * will skip it. This is not a problem since we initially add the
11867 * page to the r_commit page list.
11868 *
11869 */
11870 static void
11872 {
11880 /* make sure we're looking at the master vnode, not a shadow */
11887 /*
11888 * Step through all of the pages associated with this vnode
11889 * looking for pages which need to be committed.
11890 */
11894 /* Skip marker pages. */
11898 /*
11899 * First short-cut everything (without the page_lock)
11900 * and see if this page does not need to be committed
11901 * or is modified if so then we'll just skip it.
11902 */
11906 /*
11907 * Attempt to lock the page. If we can't, then
11908 * someone else is messing with it or we have been
11909 * called from nfs4_dispose and this is the page that
11910 * nfs4_dispose was called with.. anyway just skip it.
11911 */
11915 /*
11916 * Lets check again now that we have the page lock.
11917 */
11921 }
11923 /* this had better not be a free page */
11926 /*
11927 * The page needs to be committed and we locked it.
11928 * Update the base and length parameters and add it
11929 * to r_pages.
11930 */
11942 }
11944 }
11947 }
11949 /*
11950 * This routine is used to gather together a page list of the pages
11951 * which are to be committed on the server. This routine must not
11952 * be called if the calling thread holds any locked pages.
11953 *
11954 * The calling thread must have set R4COMMIT. This bit is used to
11955 * serialize access to the commit structure in the rnode. As long
11956 * as the thread has set R4COMMIT, then it can manipulate the commit
11957 * structure without requiring any other locks.
11958 */
11959 static void
11961 {
11965 uoff_t end;
11966 uoff_t off;
11973 /* make sure we're looking at the master vnode, not a shadow */
11978 /*
11979 * If there are no pages associated with this vnode, then
11980 * just return.
11981 */
11984 /*
11985 * Calculate the ending offset.
11986 */
11989 /*
11990 * Lookup each page by vp, offset.
11991 */
11994 /*
11995 * If this page does not need to be committed or is
11996 * modified, then just skip it.
11997 */
12001 }
12004 /*
12005 * The page needs to be committed and we locked it.
12006 * Update the base and length parameters and add it
12007 * to r_pages.
12008 */
12015 }
12017 }
12018 }
12020 /*
12021 * Called from nfs4_close(), nfs4_fsync() and nfs4_delmap().
12022 * Flushes and commits data to the server.
12023 */
12024 static int
12026 {
12028 verifier4 write_verf;
12033 /*
12034 * Flush the data portion of the file and then commit any
12035 * portions which need to be committed. This may need to
12036 * be done twice if the server has changed state since
12037 * data was last written. The data will need to be
12038 * rewritten to the server and then a new commit done.
12039 *
12040 * In fact, this may need to be done several times if the
12041 * server is having problems and crashing while we are
12042 * attempting to do this.
12043 */
12045 top:
12046 /*
12047 * Do a flush based on the poff and plen arguments. This
12048 * will synchronously write out any modified pages in the
12049 * range specified by (poff, plen). This starts all of the
12050 * i/o operations which will be waited for in the next
12051 * call to nfs4_putpage
12052 */
12062 /*
12063 * Do a flush based on the poff and plen arguments. This
12064 * will synchronously write out any modified pages in the
12065 * range specified by (poff, plen) and wait until all of
12066 * the asynchronous i/o's in that range are done as well.
12067 */
12078 }
12081 /*
12082 * Now commit any pages which might need to be committed.
12083 * If the error, NFS_VERF_MISMATCH, is returned, then
12084 * start over with the flush operation.
12085 */
12092 }
12094 /*
12095 * nfs4_commit_vp() will wait for other pending commits and
12096 * will either commit the whole file or a range, plen dictates
12097 * if we commit whole file. a value of zero indicates the whole
12098 * file. Called from nfs4_putpage_commit() or nfs4_sync_putapage()
12099 */
12100 static int
12103 {
12106 offset3 offset;
12107 count3 len;
12113 /*
12114 * before we gather commitable pages make
12115 * sure there are no outstanding async writes
12116 */
12121 }
12123 }
12125 /*
12126 * Set the `commit inprogress' state bit. We must
12127 * first wait until any current one finishes.
12128 */
12134 }
12138 /*
12139 * Gather all of the pages which need to be
12140 * committed.
12141 */
12144 else
12147 /*
12148 * Clear the `commit inprogress' bit and disconnect the
12149 * page list which was gathered by nfs4_get_commit.
12150 */
12160 /*
12161 * If any pages need to be committed, commit them and
12162 * then unlock them so that they can be freed some
12163 * time later.
12164 */
12168 /*
12169 * No error occurred during the flush portion
12170 * of this operation, so now attempt to commit
12171 * the data to stable storage on the server.
12172 *
12173 * This will unlock all of the pages on the list.
12174 */
12176 }
12178 static int
12181 {
12189 /*
12190 * If we got an error, then just unlock all of the pages
12191 * on the list.
12192 */
12198 }
12200 }
12201 /*
12202 * We've tried as hard as we can to commit the data to stable
12203 * storage on the server. We just unlock the pages and clear
12204 * the commit required state. They will get freed later.
12205 */
12211 }
12214 }
12216 static void
12219 {
12222 }
12224 /*ARGSUSED*/
12225 static int
12228 {
12231 vattr_t va;
12232 vsecattr_t nfsace4_vsap;
12238 /* if we have a delegation, return it */
12244 NFS4_ACL_SET);
12249 /*
12250 * These are aclent_t type entries.
12251 */
12257 /*
12258 * These are ace_t type entries.
12259 */
12261 FALSE);
12264 }
12269 }
12271 }
12273 /* ARGSUSED */
12274 int
12277 {
12280 nfs4_ga_res_t gar;
12290 /*
12291 * vsecattr->vsa_mask holds the original acl request mask.
12292 * This is needed when determining what to return.
12293 * (See: nfs4_create_getsecattr_return())
12294 */
12299 /*
12300 * If this is a referral stub, don't try to go OTW for an ACL
12301 */
12306 /*
12307 * Check if the data is cached and the cache is valid. If it
12308 * is we don't go over the wire.
12309 */
12320 }
12321 }
12323 }
12325 /*
12326 * The getattr otw call will always get both the acl, in
12327 * the form of a list of nfsace4's, and the number of acl
12328 * entries; independent of the value of gar.n4g_va.va_mask.
12329 */
12336 }
12339 /*
12340 * No error was returned, but according to the response
12341 * bitmap, neither was an acl.
12342 */
12346 }
12348 /*
12349 * Update the cache with the ACL.
12350 */
12361 }
12363 }
12366 }
12368 /*
12369 * The function returns:
12370 * - 0 (zero) if the passed in "acl_mask" is a valid request.
12371 * - EINVAL if the passed in "acl_mask" is an invalid request.
12372 *
12373 * In the case of getting an acl (op == NFS4_ACL_GET) the mask is invalid if:
12374 * - We have a mixture of ACE and ACL requests (e.g. VSA_ACL | VSA_ACE)
12375 *
12376 * In the case of setting an acl (op == NFS4_ACL_SET) the mask is invalid if:
12377 * - We have a mixture of ACE and ACL requests (e.g. VSA_ACL | VSA_ACE)
12378 * - We have a count field set without the corresponding acl field set. (e.g. -
12379 * VSA_ACECNT is set, but VSA_ACE is not)
12380 */
12381 static int
12383 {
12384 /* Shortcut the masks that are always valid. */
12391 /*
12392 * We can't have any VSA_ACL type stuff in the mask now.
12393 */
12395 VSA_DFACLCNT))
12401 }
12402 }
12405 /*
12406 * We can't have any VSA_ACE type stuff in the mask now.
12407 */
12418 }
12419 }
12421 }
12423 /*
12424 * The theory behind creating the correct getsecattr return is simply this:
12425 * "Don't return anything that the caller is not expecting to have to free."
12426 */
12427 static int
12430 {
12432 /* Save the mask since the translators modify it. */
12441 /*
12442 * If the caller only asked for the ace count (VSA_ACECNT)
12443 * don't give them the full acl (VSA_ACE), free it.
12444 */
12450 }
12451 }
12455 VSA_DFACLCNT)) {
12462 /*
12463 * If the caller only asked for the acl count (VSA_ACLCNT)
12464 * and/or the default acl count (VSA_DFACLCNT) don't give them
12465 * the acl (VSA_ACL) or default acl (VSA_DFACL), free it.
12466 */
12472 }
12473 }
12480 }
12481 }
12483 }
12485 }
12487 /* ARGSUSED */
12488 int
12491 {
12496 /*
12497 * check for valid cmd parameter
12498 */
12502 /*
12503 * Check access permissions
12504 */
12510 /*
12511 * If the filesystem is mounted using local locking, pass the
12512 * request off to the local share code.
12513 */
12520 /*
12521 * This will be properly implemented later,
12522 * see RFE: 4823948 .
12523 */
12528 /*
12529 * NFS client can't store remote locks itself
12530 */
12538 }
12541 }
12543 /*
12544 * Common code called by directory ops to update the attrcache
12545 */
12546 static int
12549 {
12555 /* getattr not done or failed */
12558 }
12564 }
12566 }
12568 /*
12569 * Update directory caches for directory modification ops (link, rename, etc.)
12570 * When dinfo is NULL, manage dircaches in the old way.
12571 */
12572 static void
12575 {
12580 /* Purge rddir cache for dir since it changed */
12584 /*
12585 * If caller provided dinfo, then use it to manage dir caches.
12586 */
12594 /*
12595 * XXX don't update if the created_v4 flag is
12596 * set
12597 */
12602 }
12603 }
12609 }
12611 /*
12612 * Caller didn't provide dinfo, then check change_info4 to update DNLC.
12613 * Since caller modified dir but didn't receive post-dirmod-op dir
12614 * attrs, the dir's attrs must be purged.
12615 *
12616 * XXX this check and dnlc update/purge should really be atomic,
12617 * XXX but can't use rnode statelock because it'll deadlock in
12618 * XXX dnlc_purge_vp, however, the risk is minimal even if a race
12619 * XXX does occur.
12620 *
12621 * XXX We also may want to check that atomic is true in the
12622 * XXX change_info struct. If it is not, the change_info may
12623 * XXX reflect changes by more than one clients which means that
12624 * XXX our cache may not be valid.
12625 */
12628 /* no changes took place in the directory prior to our link */
12635 /*
12636 * XXX dont' update if the created_v4 flag
12637 * is set
12638 */
12641 "nfs4_update_dircaches: don't"
12643 }
12644 }
12646 /* Another client modified directory - purge its dnlc cache */
12648 }
12649 }
12651 /*
12652 * The OPEN_CONFIRM operation confirms the sequence number used in OPENing a
12653 * file.
12654 *
12655 * The 'reopening_file' boolean should be set to TRUE if we are reopening this
12656 * file (ie: client recovery) and otherwise set to FALSE.
12657 *
12658 * 'nfs4_start/end_op' should have been called by the proper (ie: not recovery
12659 * initiated) calling functions.
12660 *
12661 * 'resend' is set to TRUE if this is a OPEN_CONFIRM issued as a result
12662 * of resending a 'lost' open request.
12663 *
12664 * 'num_bseqid_retryp' makes sure we don't loop forever on a broken
12665 * server that hands out BAD_SEQID on open confirm.
12666 *
12667 * Errors are returned via the nfs4_error_t parameter.
12668 */
12669 void
12673 {
12674 COMPOUND4args_clnt args;
12675 COMPOUND4res_clnt res;
12684 #if DEBUG
12688 #endif
12690 recov_retry_confirm:
12696 else
12702 /* putfh target fh */
12719 }
12743 }
12744 }
12753 }
12754 /* State may have changed so retry the entire OPEN op */
12757 else
12762 }
12767 }
12774 }
12776 /*
12777 * Return the credentials associated with a client state object. The
12778 * caller is responsible for freeing the credentials.
12779 */
12783 {
12786 /*
12787 * It's ok to not lock the open stream and open owner to get
12788 * the oo_cred since this is only written once (upon creation)
12789 * and will not change.
12790 */
12795 }
12797 /*
12798 * nfs4_find_sysid
12799 *
12800 * Find the sysid for the knetconfig associated with the given mi.
12801 */
12804 {
12807 /*
12808 * Switch from RDMA knconf to original mount knconf
12809 */
12812 }
12814 #ifdef DEBUG
12815 /*
12816 * Return a string version of the call type for easy reading.
12817 */
12820 {
12834 }
12835 }
12836 #endif
12838 /*
12839 * Map the frlock cmd and lock type to the NFSv4 over-the-wire lock type
12840 * Unlock requests don't have an over-the-wire locktype, so we just return
12841 * something non-threatening.
12842 */
12844 static nfs_lock_type4
12846 {
12855 else
12860 else
12862 }
12864 /*NOTREACHED*/
12865 }
12867 /*
12868 * Do some preliminary checks for nfs4frlock.
12869 */
12870 static int
12872 uoff_t offset)
12873 {
12876 /*
12877 * If we are setting a lock, check that the file is opened
12878 * with the correct mode.
12879 */
12884 "nfs4frlock_validate_args: file was opened with "
12887 }
12888 }
12890 /* Convert the offset. It may need to be restored before returning. */
12894 error));
12896 }
12899 }
12901 /*
12902 * Set the flock64's lm_sysid for nfs4frlock.
12903 */
12904 static int
12906 {
12909 /* Find the lm_sysid */
12916 }
12921 }
12923 /*
12924 * Do the remaining preliminary setup for nfs4frlock.
12925 */
12926 static void
12930 {
12931 /*
12932 * set tick_delay to the base delay time.
12933 * (NFS4_BASE_WAIT_TIME is in secs)
12934 */
12938 /*
12939 * If lock is relative to EOF, we need the newest length of the
12940 * file. Therefore invalidate the ATTR_CACHE.
12941 */
12951 }
12953 /*
12954 * Initialize and allocate the data structures necessary for
12955 * the nfs4frlock call.
12956 * Allocates argsp's op array.
12957 */
12958 static void
12963 {
12972 /* fill array with zero */
12981 /* initialize in case of error; will get real value down below */
12986 else
12988 }
12990 /*
12991 * Call the nfs4_start_fop() for nfs4frlock, if necessary. Assign
12992 * the proper nfs4_server_t for this instance of nfs4frlock.
12993 * Returns 0 (success) or an errno value.
12994 */
12995 static int
12999 {
13014 }
13019 /* If the file failed recovery, just quit. */
13023 }
13025 }
13028 }
13030 /*
13031 * Setup the LOCK4/LOCKU4 arguments for resending a lost lock request. A
13032 * resend nfs4frlock call is initiated by the recovery framework.
13033 * Acquires the lop and oop seqid synchronization.
13034 */
13035 static void
13040 {
13056 }
13058 /* Must resend this lost lock/locku request. */
13097 }
13124 }
13125 }
13126 }
13128 /*
13129 * Setup the LOCKT4 arguments.
13130 */
13131 static void
13135 {
13144 /*
13145 * The locktype will be READ_LT unless it's
13146 * a write lock. We do this because the Solaris
13147 * system call allows the combination of
13148 * F_UNLCK and F_GETLK* and so in that case the
13149 * unlock is mapped to a read.
13150 */
13153 else
13157 /* set the lock owner4 args */
13167 }
13169 /*
13170 * If the client is holding a delegation, and the open stream to be used
13171 * with this lock request is a delegation open stream, then re-open the stream.
13172 * Sets the nfs4_error_t to all zeros unless the open stream has already
13173 * failed a reopen or we couldn't find the open stream. NFS4ERR_DELAY
13174 * means the caller should retry (like a recovery retry).
13175 */
13176 static void
13178 {
13179 open_delegation_type4 dt;
13182 open_claim_type4 oclaim;
13201 }
13202 /* returns with 'os_sync_lock' held */
13208 }
13213 "nfs4frlock_check_deleg: os_failed_reopen set "
13221 }
13223 /*
13224 * Determine whether a reopen is needed. If this
13225 * is a delegation open stream, then send the open
13226 * to the server to give visibility to the open owner.
13227 * Even if it isn't a delegation open stream, we need
13228 * to check if the previous open CLAIM_DELEGATE_CUR
13229 * was sufficient.
13230 */
13242 /*
13243 * Always use CLAIM_PREVIOUS after server reboot.
13244 * The server will reject CLAIM_DELEGATE_CUR if
13245 * it is used during the grace period.
13246 */
13254 }
13261 }
13262 }
13265 }
13266 }
13268 /*
13269 * Setup the LOCKU4 arguments.
13270 * Returns errors via the nfs4_error_t.
13271 * NFS4_OK no problems. *go_otwp is TRUE if call should go
13272 * over-the-wire. The caller must release the
13273 * reference on *lopp.
13274 * NFS4ERR_DELAY caller should retry (like recovery retry)
13275 * (other) unrecoverable error.
13276 */
13277 static void
13283 {
13286 pid_t pid;
13300 else
13305 /* locktype should be set to any legal value */
13311 /*
13312 * Get the lock owner stateid. If no lock owner
13313 * exists, return success.
13314 */
13320 /*
13321 * No lock owner so no locks to unlock.
13322 * Return success. If there was a failed
13323 * reclaim earlier, the lock might still be
13324 * registered with the local locking code,
13325 * so notify it of the unlock.
13326 *
13327 * If the lockowner is using a special stateid,
13328 * then the original lock request (that created
13329 * this lockowner) was never successful, so we
13330 * have no lock to undo OTW.
13331 */
13333 "nfs4frlock_setup_locku_args: LOCKU: no lock owner "
13339 /*
13340 * Release our hold and NULL out so final_cleanup
13341 * doesn't try to end a lock seqid sync we
13342 * never started.
13343 */
13347 }
13351 }
13358 }
13365 /* leave the ref count on lop, rele after RPC call */
13373 }
13375 /*
13376 * Setup the LOCK4 arguments.
13377 *
13378 * Returns errors via the nfs4_error_t.
13379 * NFS4_OK no problems
13380 * NFS4ERR_DELAY caller should retry (like recovery retry)
13381 * (other) unrecoverable error
13382 */
13383 static void
13388 {
13393 pid_t pid;
13407 else
13412 /*
13413 * Get the lock owner. If no lock owner exists,
13414 * create a 'temporary' one and grab the open seqid
13415 * synchronization (which puts a hold on the open
13416 * owner and open stream).
13417 * This also grabs the lock seqid synchronization.
13418 */
13434 out:
13438 }
13440 /*
13441 * After we get the reply from the server, record the proper information
13442 * for possible resend lock requests.
13443 */
13444 static void
13449 {
13459 "nfs4frlock_save_lost_rqst: set lo_pending_rqsts to 1 "
13465 }
13470 /*
13471 * For lock/locku requests, we treat EINTR as ETIMEDOUT for
13472 * recovery purposes so that the lock request that was sent
13473 * can be saved and re-issued later. Ditto for EIO from a forced
13474 * unmount. This is done to have the client's local locking state
13475 * match the v4 server's state; that is, the request was
13476 * potentially received and accepted by the server but the client
13477 * thinks it was not.
13478 */
13483 "nfs4frlock_save_lost_rqst: got a lost %s lock for "
13491 }
13492 /*
13493 * Objects are held and rele'd via the recovery code.
13494 * See nfs4_save_lost_rqst.
13495 */
13513 }
13515 }
13516 }
13518 /*
13519 * Update lop's seqid. Also update the seqid stored in a resend request,
13520 * if any. (Some recovery errors increment the seqid, and we may have to
13521 * send the resend request again.)
13522 */
13524 static void
13527 {
13534 }
13538 }
13539 }
13541 /*
13542 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13543 * COMPOUND4 args/res for calls that need to retry.
13544 * Switches the *cred_otwp to base_cr.
13545 */
13546 static void
13552 {
13560 needrecov);
13562 }
13578 }
13580 /* need to free up the reference on osp for lock args */
13584 }
13586 /* need to free up the reference on oop for lock args */
13591 }
13596 }
13598 /*
13599 * Function to process the client's recovery for nfs4frlock.
13600 * Returns TRUE if we should retry the lock request; FALSE otherwise.
13601 *
13602 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13603 * COMPOUND4 args/res for calls that need to retry.
13604 *
13605 * Note: the rp's r_lkserlock is *not* dropped during this path.
13606 */
13607 static bool_t
13615 {
13635 nfs_opnum4 op;
13640 seqid4 seqid;
13646 else
13653 }
13657 }
13666 }
13668 /*
13669 * Return that we do not want to retry the request for 3 cases:
13670 * 1. If we received EINTR or are bailing out because of a forced
13671 * unmount, we came into this code path just for the sake of
13672 * initiating recovery, we now need to return the error.
13673 * 2. If we have aborted recovery.
13674 * 3. We received NFS4ERR_BAD_SEQID.
13675 */
13682 needrecov);
13684 }
13701 }
13706 }
13710 /* need to free up the reference on osp for lock args */
13714 }
13716 /* need to free up the reference on oop for lock args */
13721 }
13724 }
13726 /*
13727 * Handles the successful reply from the server for nfs4frlock.
13728 */
13729 static void
13733 {
13739 /*
13740 * We do not register lost locks locally in
13741 * the 'resend' case since the user/application
13742 * doesn't think we have the lock.
13743 */
13746 }
13747 }
13748 }
13750 /*
13751 * Handle the DENIED reply from the server for nfs4frlock.
13752 * Returns TRUE if we should retry the request; FALSE otherwise.
13753 *
13754 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13755 * COMPOUND4 args/res for calls that need to retry. Can also
13756 * drop and regrab the r_lkserlock.
13757 */
13758 static bool_t
13768 {
13777 /*
13778 * Blocking lock needs to sleep and retry from the request.
13779 *
13780 * Do not block and wait for 'resend' or 'reinstate'
13781 * lock requests, just return the error.
13782 *
13783 * Note: reclaim requests have cmd == F_SETLK, not F_SETLKW.
13784 */
13811 }
13816 }
13827 }
13832 /*
13833 * Make sure we are still safe to lock with
13834 * regards to mmapping.
13835 */
13839 }
13842 }
13856 /* according to NLM code */
13861 }
13863 }
13865 /*
13866 * Handles all NFS4 errors besides NFS4_OK and NFS4ERR_DENIED for nfs4frlock.
13867 */
13868 static void
13870 {
13904 "nfs4frlock_results_default: got unrecognizable "
13907 }
13908 }
13910 /*
13911 * The lock request was successful, so update the client's state.
13912 */
13913 static void
13918 {
13925 /* update the stateid with server's response */
13931 }
13935 /*
13936 * If the lock was the result of a resending a lost
13937 * request, we've synched up the stateid and seqid
13938 * with the server, but now the server might be out of sync
13939 * with what the application thinks it has for locks.
13940 * Clean that up here. It's unclear whether we should do
13941 * this even if the filesystem has been forcibly unmounted.
13942 * For most servers, it's probably wasted effort, but
13943 * RFC 7530 lets servers require that unlocks exactly match
13944 * the locks that are held.
13945 */
13951 }
13957 /* Update the stateid with the server's response */
13960 /* Switch the lock type to express success, see fcntl */
13963 }
13964 }
13966 /*
13967 * Do final cleanup before exiting nfs4frlock.
13968 * Calls nfs4_end_fop, drops the seqid syncs, and frees up the
13969 * COMPOUND4 args/res for calls that haven't already.
13970 */
13971 static void
13980 {
13988 /*
13989 * The client recovery code wants the raw status information,
13990 * so don't map the NFS status code to an errno value for
13991 * non-normal call types.
13992 */
13998 needrecov);
14000 /*
14001 * We've established a new lock on the server, so invalidate
14002 * the pages associated with the vnode to get the most up to
14003 * date pages from the server after acquiring the lock. We
14004 * want to be sure that the read operation gets the newest data.
14005 * N.B.
14006 * We used to do this in nfs4frlock_results_ok but that doesn't
14007 * work since fop_putpage can call nfs4_commit which calls
14008 * nfs4_start_fop. We flush the pages below after calling
14009 * nfs4_end_fop above
14010 * The flush of the page cache must be done after
14011 * nfs4_end_open_seqid_sync() to avoid a 4-way hang.
14012 */
14015 }
14026 }
14028 /* free the reference on the lock owner */
14032 }
14034 /* need to free up the reference on osp for lock args */
14038 /* need to free up the reference on oop for lock args */
14042 }
14051 /*
14052 * Record debug information in the event we get EINVAL.
14053 */
14059 "%s operation failed with "
14060 "EINVAL probably since the server, %s,"
14065 }
14066 }
14071 }
14073 /*
14074 * This calls the server and the local locking code.
14075 *
14076 * Client locks are registerred locally by oring the sysid with
14077 * LM_SYSID_CLIENT. The server registers locks locally using just the sysid.
14078 * We need to distinguish between the two to avoid collision in case one
14079 * machine is used as both client and server.
14080 *
14081 * Blocking lock requests will continually retry to acquire the lock
14082 * forever.
14083 *
14084 * The ctype is defined as follows:
14085 * NFS4_LCK_CTYPE_NORM: normal lock request.
14086 *
14087 * NFS4_LCK_CTYPE_RECLAIM: bypass the usual calls for synchronizing with client
14088 * recovery, get the pid from flk instead of curproc, and don't reregister
14089 * the lock locally.
14090 *
14091 * NFS4_LCK_CTYPE_RESEND: same as NFS4_LCK_CTYPE_RECLAIM, with the addition
14092 * that we will use the information passed in via resend_rqstp to setup the
14093 * lock/locku request. This resend is the exact same request as the 'lost
14094 * lock', and is initiated by the recovery framework. A successful resend
14095 * request can initiate one or more reinstate requests.
14096 *
14097 * NFS4_LCK_CTYPE_REINSTATE: same as NFS4_LCK_CTYPE_RESEND, except that it
14098 * does not trigger additional reinstate requests. This lock call type is
14099 * set for setting the v4 server's locking state back to match what the
14100 * client's local locking state is in the event of a received 'lost lock'.
14101 *
14102 * Errors are returned via the nfs4_error_t parameter.
14103 */
14104 void
14108 {
14124 nfs4_recov_state_t recov_state;
14126 nfs4_op_hint_t op_hint;
14127 nfs4_lost_rqst_t lost_rqst;
14134 #ifdef DEBUG
14136 #endif
14140 #ifdef DEBUG
14150 #endif
14162 recov_retry:
14174 /*
14175 * Leave the request for the recovery system to deal with.
14176 */
14194 }
14198 }
14200 /* putfh directory fh */
14204 /*
14205 * Set up the over-the-wire arguments and get references to the
14206 * open owner, etc.
14207 */
14231 else
14243 /* recov thread never gets this error */
14260 }
14267 }
14271 }
14273 /* XXX should we use the local reclock as a cache ? */
14274 /*
14275 * Unregister the lock with the local locking code before
14276 * contacting the server. This avoids a potential race where
14277 * another process gets notified that it has been granted a lock
14278 * before we can unregister ourselves locally.
14279 */
14284 }
14286 /*
14287 * Send the server the lock request. Continually loop with a delay
14288 * if get error NFS4ERR_DENIED (for blocking locks) or NFS4ERR_GRACE.
14289 */
14304 }
14306 /*
14307 * Do the OTW call.
14308 */
14322 /*
14323 * Check if one of these mutually exclusive error cases has
14324 * happened:
14325 * need to swap credentials due to access error
14326 * recovery is needed
14327 * different error (only known case is missing Kerberos ticket)
14328 */
14337 }
14340 /*
14341 * LOCKT requests don't need to recover from lost
14342 * requests since they don't create/modify state.
14343 */
14346 lockt_args)
14348 /*
14349 * Do not attempt recovery for requests initiated by
14350 * the recovery framework. Let the framework redrive them.
14351 */
14356 }
14372 }
14374 }
14376 /*
14377 * Bail out if have reached this point with ep->error set. Can
14378 * happen if (ep->error == EACCES && !needrecov && cred_otw == cr).
14379 * This happens if Kerberos ticket has expired or has been
14380 * destroyed.
14381 */
14385 /*
14386 * Process the reply.
14387 */
14392 resend_rqstp);
14393 /*
14394 * Have a successful lock operation, now update state.
14395 */
14413 }
14415 /*
14416 * If the server won't let us reclaim, fall-back to trying to lock
14417 * the file from scratch. Code elsewhere will check the changeinfo
14418 * to ensure the file hasn't been changed.
14419 */
14426 /* clean up before retrying */
14432 }
14433 /* FALLTHROUGH */
14438 }
14439 out:
14440 /*
14441 * Process and cleanup from error. Make interrupted unlock
14442 * requests look successful, since they will be handled by the
14443 * client recovery code.
14444 */
14453 }
14455 /*
14456 * nfs4_safelock:
14457 *
14458 * Return non-zero if the given lock request can be handled without
14459 * violating the constraints on concurrent mapping and locking.
14460 */
14462 static int
14464 {
14479 /*
14480 * If the file is already mapped and there are locks, then they
14481 * should be all safe locks. So adding or removing a lock is safe
14482 * as long as the new request is safe (i.e., whole-file, meaning
14483 * length and starting offset are both zero).
14484 */
14488 "cannot lock a memory mapped file unless locking the "
14492 }
14494 /* mandatory locking and mapping don't mix */
14501 }
14506 }
14509 }
14512 /*
14513 * Register the lock locally within Solaris.
14514 * As the client, we "or" the sysid with LM_SYSID_CLIENT when
14515 * recording locks locally.
14516 *
14517 * This should handle conflicts/cooperation with NFS v2/v3 since all locks
14518 * are registered locally.
14519 */
14520 void
14522 uoff_t offset)
14523 {
14526 #ifdef DEBUG
14528 #endif
14532 #ifdef DEBUG
14540 #endif
14542 /* register the lock with local locking */
14546 #ifdef DEBUG
14549 "nfs4_register_lock_locally: could not register with"
14559 "blocked by pid %d sysid 0x%x type %d "
14563 }
14564 #endif
14566 }
14568 /*
14569 * nfs4_lockrelease:
14570 *
14571 * Release any locks on the given vnode that are held by the current
14572 * process. Also removes the lock owner (if one exists) from the rnode's
14573 * list.
14574 */
14575 static int
14577 {
14578 flock64_t ld;
14582 nfs4_recov_state_t recov_state;
14585 bool_t recovonly;
14593 /*
14594 * If we have not locked anything then we can
14595 * just return since we have no work to do.
14596 */
14599 }
14601 /*
14602 * We need to comprehend that another thread may
14603 * kick off recovery and the lock_owner we have stashed
14604 * in lop might be invalid so we should NOT cache it
14605 * locally!
14606 */
14616 }
14620 /*
14621 * Check if the lock owner might have a lock (request was sent but
14622 * no response was received). Also check if there are any remote
14623 * locks on the file. (In theory we shouldn't have to make this
14624 * second check if there's no lock owner, but for now we'll be
14625 * conservative and do it anyway.) If either condition is true,
14626 * send an unlock for the entire file to the server.
14627 *
14628 * Note that no explicit synchronization is needed here. At worst,
14629 * flk_has_remote_locks() will return a false positive, in which case
14630 * the unlock call wastes time but doesn't harm correctness.
14631 */
14638 }
14643 "nfs4_lockrelease: possible orphan %d, remote locks %d, for "
14657 /*
14658 * If fop_frlock fails, make sure we unregister
14659 * local locks before we continue.
14660 */
14664 "nfs4_lockrelease: lock release error on vp"
14666 }
14667 }
14678 }
14680 /*
14681 * So, here we're going to need to retrieve the lock-owner
14682 * again (in case recovery has done a switch-a-roo) and
14683 * remove it because we can.
14684 */
14690 }
14694 }
14696 /*
14697 * Wait for 'tick_delay' clock ticks.
14698 * Implement exponential backoff until hit the lease_time of this nfs4_server.
14699 * NOTE: lock_lease_time is in seconds.
14700 *
14701 * XXX For future improvements, should implement a waiting queue scheme.
14702 */
14703 static int
14705 {
14709 /* wait tick_delay clock ticks or siginteruptus */
14712 }
14714 "reissue the lock request: blocked for %ld clock ticks: %ld "
14717 /* get the lease time */
14720 /* drv_hztousec converts ticks to microseconds */
14726 }
14728 }
14731 void
14733 {
14734 }
14736 void
14738 {
14739 }
14741 /*
14742 * Return a reference to the directory (parent) vnode for a given vnode,
14743 * using the saved pathname information and the directory file handle. The
14744 * caller is responsible for disposing of the reference.
14745 * Returns zero or an errno value.
14746 *
14747 * Caller should set need_start_op to FALSE if it is the recovery
14748 * thread, or if a start_fop has already been done. Otherwise, TRUE.
14749 */
14750 int
14752 {
14763 nfs_fh4 fh;
14784 }
14792 }
14798 }
14806 }
14811 }
14819 }
14822 }
14824 /*
14825 * Copy the (final) component name of vp to fnamep. maxlen is the maximum
14826 * length that fnamep can accept, including the trailing null.
14827 * Returns 0 if okay, returns an errno value if there was a problem.
14828 */
14830 int
14832 {
14838 /*
14839 * If the file being opened has VROOT set, then this is
14840 * a "file" mount. sv_name will not be interesting, so
14841 * go back to the servinfo4 to get the original mount
14842 * path and strip off all but the final edge. Otherwise
14843 * just return the name from the shadow vnode.
14844 */
14854 else
14855 fn++;
14859 }
14864 else
14869 else
14873 }
14875 /*
14876 * Bookkeeping for a close that doesn't need to go over the wire.
14877 * *have_lockp is set to 0 if 'os_sync_lock' is released; otherwise
14878 * it is left at 1.
14879 */
14880 void
14882 {
14898 }
14900 /*
14901 * This removes the reference obtained at OPEN; ie,
14902 * when the open stream structure was created.
14903 *
14904 * We don't have to worry about calling 'open_stream_rele'
14905 * since we our currently holding a reference to this
14906 * open stream which means the count can not go to 0 with
14907 * this decrement.
14908 */
14916 }
14918 /*
14919 * Close all remaining open streams on the rnode. These open streams
14920 * could be here because:
14921 * - The close attempted at either close or delmap failed
14922 * - Some kernel entity did fop_open but never did fop_close
14923 * - Someone did mknod on a regular file but never opened it
14924 */
14925 int
14927 {
14938 /*
14939 * At this point, all we know is that the last time
14940 * someone called vn_rele, the count was 1. Since then,
14941 * the vnode could have been re-activated. We want to
14942 * loop through the open streams and close each one, but
14943 * we have to be careful since once we release the rnode
14944 * hash bucket lock, someone else is free to come in and
14945 * re-activate the rnode and add new open streams. The
14946 * strategy is take the rnode hash bucket lock, verify that
14947 * the count is still 1, grab the open stream off the
14948 * head of the list and mark it invalid, then release the
14949 * rnode hash bucket lock and proceed with that open stream.
14950 * This is ok because nfs4close_one() will acquire the proper
14951 * open/create to close/destroy synchronization for open
14952 * streams, and will ensure that if someone has reopened
14953 * the open stream after we've dropped the hash bucket lock
14954 * then we'll just simply return without destroying the
14955 * open stream.
14956 * Repeat until the list is empty.
14957 */
14961 /* make sure vnode hasn't been reactivated */
14968 }
14969 /*
14970 * Grabbing r_os_lock before releasing v_lock prevents
14971 * a window where the rnode/open stream could get
14972 * reactivated (and os_force_close set to 0) before we
14973 * had a chance to set os_force_close to 1.
14974 */
14980 /* nothing left to CLOSE OTW, so return */
14984 }
14987 /* the file can't still be mem mapped */
14993 /*
14994 * Grab a ref on this open stream; nfs4close_one
14995 * will mark it as invalid
14996 */
15006 /* Update error if it isn't already non-zero */
15012 }
15014 #ifdef DEBUG
15015 nfs4close_all_cnt++;
15016 #endif
15017 /* Release the ref on osp acquired above. */
15020 /* Proceed to the next open stream, if any */
15021 }
15023 }
15025 /*
15026 * nfs4close_one - close one open stream for a file if needed.
15027 *
15028 * "close_type" indicates which close path this is:
15029 * CLOSE_NORM: close initiated via fop_close.
15030 * CLOSE_DELMAP: close initiated via fop_delmap.
15031 * CLOSE_FORCE: close initiated via fop_inactive. This path forces
15032 * the close and release of client state for this open stream
15033 * (unless someone else has the open stream open).
15034 * CLOSE_RESEND: indicates the request is a replay of an earlier request
15035 * (e.g., due to abort because of a signal).
15036 * CLOSE_AFTER_RESEND: close initiated to "undo" a successful resent OPEN.
15037 *
15038 * CLOSE_RESEND and CLOSE_AFTER_RESEND will not attempt to retry after client
15039 * recovery. Instead, the caller is expected to deal with retries.
15040 *
15041 * The caller can either pass in the osp ('provided_osp') or not.
15042 *
15043 * 'access_bits' represents the access we are closing/downgrading.
15044 *
15045 * 'len', 'prot', and 'mmap_flags' are used for CLOSE_DELMAP. 'len' is the
15046 * number of bytes we are unmapping, 'maxprot' is the mmap protection, and
15047 * 'mmap_flags' tells us the type of sharing (MAP_PRIVATE or MAP_SHARED).
15048 *
15049 * Errors are returned via the nfs4_error_t.
15050 */
15051 void
15055 uint_t mmap_flags)
15056 {
15063 nfs4_recov_state_t recov_state;
15088 /*
15089 * First get the open owner.
15090 */
15097 }
15101 "nfs4close_one: no oop, rp %p, mi %p, cr %p, osp %p, "
15106 }
15109 recov_retry:
15122 /*
15123 * Second synchronize with recovery.
15124 */
15132 /*
15133 * If we couldn't get start_fop, but have to
15134 * cleanup state, then at least acquire the
15135 * mi_recovlock so we can synchronize with
15136 * recovery.
15137 */
15144 }
15145 }
15147 /*
15148 * We cannot attempt to get the open seqid sync if nfs4_start_fop
15149 * set 'recovonly' to TRUE since most likely this is due to
15150 * reovery being active (MI4_RECOV_ACTIV). If recovery is active,
15151 * nfs4_start_open_seqid_sync() will fail with EAGAIN asking us
15152 * to retry, causing us to loop until recovery finishes. Plus we
15153 * don't need protection over the open seqid since we're not going
15154 * OTW, hence don't need to use the seqid.
15155 */
15157 /* need to grab the open owner sync before 'os_sync_lock' */
15167 }
15169 }
15171 /*
15172 * Third get an open stream and acquire 'os_sync_lock' to
15173 * sychronize the opening/creating of an open stream with the
15174 * closing/destroying of an open stream.
15175 */
15177 /* returns with 'os_sync_lock' held */
15182 }
15187 }
15192 /*
15193 * Fourth, do any special pre-OTW CLOSE processing
15194 * based on the specific close type.
15195 */
15203 }
15206 /* see if somebody reopened the open stream. */
15209 "nfs4close_one: skip CLOSE_FORCE as osp %p "
15214 }
15219 }
15221 /*
15222 * We can't depend on os_open_ref_count being 0 due to the
15223 * way executables are opened (VN_RELE to match a fop_open).
15224 */
15225 #ifdef NOTYET
15227 #endif
15230 "nfs4close_one: should panic here on an "
15231 "ASSERT(osp->os_open_ref_count == 0). Ignoring "
15235 }
15237 /*
15238 * There is the possibility that nfs4close_one()
15239 * for close_type == CLOSE_DELMAP couldn't find the
15240 * open stream, thus couldn't decrement its os_mapcnt;
15241 * therefore we can't use this ASSERT yet.
15242 */
15243 #ifdef NOTYET
15245 #endif
15247 }
15258 /* mirror the PROT_NONE check in nfs4_addmap() */
15264 }
15267 nfs4_lost_rqst_t lost_rqst;
15269 /* request should not already be in recovery queue */
15282 }
15284 /*
15285 * If a previous OTW call got NFS4ERR_BAD_SEQID, then
15286 * we stopped operating on the open owner's <old oo_name, old seqid>
15287 * space, which means we stopped operating on the open stream
15288 * too. So don't go OTW (as the seqid is likely bad, and the
15289 * stateid could be stale, potentially triggering a false
15290 * setclientid), and just clean up the client's internal state.
15291 */
15300 }
15302 /* If the file failed recovery, just quit. */
15306 }
15309 /*
15310 * If the force close path failed to obtain start_fop
15311 * then skip the OTW close and just remove the state.
15312 */
15316 /*
15317 * Fifth, check to see if there are still mapped pages or other
15318 * opens using this open stream. If there are then we can't
15319 * close yet but we can see if an OPEN_DOWNGRADE is necessary.
15320 */
15322 nfs4_lost_rqst_t new_lost_rqst;
15328 /*
15329 * If this open stream was never OPENed OTW then we
15330 * surely can't DOWNGRADE it (especially since the
15331 * osp->open_stateid is really a delegation stateid
15332 * when os_delegation is 1).
15333 */
15341 }
15346 bool_t abort;
15353 open_dg_seqid);
15374 }
15387 }
15389 }
15391 /*
15392 * If this open stream was created as the results of an open
15393 * while holding a delegation, then just release it; no need
15394 * to do an OTW close. Otherwise do a "normal" OTW close.
15395 */
15400 }
15402 /*
15403 * If this stream is not valid, we're done.
15404 */
15408 }
15410 /*
15411 * Last open or mmap ref has vanished, need to do an OTW close.
15412 * First check to see if a close is still necessary.
15413 */
15418 /*
15419 * Reopen of the open stream failed, hence the
15420 * stateid of the open stream is invalid/stale, and
15421 * sending this OTW would incorrectly cause another
15422 * round of recovery. In this case, we need to set
15423 * the 'os_valid' bit to 0 so another thread doesn't
15424 * come in and re-open this open stream before
15425 * this "closing" thread cleans up state (decrementing
15426 * the nfs4_server_t's state_ref_count and decrementing
15427 * the os_ref_count).
15428 */
15430 /*
15431 * This removes the reference obtained at OPEN; ie,
15432 * when the open stream structure was created.
15433 *
15434 * We don't have to worry about calling 'open_stream_rele'
15435 * since we our currently holding a reference to this
15436 * open stream which means the count can not go to 0 with
15437 * this decrement.
15438 */
15444 }
15448 /*
15449 * Sixth, try the CLOSE OTW.
15450 */
15455 /*
15456 * Let the recovery thread be responsible for
15457 * removing the state for CLOSE.
15458 */
15462 }
15464 /* See if we need to retry with a different cred */
15472 }
15481 }
15485 }
15494 "nfs4close_one: need to retry the close "
15497 }
15498 close_cleanup:
15499 /*
15500 * Seventh and lastly, process our results.
15501 */
15503 /*
15504 * It's ok to drop and regrab the 'os_sync_lock' since
15505 * nfs4close_notw() will recheck to make sure the
15506 * "close"/removal of state should happen.
15507 */
15511 }
15512 /*
15513 * This is last call, remove the ref on the open
15514 * stream created by open and clean everything up.
15515 */
15519 }
15530 }
15537 }
15539 }
15541 out:
15557 }
15558 }
15560 /*
15561 * Convert information returned by the server in the LOCK4denied
15562 * structure to the form required by fcntl.
15563 */
15564 static void
15566 {
15569 #ifdef DEBUG
15573 }
15574 #endif
15581 /*
15582 * If the blocking clientid matches our client id, then we can
15583 * interpret the lockowner (since we built it). If not, then
15584 * fabricate a sysid and pid. Note that the l_sysid field
15585 * in *flk already has the local sysid.
15586 */
15600 }
15605 /*
15606 * Construct a new sysid which should be different from
15607 * sysids of other systems.
15608 */
15612 }
15613 }
15615 static pid_t
15617 {
15633 }
15635 /*
15636 * Given a lock pointer, returns the length of that lock.
15637 * "end" is the last locked offset the "l_len" covers from
15638 * the start of the lock.
15639 */
15640 static off64_t
15642 {
15643 off64_t lock_end;
15647 else
15651 }
15653 /*
15654 * Given the end of a lock, it will return you the length "l_len" for that lock.
15655 */
15656 static off64_t
15658 {
15659 off64_t lock_len;
15664 else
15668 }
15670 /*
15671 * On given end for a lock it determines if it is the last locked offset
15672 * or not, if so keeps it as is, else adds one to return the length for
15673 * valid start.
15674 */
15675 static off64_t
15677 {
15680 else
15682 }
15684 /*
15685 * See if these two locks overlap, and if so return 1;
15686 * otherwise, return 0.
15687 */
15688 static int
15690 {
15701 }
15703 /*
15704 * Determine what the intersecting lock region is, and add that to the
15705 * 'nl_llpp' locklist in increasing order (by l_start).
15706 */
15707 static void
15710 {
15725 /* Find the starting point of the intersecting region */
15728 else
15731 /* Find the lenght of the intersecting region */
15734 else
15737 /*
15738 * Prepare the flock structure for the intersection found and insert
15739 * it into the new list in increasing l_start order. This list contains
15740 * intersections of locks registered by the client with the local host
15741 * and the lost lock.
15742 * The lock type of this lock is the same as that of the local_flp.
15743 */
15759 }
15761 /* first on the list */
15767 }
15774 }
15776 /*
15777 * Our local locking current state is potentially different than
15778 * what the NFSv4 server thinks we have due to a lost lock that was
15779 * resent and then received. We need to reset our "NFSv4" locking
15780 * state to match the current local locking state for this pid since
15781 * that is what the user/application sees as what the world is.
15782 *
15783 * We cannot afford to drop the open/lock seqid sync since then we can
15784 * get confused about what the current local locking state "is" versus
15785 * "was".
15786 *
15787 * If we are unable to fix up the locks, we send SIGLOST to the affected
15788 * process. This is not done if the filesystem has been forcibly
15789 * unmounted, in case the process has already exited and a new process
15790 * exists with the same pid.
15791 */
15792 static void
15795 {
15800 flock64_t ul_fl;
15805 /*
15806 * Find active locks for this vp from the local locking code.
15807 * Scan through this list and find out the locks that intersect with
15808 * the lost lock. Once we find the lock that intersects, add the
15809 * intersection area as a new lock to a new list "ri_llp". The lock
15810 * type of the intersection region lock added to ri_llp is the same
15811 * as that found in the active lock list, "list". The intersecting
15812 * region locks are added to ri_llp in increasing l_start order.
15813 */
15821 /*
15822 * Pick locks that belong to this pid/lockowner
15823 */
15828 }
15830 /*
15831 * Now we have the list of intersections with the lost lock. These are
15832 * the locks that were/are active before the server replied to the
15833 * last/lost lock. Issue these locks to the server here. Playing these
15834 * locks to the server will re-establish our current local locking state
15835 * with the v4 server.
15836 * If we get an error, send SIGLOST to the application for that lock.
15837 */
15841 "nfs4_reinstitute_local_lock_state: need to issue "
15847 /*
15848 * No need to relock what we already have
15849 */
15854 }
15856 /*
15857 * Now keeping the start of the lost lock as our reference parse the
15858 * newly created ri_llp locklist to find the ranges that we have locked
15859 * with the v4 server but not in the current local locking. We need
15860 * to unlock these ranges.
15861 * These ranges can also be reffered to as those ranges, where the lost
15862 * lock does not overlap with the locks in the ri_llp but are locked
15863 * since the server replied to the lost lock.
15864 */
15879 }
15881 "nfs4_reinstitute_local_lock_state: "
15891 }
15893 /*
15894 * In the case where the lost lock ends after all intersecting locks,
15895 * unlock the last part of the lost lock range.
15896 */
15899 "nfs4_reinstitute_local_lock_state: UNLOCK end of the "
15904 /*
15905 * Is it an to-EOF lock? if so unlock till the end
15906 */
15909 else
15913 }
15918 /* Free up our newly created locklist */
15923 }
15925 /*
15926 * Now return back to the original calling nfs4frlock()
15927 * and let us naturally drop our seqid syncs.
15928 */
15929 }
15931 /*
15932 * Create a lost state record for the given lock reinstantiation request
15933 * and push it onto the lost state queue.
15934 */
15935 static void
15938 {
15939 nfs4_lost_rqst_t req;
15940 nfs_lock_type4 locktype;
15952 }