| blob | 8732980e84100b3c0480ad195775f2c490d788e2 |
1 /*
2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Rick Macklem at The University of Guelph.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * @(#)nfs_vnops.c 8.16 (Berkeley) 5/27/95
37 * $FreeBSD: src/sys/nfs/nfs_vnops.c,v 1.150.2.5 2001/12/20 19:56:28 dillon Exp $
38 * $DragonFly: src/sys/vfs/nfs/nfs_vnops.c,v 1.80 2008/10/18 01:13:54 dillon Exp $
39 */
42 /*
43 * vnode op calls for Sun NFS version 2 and 3
44 */
48 #include <sys/param.h>
49 #include <sys/kernel.h>
50 #include <sys/systm.h>
51 #include <sys/resourcevar.h>
52 #include <sys/proc.h>
53 #include <sys/mount.h>
54 #include <sys/buf.h>
55 #include <sys/malloc.h>
56 #include <sys/mbuf.h>
57 #include <sys/namei.h>
58 #include <sys/nlookup.h>
59 #include <sys/socket.h>
60 #include <sys/vnode.h>
61 #include <sys/dirent.h>
62 #include <sys/fcntl.h>
63 #include <sys/lockf.h>
64 #include <sys/stat.h>
65 #include <sys/sysctl.h>
66 #include <sys/conf.h>
68 #include <vm/vm.h>
69 #include <vm/vm_extern.h>
70 #include <vm/vm_zone.h>
72 #include <sys/buf2.h>
74 #include <vfs/fifofs/fifo.h>
75 #include <vfs/ufs/dir.h>
77 #undef DIRBLKSIZ
87 #include <net/if.h>
88 #include <netinet/in.h>
89 #include <netinet/in_var.h>
91 #include <sys/thread2.h>
93 /* Defs */
94 #define TRUE 1
95 #define FALSE 0
100 #define nfs_poll vop_nopoll
131 /*
132 * Global vfs data structures for nfs
133 */
166 };
168 /*
169 * Special device vnode ops
170 */
183 };
197 };
237 #if 0
243 #endif
245 #define NFSV3ACCESS_ALL (NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY \
246 | NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE \
247 | NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP)
248 static int
251 {
256 u_int32_t rmode;
276 }
279 nfsmout:
281 }
283 /*
284 * nfs access vnode op.
285 * For nfs version 2, just return ok. File accesses may fail later.
286 * For nfs version 3, use the access rpc to check accessibility. If file modes
287 * are changed on the server, accesses might still fail later.
288 *
289 * nfs_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred)
290 */
291 static int
293 {
302 /*
303 * Disallow write attempts on filesystems mounted read-only;
304 * unless the file is a socket, fifo, or a block or character
305 * device resident on the filesystem.
306 */
315 }
316 }
318 /*
319 * The NFS protocol passes only the effective uid/gid over the wire but
320 * we need to check access against real ids if AT_EACCESS not set.
321 * Handle this case by cloning the credentials and setting the
322 * effective ids to the real ones.
323 */
330 }
332 /*
333 * For nfs v3, check to see if we have done this recently, and if
334 * so return our cached result instead of making an ACCESS call.
335 * If not, do an access rpc, otherwise you are stuck emulating
336 * ufs_access() locally using the vattr. This may not be correct,
337 * since the server may apply other access criteria such as
338 * client uid-->server uid mapping that we do not know about.
339 */
343 else
353 NFSV3ACCESS_DELETE);
356 }
357 /* XXX safety belt, only make blanket request if caching */
364 }
366 /*
367 * Does our cached result allow us to give a definite yes to
368 * this request?
369 */
376 /*
377 * Either a no, or a don't know. Go to the wire.
378 */
384 }
385 }
386 }
391 }
393 /*
394 * Attempt to prevent a mapped root from accessing a file
395 * which it shouldn't. We try to read a byte from the file
396 * if the user is root and the file is not zero length.
397 * After calling nfs_laccess, we should have the correct
398 * file size cached.
399 */
429 }
430 }
431 }
432 /*
433 * [re]record creds for reading and/or writing if access
434 * was granted. Assume the NFS server will grant read access
435 * for execute requests.
436 */
443 }
449 }
450 }
453 }
455 /*
456 * nfs open vnode op
457 * Check to see if the type is ok
458 * and that deletion is not in progress.
459 * For paged in text files, you will need to flush the page cache
460 * if consistency is lost.
461 *
462 * nfs_open(struct vnode *a_vp, int a_mode, struct ucred *a_cred,
463 * struct file *a_fp)
464 */
465 /* ARGSUSED */
466 static int
468 {
475 #ifdef DIAGNOSTIC
477 #endif
479 }
481 /*
482 * Save valid creds for reading and writing for later RPCs.
483 */
489 }
495 }
497 /*
498 * Clear the attribute cache only if opening with write access. It
499 * is unclear if we should do this at all here, but we certainly
500 * should not clear the cache unconditionally simply because a file
501 * is being opened.
502 */
506 /*
507 * For normal NFS, reconcile changes made locally verses
508 * changes made remotely. Note that VOP_GETATTR only goes
509 * to the wire if the cached attribute has timed out or been
510 * cleared.
511 *
512 * If local modifications have been made clear the attribute
513 * cache to force an attribute and modified time check. If
514 * GETATTR detects that the file has been changed by someone
515 * other then us it will set NRMODIFIED.
516 *
517 * If we are opening a directory and local changes have been
518 * made we have to invalidate the cache in order to ensure
519 * that we get the most up-to-date information from the
520 * server. XXX
521 */
529 }
530 }
541 }
544 }
546 /*
547 * nfs close vnode op
548 * What an NFS client should do upon close after writing is a debatable issue.
549 * Most NFS clients push delayed writes to the server upon close, basically for
550 * two reasons:
551 * 1 - So that any write errors may be reported back to the client process
552 * doing the close system call. By far the two most likely errors are
553 * NFSERR_NOSPC and NFSERR_DQUOT to indicate space allocation failure.
554 * 2 - To put a worst case upper bound on cache inconsistency between
555 * multiple clients for the file.
556 * There is also a consistency problem for Version 2 of the protocol w.r.t.
557 * not being able to tell if other clients are writing a file concurrently,
558 * since there is no way of knowing if the changed modify time in the reply
559 * is only due to the write for this client.
560 * (NFS Version 3 provides weak cache consistency data in the reply that
561 * should be sufficient to detect and handle this case.)
562 *
563 * The current code does the following:
564 * for NFS Version 2 - play it safe and flush/invalidate all dirty buffers
565 * for NFS Version 3 - flush dirty buffers to the server but don't invalidate
566 * or commit them (this satisfies 1 and 2 except for the
567 * case where the server crashes after this close but
568 * before the commit RPC, which is felt to be "good
569 * enough". Changing the last argument to nfs_flush() to
570 * a 1 would force a commit operation, if it is felt a
571 * commit is necessary now.
572 * for NQNFS - do nothing now, since 2 is dealt with via leases and
573 * 1 should be dealt with via an fsync() system call for
574 * cases where write errors are important.
575 *
576 * nfs_close(struct vnode *a_vp, int a_fflag)
577 */
578 /* ARGSUSED */
579 static int
581 {
590 /*
591 * Under NFSv3 we have dirty buffers to dispose of. We
592 * must flush them to the NFS server. We have the option
593 * of waiting all the way through the commit rpc or just
594 * waiting for the initial write. The default is to only
595 * wait through the initial write so the data is in the
596 * server's cache, which is roughly similar to the state
597 * a standard disk subsystem leaves the file in on close().
598 *
599 * We cannot clear the NLMODIFIED bit in np->n_flag due to
600 * potential races with other processes, and certainly
601 * cannot clear it if we don't commit.
602 */
605 /* np->n_flag &= ~NLMODIFIED; */
608 }
610 }
614 }
615 }
618 }
620 /*
621 * nfs getattr call from vfs.
622 *
623 * nfs_getattr(struct vnode *a_vp, struct vattr *a_vap)
624 */
625 static int
627 {
637 /*
638 * Update local times for special files.
639 */
642 /*
643 * First look in the cache.
644 */
653 }
662 }
665 nfsmout:
667 }
669 /*
670 * nfs setattr call.
671 *
672 * nfs_setattr(struct vnode *a_vp, struct vattr *a_vap, struct ucred *a_cred)
673 */
674 static int
676 {
684 off_t tsize;
687 #ifndef nolint
689 #endif
691 /*
692 * Setting of flags is not supported.
693 */
697 /*
698 * Disallow write attempts if the filesystem is mounted read-only.
699 */
707 /*
708 * truncation requested
709 */
726 /*
727 * Disallow write attempts if the filesystem is
728 * mounted read-only.
729 */
733 /*
734 * This is nasty. The RPCs we send to flush pending
735 * data often return attribute information which is
736 * cached via a callback to nfs_loadattrcache(), which
737 * has the effect of changing our notion of the file
738 * size. Due to flushed appends and other operations
739 * the file size can be set to virtually anything,
740 * including values that do not match either the old
741 * or intended file size.
742 *
743 * When this condition is detected we must loop to
744 * try the operation again. Hopefully no more
745 * flushing is required on the loop so it works the
746 * second time around. THIS CASE ALMOST ALWAYS
747 * HAPPENS!
748 */
750 again:
759 }
764 else
766 }
767 /*
768 * note: this loop case almost always happens at
769 * least once per truncation.
770 */
775 }
777 /*
778 * What to do. If we are modifying the mtime we lose
779 * mtime detection of changes made by the server or other
780 * clients. But programs like rsync/rdist/cpdup are going
781 * to call utimes a lot. We don't want to piecemeal sync.
782 *
783 * For now sync if any prior remote changes were detected,
784 * but allow us to lose track of remote changes made during
785 * the utimes operation.
786 */
794 }
795 }
796 }
799 /*
800 * Sanity check if a truncation was issued. This should only occur
801 * if multiple processes are racing on the same file.
802 */
811 }
816 }
818 }
820 /*
821 * Do an nfs setattr rpc.
822 */
823 static int
826 {
848 else
852 else
856 else
861 }
868 }
871 nfsmout:
873 }
875 static
876 void
878 {
881 else
885 }
887 /*
888 * NEW API CALL - replaces nfs_lookup(). However, we cannot remove
889 * nfs_lookup() until all remaining new api calls are implemented.
890 *
891 * Resolve a namecache entry. This function is passed a locked ncp and
892 * must call nfs_cache_setvp() on it as appropriate to resolve the entry.
893 */
894 static int
896 {
932 /*
933 * Cache negatve lookups to reduce NFS traffic, but use
934 * a fast timeout. Otherwise use a timeout of 1 tick.
935 * XXX we should add a namecache flag for no-caching
936 * to uncache the negative hit as soon as possible, but
937 * we cannot simply destroy the entry because it is used
938 * as a placeholder by the caller.
939 *
940 * The refactored nfs code will overwrite a non-zero error
941 * with 0 when we use ERROROUT(), so don't here.
942 */
946 NFS_LATTR_NOSHRINK);
950 }
954 }
956 /*
957 * Success, get the file handle, do various checks, and load
958 * post-operation data from the reply packet. Theoretically
959 * we should never be looking up "." so, theoretically, we
960 * should never get the same file handle as our directory. But
961 * we check anyway. XXX
962 *
963 * Note that no timeout is set for the positive cache hit. We
964 * assume, theoretically, that ESTALE returns will be dealt with
965 * properly to handle NFS races and in anycase we cannot depend
966 * on a timeout to deal with NFS open/create/excl issues so instead
967 * of a bad hack here the rest of the NFS client code needs to do
968 * the right thing.
969 */
983 }
985 }
988 NFS_LATTR_NOSHRINK));
990 NFS_LATTR_NOSHRINK));
993 }
997 nfsmout:
1002 else
1004 }
1006 }
1008 /*
1009 * 'cached' nfs directory lookup
1010 *
1011 * NOTE: cannot be removed until NFS implements all the new n*() API calls.
1012 *
1013 * nfs_lookup(struct vnode *a_dvp, struct vnode **a_vpp,
1014 * struct componentname *a_cnp)
1015 */
1016 static int
1018 {
1037 /*
1038 * Read-only mount check and directory check.
1039 */
1048 /*
1049 * Look it up in the cache. Note that ENOENT is only returned if we
1050 * previously entered a negative hit (see later on). The additional
1051 * nfsneg_cache_timeout check causes previously cached results to
1052 * be instantly ignored if the negative caching is turned off.
1053 */
1059 /*
1060 * Go to the wire.
1061 */
1075 NFS_LATTR_NOSHRINK);
1079 }
1084 }
1087 /*
1088 * Handle RENAME case...
1089 */
1095 }
1101 }
1105 NFS_LATTR_NOSHRINK));
1107 NFS_LATTR_NOSHRINK));
1110 }
1117 }
1119 }
1129 }
1136 }
1138 }
1148 }
1152 }
1154 }
1157 NFS_LATTR_NOSHRINK));
1159 NFS_LATTR_NOSHRINK));
1162 }
1163 #if 0
1164 /* XXX MOVE TO nfs_nremove() */
1168 }
1169 #endif
1173 nfsmout:
1178 }
1185 }
1188 else
1190 }
1191 }
1193 }
1195 /*
1196 * nfs read call.
1197 * Just call nfs_bioread() to do the work.
1198 *
1199 * nfs_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
1200 * struct ucred *a_cred)
1201 */
1202 static int
1204 {
1208 }
1210 /*
1211 * nfs readlink call
1212 *
1213 * nfs_readlink(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred)
1214 */
1215 static int
1217 {
1223 }
1225 /*
1226 * Do a readlink rpc.
1227 * Called by nfs_doio() from below the buffer cache.
1228 */
1229 int
1231 {
1245 NFS_LATTR_NOSHRINK));
1246 }
1253 }
1255 }
1258 nfsmout:
1260 }
1262 /*
1263 * nfs synchronous read rpc using UIO
1264 */
1265 int
1267 {
1272 off_t tmp_off;
1277 #ifndef nolint
1279 #endif
1300 }
1305 NFS_LATTR_NOSHRINK));
1310 }
1316 /*
1317 * Handle short-read from server (NFSv3). If EOF is not
1318 * flagged (and no error occurred), but retlen is less
1319 * then the request size, we must zero-fill the remainder.
1320 */
1324 }
1327 /*
1328 * Terminate loop on EOF or zero-length read.
1329 *
1330 * For NFSv2 a short-read indicates EOF, not zero-fill,
1331 * and also terminates the loop.
1332 */
1338 }
1339 }
1340 nfsmout:
1342 }
1344 /*
1345 * nfs write call
1346 */
1347 int
1350 {
1361 #ifndef DIAGNOSTIC
1364 #endif
1383 u_int32_t x;
1386 /* Set both "begin" and "current" to non-garbage. */
1393 }
1398 /*
1399 * The write RPC returns a before and after mtime. The
1400 * nfsm_wcc_data() macro checks the before n_mtime
1401 * against the before time and stores the after time
1402 * in the nfsnode's cached vattr and n_mtime field.
1403 * The NRMODIFIED bit will be set if the before
1404 * time did not match the original mtime.
1405 */
1423 }
1426 /*
1427 * Return the lowest committment level
1428 * obtained by any of the RPCs.
1429 */
1437 NFSX_V3WRITEVERF);
1443 NFSX_V3WRITEVERF);
1444 }
1445 }
1448 }
1454 }
1455 nfsmout:
1462 }
1464 /*
1465 * nfs mknod rpc
1466 * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
1467 * mode set to specify the file type and the size field for rdev.
1468 */
1469 static int
1472 {
1493 }
1496 }
1503 NFS_MAXNAMLEN));
1512 }
1521 }
1530 }
1535 }
1536 }
1539 }
1542 nfsmout:
1548 }
1553 }
1555 /*
1556 * nfs mknod vop
1557 * just call nfs_mknodrpc() to do the work.
1558 *
1559 * nfs_mknod(struct vnode *a_dvp, struct vnode **a_vpp,
1560 * struct componentname *a_cnp, struct vattr *a_vap)
1561 */
1562 /* ARGSUSED */
1563 static int
1565 {
1567 }
1570 /*
1571 * nfs file create call
1572 *
1573 * nfs_create(struct vnode *a_dvp, struct vnode **a_vpp,
1574 * struct componentname *a_cnp, struct vattr *a_vap)
1575 */
1576 static int
1578 {
1593 /*
1594 * Oops, not for me..
1595 */
1601 }
1604 again:
1611 NFS_MAXNAMLEN));
1617 #ifdef INET
1620 else
1621 #endif
1627 }
1636 }
1645 }
1650 }
1651 }
1655 else
1657 }
1660 nfsmout:
1666 }
1668 /*
1669 * We are normally called with only a partially initialized
1670 * VAP. Since the NFSv3 spec says that server may use the
1671 * file attributes to store the verifier, the spec requires
1672 * us to do a SETATTR RPC. FreeBSD servers store the verifier
1673 * in atime, but we can't really assume that all servers will
1674 * so we ensure that our SETATTR sets both atime and mtime.
1675 */
1681 }
1683 /*
1684 * The new np may have enough info for access
1685 * checks, make sure rucred and wucred are
1686 * initialized for read and write rpc's.
1687 */
1696 }
1701 }
1703 /*
1704 * nfs file remove call
1705 * To try and make nfs semantics closer to ufs semantics, a file that has
1706 * other processes using the vnode is renamed instead of removed and then
1707 * removed later on the last close.
1708 * - If v_sysref.refcnt > 1
1709 * If a rename is not already in the works
1710 * call nfs_sillyrename() to set it up
1711 * else
1712 * do the remove rpc
1713 *
1714 * nfs_remove(struct vnode *a_dvp, struct vnode *a_vp,
1715 * struct componentname *a_cnp)
1716 */
1717 static int
1719 {
1727 #ifndef DIAGNOSTIC
1730 #endif
1736 /*
1737 * throw away biocache buffers, mainly to avoid
1738 * unnecessary delayed writes later.
1739 */
1741 /* Do the rpc */
1745 /*
1746 * Kludge City: If the first reply to the remove rpc is lost..
1747 * the reply to the retransmitted request will be ENOENT
1748 * since the file was in fact removed
1749 * Therefore, we cheat and return success.
1750 */
1755 }
1758 }
1760 /*
1761 * nfs file remove rpc called from nfs_inactive
1762 */
1763 int
1765 {
1768 }
1770 /*
1771 * Nfs remove rpc, called from nfs_remove() and nfs_removeit().
1772 */
1773 static int
1776 {
1791 }
1794 nfsmout:
1799 }
1801 /*
1802 * nfs file rename call
1803 *
1804 * nfs_rename(struct vnode *a_fdvp, struct vnode *a_fvp,
1805 * struct componentname *a_fcnp, struct vnode *a_tdvp,
1806 * struct vnode *a_tvp, struct componentname *a_tcnp)
1807 */
1808 static int
1810 {
1819 /* Check for cross-device rename */
1824 }
1826 /*
1827 * We shouldn't have to flush fvp on rename for most server-side
1828 * filesystems as the file handle should not change. Unfortunately
1829 * the inode for some filesystems (msdosfs) might be tied to the
1830 * file name or directory position so to be completely safe
1831 * vfs.nfs.flush_on_rename is set by default. Clear to improve
1832 * performance.
1833 *
1834 * We must flush tvp on rename because it might become stale on the
1835 * server after the rename.
1836 */
1842 /*
1843 * If the tvp exists and is in use, sillyrename it before doing the
1844 * rename of the new file over it.
1845 *
1846 * XXX Can't sillyrename a directory.
1847 *
1848 * We do not attempt to do any namecache purges in this old API
1849 * routine. The new API compat functions have access to the actual
1850 * namecache structures and will do it for us.
1851 */
1857 ;
1858 }
1864 out:
1867 else
1873 /*
1874 * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
1875 */
1879 }
1881 /*
1882 * nfs file rename rpc called from nfs_remove() above
1883 */
1884 static int
1887 {
1890 }
1892 /*
1893 * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit().
1894 */
1895 static int
1899 {
1918 }
1921 nfsmout:
1929 }
1931 /*
1932 * nfs hard link create call
1933 *
1934 * nfs_link(struct vnode *a_tdvp, struct vnode *a_vp,
1935 * struct componentname *a_cnp)
1936 */
1937 static int
1939 {
1948 }
1950 /*
1951 * The attribute cache may get out of sync with the server on link.
1952 * Pushing writes to the server before handle was inherited from
1953 * long long ago and it is unclear if we still need to do this.
1954 * Defaults to off.
1955 */
1969 NFS_MAXNAMLEN));
1974 NFS_LATTR_NOSHRINK));
1976 }
1979 nfsmout:
1985 /*
1986 * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
1987 */
1991 }
1993 /*
1994 * nfs symbolic link create call
1995 *
1996 * nfs_symlink(struct vnode *a_dvp, struct vnode **a_vpp,
1997 * struct componentname *a_cnp, struct vattr *a_vap,
1998 * char *a_target)
1999 */
2000 static int
2002 {
2022 NFS_MAXNAMLEN));
2025 }
2035 }
2037 /*
2038 * Issue the NFS request and get the rpc response.
2039 *
2040 * Only NFSv3 responses returning an error of 0 actually return
2041 * a file handle that can be converted into newvp without having
2042 * to do an extra lookup rpc.
2043 */
2049 }
2051 }
2053 /*
2054 * out code jumps -> here, mrep is also freed.
2055 */
2059 nfsmout:
2061 /*
2062 * If we get an EEXIST error, silently convert it to no-error
2063 * in case of an NFS retry.
2064 */
2068 /*
2069 * If we do not have (or no longer have) an error, and we could
2070 * not extract the newvp from the response due to the request being
2071 * NFSv2 or the error being EEXIST. We have to do a lookup in order
2072 * to obtain a newvp to return.
2073 */
2081 }
2087 }
2092 }
2094 /*
2095 * nfs make dir call
2096 *
2097 * nfs_mkdir(struct vnode *a_dvp, struct vnode **a_vpp,
2098 * struct componentname *a_cnp, struct vattr *a_vap)
2099 */
2100 static int
2102 {
2120 }
2138 }
2143 }
2146 }
2149 nfsmout:
2153 /*
2154 * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
2155 * if we can succeed in looking up the directory.
2156 */
2161 }
2168 }
2169 }
2176 }
2178 /*
2179 * nfs remove directory call
2180 *
2181 * nfs_rmdir(struct vnode *a_dvp, struct vnode *a_vp,
2182 * struct componentname *a_cnp)
2183 */
2184 static int
2186 {
2204 NFS_MAXNAMLEN));
2209 }
2212 nfsmout:
2216 /*
2217 * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
2218 */
2222 }
2224 /*
2225 * nfs readdir call
2226 *
2227 * nfs_readdir(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred)
2228 */
2229 static int
2231 {
2244 /*
2245 * If we have a valid EOF offset cache we must call VOP_GETATTR()
2246 * and then check that is still valid, or if this is an NQNFS mount
2247 * we call NQNFS_CKCACHEABLE() instead of VOP_GETATTR(). Note that
2248 * VOP_GETATTR() does not necessarily go to the wire.
2249 */
2254 ) {
2257 }
2258 }
2260 /*
2261 * Call nfs_bioread() to do the real work. nfs_bioread() does its
2262 * own cache coherency checks so we do not have to.
2263 */
2269 done:
2272 }
2274 /*
2275 * Readdir rpc call. nfs_bioread->nfs_doio->nfs_readdirrpc.
2276 *
2277 * Note that for directories, nfs_bioread maintains the underlying nfs-centric
2278 * offset/block and converts the nfs formatted directory entries for userland
2279 * consumption as well as deals with offsets into the middle of blocks.
2280 * nfs_doio only deals with logical blocks. In particular, uio_offset will
2281 * be block-bounded. It must convert to cookies for the actual RPC.
2282 */
2283 int
2285 {
2290 caddr_t cp;
2291 nfsuint64 cookie;
2294 u_quad_t fileno;
2302 #ifndef DIAGNOSTIC
2306 #endif
2308 /*
2309 * If there is no cookie, assume directory was stale.
2310 */
2314 else
2316 /*
2317 * Loop around doing readdir rpc's of size nm_readdirsize
2318 * truncated to a multiple of DIRBLKSIZ.
2319 * The stopping criteria is EOF or buffer full.
2320 */
2335 }
2342 NFS_LATTR_NOSHRINK));
2346 }
2350 /* loop thru the dir entries, converting them to std form */
2360 }
2366 }
2368 /*
2369 * len is the number of bytes in the path element
2370 * name, not including the \0 termination.
2371 *
2372 * tlen is the number of bytes w have to reserve for
2373 * the path element name.
2374 */
2379 /*
2380 * If the entry would cross a DIRBLKSIZ boundary,
2381 * extend the previous nfs_dirent to cover the
2382 * remaining space.
2383 */
2392 }
2410 /*
2411 * The uiop has advanced by nfs_dirent + len
2412 * but really needs to advance by
2413 * nfs_dirent + tlen
2414 */
2423 /*
2424 * NFS strings must be rounded up (nfsm_myouio
2425 * handled that in the bigenough case).
2426 */
2428 }
2433 }
2435 /*
2436 * If we were able to accomodate the last entry,
2437 * get the cookie for the next one. Otherwise
2438 * hold-over the cookie for the one we were not
2439 * able to accomodate.
2440 */
2448 tl++;
2449 }
2451 }
2452 /*
2453 * If at end of rpc data, get the eof boolean
2454 */
2458 }
2461 }
2462 /*
2463 * Fill last record, iff any, out to a multiple of DIRBLKSIZ
2464 * by increasing d_reclen for the last record.
2465 */
2473 }
2476 /*
2477 * We hit the end of the directory, update direofoffset.
2478 */
2481 /*
2482 * There is more to go, insert the link cookie so the
2483 * next block can be read.
2484 */
2489 }
2490 nfsmout:
2492 }
2494 /*
2495 * NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
2496 */
2497 int
2499 {
2506 caddr_t cp;
2508 nfsuint64 cookie;
2512 u_quad_t fileno;
2523 #ifndef nolint
2525 #endif
2526 #ifndef DIAGNOSTIC
2530 #endif
2531 /*
2532 * Obtain the namecache record for the directory so we have something
2533 * to use as a basis for creating the entries. This function will
2534 * return a held (but not locked) ncp. The ncp may be disconnected
2535 * from the tree and cannot be used for upward traversals, and the
2536 * ncp may be unnamed. Note that other unrelated operations may
2537 * cause the ncp to be named at any time.
2538 */
2543 /*
2544 * If there is no cookie, assume directory was stale.
2545 */
2549 else
2551 /*
2552 * Loop around doing readdir rpc's of size nm_readdirsize
2553 * truncated to a multiple of DIRBLKSIZ.
2554 * The stopping criteria is EOF or buffer full.
2555 */
2572 NFS_LATTR_NOSHRINK));
2578 /* loop thru the dir entries, doctoring them to 4bsd form */
2588 }
2600 }
2628 }
2636 /*
2637 * Since the attributes are before the file handle
2638 * (sigh), we must skip over the attributes and then
2639 * come back and get them.
2640 */
2659 else
2661 }
2662 }
2680 nfspos_cache_timeout);
2687 }
2688 }
2690 /* Just skip over the file handle */
2694 }
2698 else
2701 }
2704 }
2705 /*
2706 * If at end of rpc data, get the eof boolean
2707 */
2711 }
2714 }
2715 /*
2716 * Fill last record, iff any, out to a multiple of DIRBLKSIZ
2717 * by increasing d_reclen for the last record.
2718 */
2726 }
2728 /*
2729 * We are now either at the end of the directory or have filled the
2730 * block.
2731 */
2739 }
2740 nfsmout:
2744 else
2747 }
2751 }
2753 /*
2754 * Silly rename. To make the NFS filesystem that is stateless look a little
2755 * more like the "ufs" a remove of an active vnode is translated to a rename
2756 * to a funny looking filename that is removed by nfs_inactive on the
2757 * nfsnode. There is the potential for another process on a different client
2758 * to create the same funny name between the nfs_lookitup() fails and the
2759 * nfs_rename() completes, but...
2760 */
2761 static int
2763 {
2768 /*
2769 * We previously purged dvp instead of vp. I don't know why, it
2770 * completely destroys performance. We can't do it anyway with the
2771 * new VFS API since we would be breaking the namecache topology.
2772 */
2775 #ifndef DIAGNOSTIC
2778 #endif
2785 /* Fudge together a funny name */
2789 /* Try lookitups until we get one that isn't there */
2796 }
2797 }
2805 bad:
2810 }
2812 /*
2813 * Look up a file name and optionally either update the file handle or
2814 * allocate an nfsnode, depending on the value of npp.
2815 * npp == NULL --> just do the lookup
2816 * *npp == NULL --> allocate a new nfsnode and make sure attributes are
2817 * handled too
2818 * *npp != NULL --> update the file handle in the vnode
2819 */
2820 static int
2823 {
2860 }
2862 }
2865 NFS_LATTR_NOSHRINK));
2871 else
2874 }
2877 }
2878 }
2881 nfsmout:
2887 else
2889 }
2892 }
2894 }
2896 /*
2897 * Nfs Version 3 commit rpc
2898 *
2899 * We call it 'uio' to distinguish it from 'bio' but there is no real uio
2900 * involved.
2901 */
2902 int
2904 {
2928 NFSX_V3WRITEVERF)) {
2930 NFSX_V3WRITEVERF);
2932 }
2933 }
2936 nfsmout:
2938 }
2940 /*
2941 * Kludge City..
2942 * - make nfs_bmap() essentially a no-op that does no translation
2943 * - do nfs_strategy() by doing I/O with nfs_readrpc/nfs_writerpc
2944 * (Maybe I could use the process's page mapping, but I was concerned that
2945 * Kernel Write might not be enabled and also figured copyout() would do
2946 * a lot more work than bcopy() and also it currently happens in the
2947 * context of the swapper process (2).
2948 *
2949 * nfs_bmap(struct vnode *a_vp, off_t a_loffset,
2950 * off_t *a_doffsetp, int *a_runp, int *a_runb)
2951 */
2952 static int
2954 {
2962 }
2964 /*
2965 * Strategy routine.
2966 */
2967 static int
2969 {
2983 else
2986 /*
2987 * We probably don't need to push an nbio any more since no
2988 * block conversion is required due to the use of 64 bit byte
2989 * offsets, but do it anyway.
2990 *
2991 * NOTE: When NFS callers itself via this strategy routines and
2992 * sets up a synchronous I/O, it expects the I/O to run
2993 * synchronously (its bio_done routine just assumes it),
2994 * so for now we have to honor the bit.
2995 */
3000 /*
3001 * If the op is asynchronous and an i/o daemon is waiting
3002 * queue the request, wake it up and wait for completion
3003 * otherwise just do it ourselves.
3004 */
3010 }
3012 }
3014 /*
3015 * Mmap a file
3016 *
3017 * NB Currently unsupported.
3018 *
3019 * nfs_mmap(struct vnode *a_vp, int a_fflags, struct ucred *a_cred)
3020 */
3021 /* ARGSUSED */
3022 static int
3024 {
3026 }
3028 /*
3029 * fsync vnode op. Just call nfs_flush() with commit == 1.
3030 *
3031 * nfs_fsync(struct vnode *a_vp, int a_waitfor)
3032 */
3033 /* ARGSUSED */
3034 static int
3036 {
3038 }
3040 /*
3041 * Flush all the blocks associated with a vnode. Dirty NFS buffers may be
3042 * in one of two states: If B_NEEDCOMMIT is clear then the buffer contains
3043 * new NFS data which needs to be written to the server. If B_NEEDCOMMIT is
3044 * set the buffer contains data that has already been written to the server
3045 * and which now needs a commit RPC.
3046 *
3047 * If commit is 0 we only take one pass and only flush buffers containing new
3048 * dirty data.
3049 *
3050 * If commit is 1 we take two passes, issuing a commit RPC in the second
3051 * pass.
3052 *
3053 * If waitfor is MNT_WAIT and commit is 1, we loop as many times as required
3054 * to completely flush all pending data.
3055 *
3056 * Note that the RB_SCAN code properly handles the case where the
3057 * callback might block and directly or indirectly (another thread) cause
3058 * the RB tree to change.
3059 */
3061 #ifndef NFS_COMMITBVECSIZ
3062 #define NFS_COMMITBVECSIZ 16
3063 #endif
3075 off_t beg_off;
3076 off_t end_off;
3077 };
3082 int
3084 {
3088 lwkt_tokref vlock;
3100 /*
3101 * Flush mode
3102 */
3107 /*
3108 * Take a second pass if committing and no error occured.
3109 * Clean up any left over collection (whether an error
3110 * occurs or not).
3111 */
3118 }
3120 /*
3121 * Wait for pending I/O to complete before checking whether
3122 * any further dirty buffers exist.
3123 */
3129 /*
3130 * We have to be able to break out if this
3131 * is an 'intr' mount.
3132 */
3136 }
3138 /*
3139 * Since we do not process pending signals,
3140 * once we get a PCATCH our tsleep() will no
3141 * longer sleep, switch to a fixed timeout
3142 * instead.
3143 */
3147 }
3149 }
3150 }
3152 /*
3153 * Loop if we are flushing synchronous as well as committing,
3154 * and dirty buffers are still present. Otherwise we might livelock.
3155 */
3159 /*
3160 * The callbacks have to return a negative error to terminate the
3161 * RB scan.
3162 */
3166 /*
3167 * Deal with any error collection
3168 */
3172 }
3175 }
3177 static
3178 int
3180 {
3184 off_t toff;
3198 }
3199 }
3201 /*
3202 * Ignore locking errors
3203 */
3207 }
3209 /*
3210 * The buffer may have changed out from under us, even if
3211 * we did not block (MPSAFE). Check again now that it is
3212 * locked.
3213 */
3220 }
3223 /*
3224 * Only process buffers in need of a commit which we can
3225 * immediately lock. This may prevent a buffer from being
3226 * committed, but the normal flush loop will block on the
3227 * same buffer so we shouldn't get into an endless loop.
3228 */
3232 }
3236 /*
3237 * We must recheck after successfully locking the buffer.
3238 */
3244 }
3246 /*
3247 * NOTE: storing the bp in the bvary[] basically sets
3248 * it up for a commit operation.
3249 *
3250 * We must call vfs_busy_pages() now so the commit operation
3251 * is interlocked with user modifications to memory mapped
3252 * pages. The b_dirtyoff/b_dirtyend range is not correct
3253 * until after the pages have been busied.
3254 *
3255 * Note: to avoid loopback deadlocks, we do not
3256 * assign b_runningbufspace.
3257 */
3272 }
3273 }
3275 }
3277 static
3278 int
3280 {
3283 off_t bytes;
3290 /*
3291 * Commit data on the server, as required. Note that
3292 * nfs_commit will use the vnode's cred for the commit.
3293 * The NFSv3 commit RPC is limited to a 32 bit byte count.
3294 */
3305 }
3307 /*
3308 * Now, either mark the blocks I/O done or mark the
3309 * blocks dirty, depending on whether the commit
3310 * succeeded.
3311 */
3316 /*
3317 * Error, leave B_DELWRI intact
3318 */
3323 /*
3324 * Success, remove B_DELWRI ( bundirty() ).
3325 *
3326 * b_dirtyoff/b_dirtyend seem to be NFS
3327 * specific. We should probably move that
3328 * into bundirty(). XXX
3329 *
3330 * We are faking an I/O write, we have to
3331 * start the transaction in order to
3332 * immediately biodone() it.
3333 */
3338 }
3339 }
3341 }
3343 }
3345 /*
3346 * NFS advisory byte-level locks.
3347 * Currently unsupported.
3348 *
3349 * nfs_advlock(struct vnode *a_vp, caddr_t a_id, int a_op, struct flock *a_fl,
3350 * int a_flags)
3351 */
3352 static int
3354 {
3357 /*
3358 * The following kludge is to allow diskless support to work
3359 * until a real NFS lockd is implemented. Basically, just pretend
3360 * that this is a local lock.
3361 */
3363 }
3365 /*
3366 * Print out the contents of an nfsnode.
3367 *
3368 * nfs_print(struct vnode *a_vp)
3369 */
3370 static int
3372 {
3382 }
3384 /*
3385 * nfs special file access vnode op.
3386 *
3387 * nfs_laccess(struct vnode *a_vp, int a_mode, struct ucred *a_cred)
3388 */
3389 static int
3391 {
3400 }
3402 /*
3403 * Read wrapper for fifos.
3404 *
3405 * nfsfifo_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
3406 * struct ucred *a_cred)
3407 */
3408 static int
3410 {
3413 /*
3414 * Set access flag.
3415 */
3419 }
3421 /*
3422 * Write wrapper for fifos.
3423 *
3424 * nfsfifo_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
3425 * struct ucred *a_cred)
3426 */
3427 static int
3429 {
3432 /*
3433 * Set update flag.
3434 */
3438 }
3440 /*
3441 * Close wrapper for fifos.
3442 *
3443 * Update the times on the nfsnode then do fifo close.
3444 *
3445 * nfsfifo_close(struct vnode *a_vp, int a_fflag)
3446 */
3447 static int
3449 {
3470 }
3471 }
3473 }