1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1997-02-10 02:22:35 +00:00
|
|
|
* Copyright (c) 1989, 1991, 1993, 1995
|
1994-05-24 10:09:53 +00:00
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* This code is derived from software contributed to Berkeley by
|
|
|
|
|
* Rick Macklem at The University of Guelph.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
|
* are met:
|
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
|
* without specific prior written permission.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
|
*
|
1997-02-10 02:22:35 +00:00
|
|
|
* @(#)nfs_socket.c 8.5 (Berkeley) 3/30/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
|
2001-09-18 23:32:09 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* Socket operations for use by nfs
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/systm.h>
|
|
|
|
|
#include <sys/kernel.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
|
#include <sys/malloc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/mbuf.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/mount.h>
|
|
|
|
|
#include <sys/mutex.h>
|
|
|
|
|
#include <sys/proc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/protosw.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/signalvar.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/socket.h>
|
|
|
|
|
#include <sys/socketvar.h>
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
#include <sys/sysctl.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/syslog.h>
|
|
|
|
|
#include <sys/vnode.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
|
#include <netinet/in.h>
|
|
|
|
|
#include <netinet/tcp.h>
|
1994-10-17 17:47:45 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <nfs/rpcv2.h>
|
1995-06-27 11:07:30 +00:00
|
|
|
#include <nfs/nfsproto.h>
|
2001-09-18 23:32:09 +00:00
|
|
|
#include <nfsserver/nfs.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <nfs/xdr_subs.h>
|
2001-09-18 23:32:09 +00:00
|
|
|
#include <nfsserver/nfsm_subs.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
|
#define TRUE 1
|
|
|
|
|
#define FALSE 0
|
|
|
|
|
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
static int nfs_realign_test;
|
|
|
|
|
static int nfs_realign_count;
|
|
|
|
|
|
2001-09-18 23:32:09 +00:00
|
|
|
SYSCTL_DECL(_vfs_nfsrv);
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
|
2001-09-18 23:32:09 +00:00
|
|
|
SYSCTL_INT(_vfs_nfsrv, OID_AUTO, realign_test, CTLFLAG_RW, &nfs_realign_test, 0, "");
|
|
|
|
|
SYSCTL_INT(_vfs_nfsrv, OID_AUTO, realign_count, CTLFLAG_RW, &nfs_realign_count, 0, "");
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* There is a congestion window for outstanding rpcs maintained per mount
|
|
|
|
|
* point. The cwnd size is adjusted in roughly the way that:
|
|
|
|
|
* Van Jacobson, Congestion avoidance and Control, In "Proceedings of
|
|
|
|
|
* SIGCOMM '88". ACM, August 1988.
|
|
|
|
|
* describes for TCP. The cwnd size is chopped in half on a retransmit timeout
|
|
|
|
|
* and incremented by 1/cwnd when each rpc reply is received and a full cwnd
|
|
|
|
|
* of rpcs is in progress.
|
|
|
|
|
* (The sent count and cwnd are scaled for integer arith.)
|
|
|
|
|
* Variants of "slow start" were tried and were found to be too much of a
|
|
|
|
|
* performance hit (ave. rtt 3 times larger),
|
|
|
|
|
* I suspect due to the large rtt that nfs rpcs have.
|
|
|
|
|
*/
|
|
|
|
|
#define NFS_CWNDSCALE 256
|
|
|
|
|
#define NFS_MAXCWND (NFS_CWNDSCALE * 32)
|
2001-09-18 23:32:09 +00:00
|
|
|
struct callout_handle nfsrv_timer_handle;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-09-18 23:32:09 +00:00
|
|
|
static void nfs_realign(struct mbuf **pm, int hsiz); /* XXX SHARED */
|
|
|
|
|
static int nfsrv_getstream(struct nfssvc_sock *, int);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-09-18 23:32:09 +00:00
|
|
|
int (*nfsrv3_procs[NFS_NPROCS])(struct nfsrv_descript *nd,
|
|
|
|
|
struct nfssvc_sock *slp,
|
|
|
|
|
struct thread *td,
|
|
|
|
|
struct mbuf **mreqp) = {
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsrv_null,
|
|
|
|
|
nfsrv_getattr,
|
|
|
|
|
nfsrv_setattr,
|
|
|
|
|
nfsrv_lookup,
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsrv3_access,
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsrv_readlink,
|
|
|
|
|
nfsrv_read,
|
|
|
|
|
nfsrv_write,
|
|
|
|
|
nfsrv_create,
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsrv_mkdir,
|
|
|
|
|
nfsrv_symlink,
|
|
|
|
|
nfsrv_mknod,
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsrv_remove,
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsrv_rmdir,
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsrv_rename,
|
|
|
|
|
nfsrv_link,
|
|
|
|
|
nfsrv_readdir,
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsrv_readdirplus,
|
1994-05-24 10:09:53 +00:00
|
|
|
nfsrv_statfs,
|
1995-06-27 11:07:30 +00:00
|
|
|
nfsrv_fsinfo,
|
|
|
|
|
nfsrv_pathconf,
|
|
|
|
|
nfsrv_commit,
|
|
|
|
|
nfsrv_noop
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Generate the rpc reply header
|
|
|
|
|
* siz arg. is used to decide if adding a cluster is worthwhile
|
|
|
|
|
*/
|
2001-09-18 23:32:09 +00:00
|
|
|
void
|
|
|
|
|
nfs_rephead(int siz, struct nfsrv_descript *nd, struct nfssvc_sock *slp,
|
|
|
|
|
int err, struct mbuf **mrq, struct mbuf **mbp, caddr_t *bposp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
u_int32_t *tl;
|
|
|
|
|
struct mbuf *mreq;
|
1994-05-24 10:09:53 +00:00
|
|
|
caddr_t bpos;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *mb;
|
|
|
|
|
|
|
|
|
|
nd->nd_repstat = err;
|
|
|
|
|
if (err && (nd->nd_flag & ND_NFSV3) == 0) /* XXX recheck */
|
|
|
|
|
siz = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-12-21 21:44:31 +00:00
|
|
|
MGETHDR(mreq, M_TRYWAIT, MT_DATA);
|
1994-05-24 10:09:53 +00:00
|
|
|
mb = mreq;
|
|
|
|
|
/*
|
|
|
|
|
* If this is a big reply, use a cluster else
|
|
|
|
|
* try and leave leading space for the lower level headers.
|
|
|
|
|
*/
|
|
|
|
|
siz += RPC_REPLYSIZ;
|
2000-01-09 19:17:30 +00:00
|
|
|
if ((max_hdr + siz) >= MINCLSIZE) {
|
2000-12-21 21:44:31 +00:00
|
|
|
MCLGET(mreq, M_TRYWAIT);
|
1994-05-24 10:09:53 +00:00
|
|
|
} else
|
|
|
|
|
mreq->m_data += max_hdr;
|
1998-05-31 20:09:01 +00:00
|
|
|
tl = mtod(mreq, u_int32_t *);
|
1995-06-27 11:07:30 +00:00
|
|
|
mreq->m_len = 6 * NFSX_UNSIGNED;
|
|
|
|
|
bpos = ((caddr_t)tl) + mreq->m_len;
|
1994-10-17 17:47:45 +00:00
|
|
|
*tl++ = txdr_unsigned(nd->nd_retxid);
|
1994-05-24 10:09:53 +00:00
|
|
|
*tl++ = rpc_reply;
|
1995-06-27 11:07:30 +00:00
|
|
|
if (err == ERPCMISMATCH || (err & NFSERR_AUTHERR)) {
|
1994-05-24 10:09:53 +00:00
|
|
|
*tl++ = rpc_msgdenied;
|
1995-06-27 11:07:30 +00:00
|
|
|
if (err & NFSERR_AUTHERR) {
|
1994-05-24 10:09:53 +00:00
|
|
|
*tl++ = rpc_autherr;
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl = txdr_unsigned(err & ~NFSERR_AUTHERR);
|
1994-05-24 10:09:53 +00:00
|
|
|
mreq->m_len -= NFSX_UNSIGNED;
|
|
|
|
|
bpos -= NFSX_UNSIGNED;
|
|
|
|
|
} else {
|
|
|
|
|
*tl++ = rpc_mismatch;
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl++ = txdr_unsigned(RPC_VER2);
|
|
|
|
|
*tl = txdr_unsigned(RPC_VER2);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
*tl++ = rpc_msgaccepted;
|
1995-06-27 11:07:30 +00:00
|
|
|
|
|
|
|
|
/*
|
2001-09-18 23:32:09 +00:00
|
|
|
* Send a RPCAUTH_NULL verifier - no Kerberos.
|
1995-06-27 11:07:30 +00:00
|
|
|
*/
|
2001-09-18 23:32:09 +00:00
|
|
|
*tl++ = 0;
|
|
|
|
|
*tl++ = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
switch (err) {
|
|
|
|
|
case EPROGUNAVAIL:
|
|
|
|
|
*tl = txdr_unsigned(RPC_PROGUNAVAIL);
|
|
|
|
|
break;
|
|
|
|
|
case EPROGMISMATCH:
|
|
|
|
|
*tl = txdr_unsigned(RPC_PROGMISMATCH);
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, 2 * NFSX_UNSIGNED);
|
2001-09-18 23:32:09 +00:00
|
|
|
*tl++ = txdr_unsigned(2);
|
|
|
|
|
*tl = txdr_unsigned(3);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
case EPROCUNAVAIL:
|
|
|
|
|
*tl = txdr_unsigned(RPC_PROCUNAVAIL);
|
|
|
|
|
break;
|
1995-06-27 11:07:30 +00:00
|
|
|
case EBADRPC:
|
|
|
|
|
*tl = txdr_unsigned(RPC_GARBAGE);
|
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
|
|
|
|
*tl = 0;
|
1995-06-27 11:07:30 +00:00
|
|
|
if (err != NFSERR_RETVOID) {
|
2001-09-27 02:33:36 +00:00
|
|
|
tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (err)
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl = txdr_unsigned(nfsrv_errmap(nd, err));
|
1994-05-24 10:09:53 +00:00
|
|
|
else
|
1995-06-27 11:07:30 +00:00
|
|
|
*tl = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
1997-06-03 17:22:47 +00:00
|
|
|
if (mrq != NULL)
|
2001-09-18 23:32:09 +00:00
|
|
|
*mrq = mreq;
|
1994-05-24 10:09:53 +00:00
|
|
|
*mbp = mb;
|
|
|
|
|
*bposp = bpos;
|
1995-06-27 11:07:30 +00:00
|
|
|
if (err != 0 && err != NFSERR_RETVOID)
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsrvstats.srvrpc_errs++;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
* nfs_realign:
|
|
|
|
|
*
|
|
|
|
|
* Check for badly aligned mbuf data and realign by copying the unaligned
|
|
|
|
|
* portion of the data into a new mbuf chain and freeing the portions
|
|
|
|
|
* of the old chain that were replaced.
|
|
|
|
|
*
|
|
|
|
|
* We cannot simply realign the data within the existing mbuf chain
|
|
|
|
|
* because the underlying buffers may contain other rpc commands and
|
|
|
|
|
* we cannot afford to overwrite them.
|
|
|
|
|
*
|
|
|
|
|
* We would prefer to avoid this situation entirely. The situation does
|
|
|
|
|
* not occur with NFS/UDP and is supposed to only occassionally occur
|
|
|
|
|
* with TCP. Use vfs.nfs.realign_count and realign_test to check this.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1995-12-17 21:14:36 +00:00
|
|
|
static void
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_realign(struct mbuf **pm, int hsiz) /* XXX COMMON */
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
struct mbuf *m;
|
|
|
|
|
struct mbuf *n = NULL;
|
|
|
|
|
int off = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
++nfs_realign_test;
|
|
|
|
|
while ((m = *pm) != NULL) {
|
|
|
|
|
if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
|
2000-12-21 21:44:31 +00:00
|
|
|
MGET(n, M_TRYWAIT, MT_DATA);
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
if (m->m_len >= MINCLSIZE) {
|
2000-12-21 21:44:31 +00:00
|
|
|
MCLGET(n, M_TRYWAIT);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
n->m_len = 0;
|
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
pm = &m->m_next;
|
|
|
|
|
}
|
1995-05-30 08:16:23 +00:00
|
|
|
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
/*
|
|
|
|
|
* If n is non-NULL, loop on m copying data, then replace the
|
|
|
|
|
* portion of the chain that had to be realigned.
|
|
|
|
|
*/
|
|
|
|
|
if (n != NULL) {
|
|
|
|
|
++nfs_realign_count;
|
|
|
|
|
while (m) {
|
|
|
|
|
m_copyback(n, off, m->m_len, mtod(m, caddr_t));
|
|
|
|
|
off += m->m_len;
|
|
|
|
|
m = m->m_next;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
m_freem(*pm);
|
|
|
|
|
*pm = n;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Parse an RPC request
|
|
|
|
|
* - verify it
|
|
|
|
|
* - fill in the cred struct.
|
|
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfs_getreq(struct nfsrv_descript *nd, struct nfsd *nfsd, int has_header)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
int len, i;
|
|
|
|
|
u_int32_t *tl;
|
|
|
|
|
caddr_t dpos;
|
1998-05-31 20:09:01 +00:00
|
|
|
u_int32_t nfsvers, auth_type;
|
2001-09-18 23:32:09 +00:00
|
|
|
int error = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct mbuf *mrep, *md;
|
|
|
|
|
|
|
|
|
|
mrep = nd->nd_mrep;
|
|
|
|
|
md = nd->nd_md;
|
|
|
|
|
dpos = nd->nd_dpos;
|
|
|
|
|
if (has_header) {
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, 10 * NFSX_UNSIGNED);
|
1998-05-31 20:09:01 +00:00
|
|
|
nd->nd_retxid = fxdr_unsigned(u_int32_t, *tl++);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (*tl++ != rpc_call) {
|
|
|
|
|
m_freem(mrep);
|
|
|
|
|
return (EBADRPC);
|
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
} else
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, 8 * NFSX_UNSIGNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
nd->nd_repstat = 0;
|
1995-06-27 11:07:30 +00:00
|
|
|
nd->nd_flag = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (*tl++ != rpc_vers) {
|
|
|
|
|
nd->nd_repstat = ERPCMISMATCH;
|
|
|
|
|
nd->nd_procnum = NFSPROC_NOOP;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
if (*tl != nfs_prog) {
|
2001-09-18 23:32:09 +00:00
|
|
|
nd->nd_repstat = EPROGUNAVAIL;
|
|
|
|
|
nd->nd_procnum = NFSPROC_NOOP;
|
|
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
tl++;
|
1998-05-31 20:09:01 +00:00
|
|
|
nfsvers = fxdr_unsigned(u_int32_t, *tl++);
|
2001-09-18 23:32:09 +00:00
|
|
|
if (nfsvers < NFS_VER2 || nfsvers > NFS_VER3) {
|
1994-05-24 10:09:53 +00:00
|
|
|
nd->nd_repstat = EPROGMISMATCH;
|
|
|
|
|
nd->nd_procnum = NFSPROC_NOOP;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
1998-05-31 20:09:01 +00:00
|
|
|
nd->nd_procnum = fxdr_unsigned(u_int32_t, *tl++);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (nd->nd_procnum == NFSPROC_NULL)
|
|
|
|
|
return (0);
|
2001-09-18 23:32:09 +00:00
|
|
|
if (nfsvers == NFS_VER3) {
|
|
|
|
|
nd->nd_flag = ND_NFSV3;
|
|
|
|
|
if (nd->nd_procnum >= NFS_NPROCS) {
|
|
|
|
|
nd->nd_repstat = EPROCUNAVAIL;
|
|
|
|
|
nd->nd_procnum = NFSPROC_NOOP;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (nd->nd_procnum > NFSV2PROC_STATFS) {
|
|
|
|
|
nd->nd_repstat = EPROCUNAVAIL;
|
|
|
|
|
nd->nd_procnum = NFSPROC_NOOP;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
/* Map the v2 procedure numbers into v3 ones */
|
1995-06-27 11:07:30 +00:00
|
|
|
nd->nd_procnum = nfsv3_procid[nd->nd_procnum];
|
2001-09-18 23:32:09 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
auth_type = *tl++;
|
|
|
|
|
len = fxdr_unsigned(int, *tl++);
|
|
|
|
|
if (len < 0 || len > RPCAUTH_MAXSIZ) {
|
|
|
|
|
m_freem(mrep);
|
|
|
|
|
return (EBADRPC);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2001-09-18 23:32:09 +00:00
|
|
|
* Handle auth_unix;
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
if (auth_type == rpc_auth_unix) {
|
|
|
|
|
len = fxdr_unsigned(int, *++tl);
|
|
|
|
|
if (len < 0 || len > NFS_MAXNAMLEN) {
|
|
|
|
|
m_freem(mrep);
|
|
|
|
|
return (EBADRPC);
|
|
|
|
|
}
|
|
|
|
|
nfsm_adv(nfsm_rndup(len));
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, 3 * NFSX_UNSIGNED);
|
1995-06-27 11:07:30 +00:00
|
|
|
bzero((caddr_t)&nd->nd_cr, sizeof (struct ucred));
|
|
|
|
|
nd->nd_cr.cr_ref = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
nd->nd_cr.cr_uid = fxdr_unsigned(uid_t, *tl++);
|
|
|
|
|
nd->nd_cr.cr_gid = fxdr_unsigned(gid_t, *tl++);
|
|
|
|
|
len = fxdr_unsigned(int, *tl);
|
|
|
|
|
if (len < 0 || len > RPCAUTH_UNIXGIDS) {
|
|
|
|
|
m_freem(mrep);
|
|
|
|
|
return (EBADRPC);
|
|
|
|
|
}
|
2001-09-27 22:40:38 +00:00
|
|
|
tl = nfsm_dissect(u_int32_t *, (len + 2) * NFSX_UNSIGNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
for (i = 1; i <= len; i++)
|
1995-06-27 11:07:30 +00:00
|
|
|
if (i < NGROUPS)
|
|
|
|
|
nd->nd_cr.cr_groups[i] = fxdr_unsigned(gid_t, *tl++);
|
|
|
|
|
else
|
|
|
|
|
tl++;
|
1994-05-24 10:09:53 +00:00
|
|
|
nd->nd_cr.cr_ngroups = (len >= NGROUPS) ? NGROUPS : (len + 1);
|
1995-06-27 11:07:30 +00:00
|
|
|
if (nd->nd_cr.cr_ngroups > 1)
|
|
|
|
|
nfsrvw_sort(nd->nd_cr.cr_groups, nd->nd_cr.cr_ngroups);
|
|
|
|
|
len = fxdr_unsigned(int, *++tl);
|
|
|
|
|
if (len < 0 || len > RPCAUTH_MAXSIZ) {
|
1994-05-24 10:09:53 +00:00
|
|
|
m_freem(mrep);
|
|
|
|
|
return (EBADRPC);
|
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
if (len > 0)
|
|
|
|
|
nfsm_adv(nfsm_rndup(len));
|
1998-05-31 17:27:58 +00:00
|
|
|
} else {
|
|
|
|
|
nd->nd_repstat = (NFSERR_AUTHERR | AUTH_REJECTCRED);
|
|
|
|
|
nd->nd_procnum = NFSPROC_NOOP;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nd->nd_md = md;
|
|
|
|
|
nd->nd_dpos = dpos;
|
|
|
|
|
return (0);
|
|
|
|
|
nfsmout:
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Socket upcall routine for the nfsd sockets.
|
|
|
|
|
* The caddr_t arg is a pointer to the "struct nfssvc_sock".
|
|
|
|
|
* Essentially do as much as possible non-blocking, else punt and it will
|
2000-12-21 21:44:31 +00:00
|
|
|
* be called with M_TRYWAIT from an nfsd.
|
1998-05-31 17:27:58 +00:00
|
|
|
*/
|
|
|
|
|
void
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsrv_rcv(struct socket *so, void *arg, int waitflag)
|
1998-05-31 17:27:58 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct nfssvc_sock *slp = (struct nfssvc_sock *)arg;
|
|
|
|
|
struct mbuf *m;
|
1998-05-31 17:27:58 +00:00
|
|
|
struct mbuf *mp;
|
|
|
|
|
struct sockaddr *nam;
|
|
|
|
|
struct uio auio;
|
|
|
|
|
int flags, error;
|
|
|
|
|
|
|
|
|
|
if ((slp->ns_flag & SLP_VALID) == 0)
|
|
|
|
|
return;
|
|
|
|
|
#ifdef notdef
|
|
|
|
|
/*
|
|
|
|
|
* Define this to test for nfsds handling this under heavy load.
|
|
|
|
|
*/
|
|
|
|
|
if (waitflag == M_DONTWAIT) {
|
2001-09-18 23:32:09 +00:00
|
|
|
slp->ns_flag |= SLP_NEEDQ;
|
|
|
|
|
goto dorecs;
|
1998-05-31 17:27:58 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
2001-09-12 08:38:13 +00:00
|
|
|
auio.uio_td = NULL;
|
1998-05-31 17:27:58 +00:00
|
|
|
if (so->so_type == SOCK_STREAM) {
|
|
|
|
|
/*
|
|
|
|
|
* If there are already records on the queue, defer soreceive()
|
|
|
|
|
* to an nfsd so that there is feedback to the TCP layer that
|
|
|
|
|
* the nfs servers are heavily loaded.
|
|
|
|
|
*/
|
|
|
|
|
if (STAILQ_FIRST(&slp->ns_rec) && waitflag == M_DONTWAIT) {
|
|
|
|
|
slp->ns_flag |= SLP_NEEDQ;
|
|
|
|
|
goto dorecs;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Do soreceive().
|
|
|
|
|
*/
|
|
|
|
|
auio.uio_resid = 1000000000;
|
|
|
|
|
flags = MSG_DONTWAIT;
|
|
|
|
|
error = so->so_proto->pr_usrreqs->pru_soreceive
|
|
|
|
|
(so, &nam, &auio, &mp, (struct mbuf **)0, &flags);
|
|
|
|
|
if (error || mp == (struct mbuf *)0) {
|
|
|
|
|
if (error == EWOULDBLOCK)
|
|
|
|
|
slp->ns_flag |= SLP_NEEDQ;
|
|
|
|
|
else
|
|
|
|
|
slp->ns_flag |= SLP_DISCONN;
|
|
|
|
|
goto dorecs;
|
|
|
|
|
}
|
|
|
|
|
m = mp;
|
|
|
|
|
if (slp->ns_rawend) {
|
|
|
|
|
slp->ns_rawend->m_next = m;
|
|
|
|
|
slp->ns_cc += 1000000000 - auio.uio_resid;
|
|
|
|
|
} else {
|
|
|
|
|
slp->ns_raw = m;
|
|
|
|
|
slp->ns_cc = 1000000000 - auio.uio_resid;
|
|
|
|
|
}
|
|
|
|
|
while (m->m_next)
|
|
|
|
|
m = m->m_next;
|
|
|
|
|
slp->ns_rawend = m;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Now try and parse record(s) out of the raw stream data.
|
|
|
|
|
*/
|
|
|
|
|
error = nfsrv_getstream(slp, waitflag);
|
|
|
|
|
if (error) {
|
|
|
|
|
if (error == EPERM)
|
|
|
|
|
slp->ns_flag |= SLP_DISCONN;
|
|
|
|
|
else
|
|
|
|
|
slp->ns_flag |= SLP_NEEDQ;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
do {
|
|
|
|
|
auio.uio_resid = 1000000000;
|
|
|
|
|
flags = MSG_DONTWAIT;
|
|
|
|
|
error = so->so_proto->pr_usrreqs->pru_soreceive
|
|
|
|
|
(so, &nam, &auio, &mp,
|
|
|
|
|
(struct mbuf **)0, &flags);
|
|
|
|
|
if (mp) {
|
|
|
|
|
struct nfsrv_rec *rec;
|
|
|
|
|
rec = malloc(sizeof(struct nfsrv_rec),
|
|
|
|
|
M_NFSRVDESC, waitflag);
|
|
|
|
|
if (!rec) {
|
|
|
|
|
if (nam)
|
|
|
|
|
FREE(nam, M_SONAME);
|
|
|
|
|
m_freem(mp);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
nfs_realign(&mp, 10 * NFSX_UNSIGNED);
|
1998-05-31 17:27:58 +00:00
|
|
|
rec->nr_address = nam;
|
|
|
|
|
rec->nr_packet = mp;
|
|
|
|
|
STAILQ_INSERT_TAIL(&slp->ns_rec, rec, nr_link);
|
|
|
|
|
}
|
|
|
|
|
if (error) {
|
|
|
|
|
if ((so->so_proto->pr_flags & PR_CONNREQUIRED)
|
|
|
|
|
&& error != EWOULDBLOCK) {
|
|
|
|
|
slp->ns_flag |= SLP_DISCONN;
|
|
|
|
|
goto dorecs;
|
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
1998-05-31 17:27:58 +00:00
|
|
|
} while (mp);
|
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-05-31 17:27:58 +00:00
|
|
|
/*
|
|
|
|
|
* Now try and process the request records, non-blocking.
|
|
|
|
|
*/
|
|
|
|
|
dorecs:
|
|
|
|
|
if (waitflag == M_DONTWAIT &&
|
|
|
|
|
(STAILQ_FIRST(&slp->ns_rec)
|
|
|
|
|
|| (slp->ns_flag & (SLP_NEEDQ | SLP_DISCONN))))
|
|
|
|
|
nfsrv_wakenfsd(slp);
|
|
|
|
|
}
|
1995-06-27 11:07:30 +00:00
|
|
|
|
1998-05-31 17:27:58 +00:00
|
|
|
/*
|
|
|
|
|
* Try and extract an RPC request from the mbuf data list received on a
|
|
|
|
|
* stream socket. The "waitflag" argument indicates whether or not it
|
|
|
|
|
* can sleep.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsrv_getstream(struct nfssvc_sock *slp, int waitflag)
|
1998-05-31 17:27:58 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *m, **mpp;
|
|
|
|
|
char *cp1, *cp2;
|
|
|
|
|
int len;
|
1998-05-31 18:08:09 +00:00
|
|
|
struct mbuf *om, *m2, *recm = NULL;
|
1998-05-31 20:09:01 +00:00
|
|
|
u_int32_t recmark;
|
1998-05-31 17:27:58 +00:00
|
|
|
|
|
|
|
|
if (slp->ns_flag & SLP_GETSTREAM)
|
|
|
|
|
panic("nfs getstream");
|
|
|
|
|
slp->ns_flag |= SLP_GETSTREAM;
|
|
|
|
|
for (;;) {
|
|
|
|
|
if (slp->ns_reclen == 0) {
|
|
|
|
|
if (slp->ns_cc < NFSX_UNSIGNED) {
|
|
|
|
|
slp->ns_flag &= ~SLP_GETSTREAM;
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
m = slp->ns_raw;
|
|
|
|
|
if (m->m_len >= NFSX_UNSIGNED) {
|
|
|
|
|
bcopy(mtod(m, caddr_t), (caddr_t)&recmark, NFSX_UNSIGNED);
|
|
|
|
|
m->m_data += NFSX_UNSIGNED;
|
|
|
|
|
m->m_len -= NFSX_UNSIGNED;
|
|
|
|
|
} else {
|
|
|
|
|
cp1 = (caddr_t)&recmark;
|
|
|
|
|
cp2 = mtod(m, caddr_t);
|
|
|
|
|
while (cp1 < ((caddr_t)&recmark) + NFSX_UNSIGNED) {
|
|
|
|
|
while (m->m_len == 0) {
|
|
|
|
|
m = m->m_next;
|
|
|
|
|
cp2 = mtod(m, caddr_t);
|
|
|
|
|
}
|
|
|
|
|
*cp1++ = *cp2++;
|
|
|
|
|
m->m_data++;
|
|
|
|
|
m->m_len--;
|
1995-06-27 11:07:30 +00:00
|
|
|
}
|
1998-05-31 17:27:58 +00:00
|
|
|
}
|
|
|
|
|
slp->ns_cc -= NFSX_UNSIGNED;
|
|
|
|
|
recmark = ntohl(recmark);
|
|
|
|
|
slp->ns_reclen = recmark & ~0x80000000;
|
|
|
|
|
if (recmark & 0x80000000)
|
|
|
|
|
slp->ns_flag |= SLP_LASTFRAG;
|
|
|
|
|
else
|
|
|
|
|
slp->ns_flag &= ~SLP_LASTFRAG;
|
The code checks each fragment mark to see if it's valid; if the fragment
is less than NFS_MINPACKET or greater than NFS_MAXPACKET in size, it
barfs and, I think, drops the connection.
However, there's no guarantee that in a multi-fragment RPC, all the
fragments will be at least as large as NFS_MINPACKET.
In fact, with the version of "tclnfs" we have here, which supports NFS
over TCP, at least when built under SunOS 4.1.3 (i.e., with 4.1.3's
user-mode ONC RPC library), I can *repeatably* cause "tclnfs" to send a
request with more than one fragment, one of which is only 8 bytes long.
I just do a 3877-byte write to a file, at an offset of 0.
The check that "slp->ns_reclen" is greater than or equal to
NFS_MINPACKET serves no useful purpose - if the NFS server code can't
handle packets < NFS_MINPACKET bytes, it can't handle them over *any*
protocol, so the check has to be done above the RPC-over-TCP layer - and
should be removed.
Obtained from: Fix from Guy Harris, forwarded by Rick Macklem.
1998-09-29 22:33:05 +00:00
|
|
|
if (slp->ns_reclen > NFS_MAXPACKET) {
|
1998-05-31 17:27:58 +00:00
|
|
|
slp->ns_flag &= ~SLP_GETSTREAM;
|
|
|
|
|
return (EPERM);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Now get the record part.
|
|
|
|
|
*/
|
|
|
|
|
if (slp->ns_cc == slp->ns_reclen) {
|
|
|
|
|
recm = slp->ns_raw;
|
|
|
|
|
slp->ns_raw = slp->ns_rawend = (struct mbuf *)0;
|
|
|
|
|
slp->ns_cc = slp->ns_reclen = 0;
|
|
|
|
|
} else if (slp->ns_cc > slp->ns_reclen) {
|
|
|
|
|
len = 0;
|
|
|
|
|
m = slp->ns_raw;
|
|
|
|
|
om = (struct mbuf *)0;
|
|
|
|
|
while (len < slp->ns_reclen) {
|
|
|
|
|
if ((len + m->m_len) > slp->ns_reclen) {
|
|
|
|
|
m2 = m_copym(m, 0, slp->ns_reclen - len,
|
|
|
|
|
waitflag);
|
|
|
|
|
if (m2) {
|
|
|
|
|
if (om) {
|
|
|
|
|
om->m_next = m2;
|
|
|
|
|
recm = slp->ns_raw;
|
|
|
|
|
} else
|
|
|
|
|
recm = m2;
|
|
|
|
|
m->m_data += slp->ns_reclen - len;
|
|
|
|
|
m->m_len -= slp->ns_reclen - len;
|
|
|
|
|
len = slp->ns_reclen;
|
|
|
|
|
} else {
|
|
|
|
|
slp->ns_flag &= ~SLP_GETSTREAM;
|
|
|
|
|
return (EWOULDBLOCK);
|
|
|
|
|
}
|
|
|
|
|
} else if ((len + m->m_len) == slp->ns_reclen) {
|
|
|
|
|
om = m;
|
|
|
|
|
len += m->m_len;
|
|
|
|
|
m = m->m_next;
|
|
|
|
|
recm = slp->ns_raw;
|
|
|
|
|
om->m_next = (struct mbuf *)0;
|
|
|
|
|
} else {
|
|
|
|
|
om = m;
|
|
|
|
|
len += m->m_len;
|
|
|
|
|
m = m->m_next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
slp->ns_raw = m;
|
|
|
|
|
slp->ns_cc -= len;
|
|
|
|
|
slp->ns_reclen = 0;
|
|
|
|
|
} else {
|
|
|
|
|
slp->ns_flag &= ~SLP_GETSTREAM;
|
1995-06-27 11:07:30 +00:00
|
|
|
return (0);
|
1998-05-31 17:27:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Accumulate the fragments into a record.
|
|
|
|
|
*/
|
|
|
|
|
mpp = &slp->ns_frag;
|
|
|
|
|
while (*mpp)
|
|
|
|
|
mpp = &((*mpp)->m_next);
|
|
|
|
|
*mpp = recm;
|
|
|
|
|
if (slp->ns_flag & SLP_LASTFRAG) {
|
|
|
|
|
struct nfsrv_rec *rec;
|
|
|
|
|
rec = malloc(sizeof(struct nfsrv_rec), M_NFSRVDESC, waitflag);
|
|
|
|
|
if (!rec) {
|
|
|
|
|
m_freem(slp->ns_frag);
|
|
|
|
|
} else {
|
The VFS/BIO subsystem contained a number of hacks in order to optimize
piecemeal, middle-of-file writes for NFS. These hacks have caused no
end of trouble, especially when combined with mmap(). I've removed
them. Instead, NFS will issue a read-before-write to fully
instantiate the struct buf containing the write. NFS does, however,
optimize piecemeal appends to files. For most common file operations,
you will not notice the difference. The sole remaining fragment in
the VFS/BIO system is b_dirtyoff/end, which NFS uses to avoid cache
coherency issues with read-merge-write style operations. NFS also
optimizes the write-covers-entire-buffer case by avoiding the
read-before-write. There is quite a bit of room for further
optimization in these areas.
The VM system marks pages fully-valid (AKA vm_page_t->valid =
VM_PAGE_BITS_ALL) in several places, most noteably in vm_fault. This
is not correct operation. The vm_pager_get_pages() code is now
responsible for marking VM pages all-valid. A number of VM helper
routines have been added to aid in zeroing-out the invalid portions of
a VM page prior to the page being marked all-valid. This operation is
necessary to properly support mmap(). The zeroing occurs most often
when dealing with file-EOF situations. Several bugs have been fixed
in the NFS subsystem, including bits handling file and directory EOF
situations and buf->b_flags consistancy issues relating to clearing
B_ERROR & B_INVAL, and handling B_DONE.
getblk() and allocbuf() have been rewritten. B_CACHE operation is now
formally defined in comments and more straightforward in
implementation. B_CACHE for VMIO buffers is based on the validity of
the backing store. B_CACHE for non-VMIO buffers is based simply on
whether the buffer is B_INVAL or not (B_CACHE set if B_INVAL clear,
and vise-versa). biodone() is now responsible for setting B_CACHE
when a successful read completes. B_CACHE is also set when a bdwrite()
is initiated and when a bwrite() is initiated. VFS VOP_BWRITE
routines (there are only two - nfs_bwrite() and bwrite()) are now
expected to set B_CACHE. This means that bowrite() and bawrite() also
set B_CACHE indirectly.
There are a number of places in the code which were previously using
buf->b_bufsize (which is DEV_BSIZE aligned) when they should have
been using buf->b_bcount. These have been fixed. getblk() now clears
B_DONE on return because the rest of the system is so bad about
dealing with B_DONE.
Major fixes to NFS/TCP have been made. A server-side bug could cause
requests to be lost by the server due to nfs_realign() overwriting
other rpc's in the same TCP mbuf chain. The server's kernel must be
recompiled to get the benefit of the fixes.
Submitted by: Matthew Dillon <dillon@apollo.backplane.com>
1999-05-02 23:57:16 +00:00
|
|
|
nfs_realign(&slp->ns_frag, 10 * NFSX_UNSIGNED);
|
1998-05-31 17:27:58 +00:00
|
|
|
rec->nr_address = (struct sockaddr *)0;
|
|
|
|
|
rec->nr_packet = slp->ns_frag;
|
|
|
|
|
STAILQ_INSERT_TAIL(&slp->ns_rec, rec, nr_link);
|
|
|
|
|
}
|
|
|
|
|
slp->ns_frag = (struct mbuf *)0;
|
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1998-05-31 17:27:58 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1998-05-31 17:27:58 +00:00
|
|
|
/*
|
|
|
|
|
* Parse an RPC header.
|
|
|
|
|
*/
|
|
|
|
|
int
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsrv_dorec(struct nfssvc_sock *slp, struct nfsd *nfsd,
|
|
|
|
|
struct nfsrv_descript **ndp)
|
1998-05-31 17:27:58 +00:00
|
|
|
{
|
|
|
|
|
struct nfsrv_rec *rec;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct mbuf *m;
|
1998-05-31 17:27:58 +00:00
|
|
|
struct sockaddr *nam;
|
2001-09-18 23:32:09 +00:00
|
|
|
struct nfsrv_descript *nd;
|
1998-05-31 17:27:58 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
|
|
*ndp = NULL;
|
|
|
|
|
if ((slp->ns_flag & SLP_VALID) == 0 || !STAILQ_FIRST(&slp->ns_rec))
|
|
|
|
|
return (ENOBUFS);
|
|
|
|
|
rec = STAILQ_FIRST(&slp->ns_rec);
|
|
|
|
|
STAILQ_REMOVE_HEAD(&slp->ns_rec, nr_link);
|
|
|
|
|
nam = rec->nr_address;
|
|
|
|
|
m = rec->nr_packet;
|
|
|
|
|
free(rec, M_NFSRVDESC);
|
|
|
|
|
MALLOC(nd, struct nfsrv_descript *, sizeof (struct nfsrv_descript),
|
|
|
|
|
M_NFSRVDESC, M_WAITOK);
|
|
|
|
|
nd->nd_md = nd->nd_mrep = m;
|
|
|
|
|
nd->nd_nam2 = nam;
|
|
|
|
|
nd->nd_dpos = mtod(m, caddr_t);
|
|
|
|
|
error = nfs_getreq(nd, nfsd, TRUE);
|
|
|
|
|
if (error) {
|
1998-11-13 09:44:12 +00:00
|
|
|
if (nam) {
|
|
|
|
|
FREE(nam, M_SONAME);
|
|
|
|
|
}
|
1998-05-31 17:27:58 +00:00
|
|
|
free((caddr_t)nd, M_NFSRVDESC);
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
*ndp = nd;
|
|
|
|
|
nfsd->nfsd_nd = nd;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Search for a sleeping nfsd and wake it up.
|
|
|
|
|
* SIDE EFFECT: If none found, set NFSD_CHECKSLP flag, so that one of the
|
|
|
|
|
* running nfsds will go look for the work in the nfssvc_sock list.
|
|
|
|
|
*/
|
|
|
|
|
void
|
2001-09-18 23:32:09 +00:00
|
|
|
nfsrv_wakenfsd(struct nfssvc_sock *slp)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-18 23:32:09 +00:00
|
|
|
struct nfsd *nd;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
|
if ((slp->ns_flag & SLP_VALID) == 0)
|
|
|
|
|
return;
|
2001-09-18 23:32:09 +00:00
|
|
|
TAILQ_FOREACH(nd, &nfsd_head, nfsd_chain) {
|
1995-06-27 11:07:30 +00:00
|
|
|
if (nd->nfsd_flag & NFSD_WAITING) {
|
|
|
|
|
nd->nfsd_flag &= ~NFSD_WAITING;
|
|
|
|
|
if (nd->nfsd_slp)
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("nfsd wakeup");
|
|
|
|
|
slp->ns_sref++;
|
1995-06-27 11:07:30 +00:00
|
|
|
nd->nfsd_slp = slp;
|
1994-05-24 10:09:53 +00:00
|
|
|
wakeup((caddr_t)nd);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
slp->ns_flag |= SLP_DOREC;
|
1994-10-17 17:47:45 +00:00
|
|
|
nfsd_head_flag |= NFSD_CHECKSLP;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-18 23:32:09 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This is the nfs send routine.
|
|
|
|
|
* For the server side:
|
|
|
|
|
* - return EINTR or ERESTART if interrupted by a signal
|
|
|
|
|
* - return EPIPE if a connection is lost for connection based sockets (TCP...)
|
|
|
|
|
* - do any cleanup required by recoverable socket errors (?)
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
nfsrv_send(struct socket *so, struct sockaddr *nam, struct mbuf *top)
|
|
|
|
|
{
|
|
|
|
|
struct sockaddr *sendnam;
|
|
|
|
|
int error, soflags, flags;
|
|
|
|
|
|
|
|
|
|
soflags = so->so_proto->pr_flags;
|
|
|
|
|
if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
|
|
|
|
|
sendnam = (struct sockaddr *)0;
|
|
|
|
|
else
|
|
|
|
|
sendnam = nam;
|
|
|
|
|
if (so->so_type == SOCK_SEQPACKET)
|
|
|
|
|
flags = MSG_EOR;
|
|
|
|
|
else
|
|
|
|
|
flags = 0;
|
|
|
|
|
|
|
|
|
|
error = so->so_proto->pr_usrreqs->pru_sosend(so, sendnam, 0, top, 0,
|
|
|
|
|
flags, curthread/*XXX*/);
|
|
|
|
|
if (error == ENOBUFS && so->so_type == SOCK_DGRAM)
|
|
|
|
|
error = 0;
|
|
|
|
|
|
|
|
|
|
if (error) {
|
|
|
|
|
log(LOG_INFO, "nfsd send error %d\n", error);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Handle any recoverable (soft) socket errors here. (?)
|
|
|
|
|
*/
|
|
|
|
|
if (error != EINTR && error != ERESTART &&
|
|
|
|
|
error != EWOULDBLOCK && error != EPIPE)
|
|
|
|
|
error = 0;
|
|
|
|
|
}
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Nfs timer routine
|
|
|
|
|
* Scan the nfsreq list and retranmit any requests that have timed out
|
|
|
|
|
* To avoid retransmission attempts on STREAM sockets (in the future) make
|
|
|
|
|
* sure to set the r_retry field to 0 (implies nm_retry == 0).
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
nfsrv_timer(void *arg)
|
|
|
|
|
{
|
|
|
|
|
int s;
|
|
|
|
|
struct nfssvc_sock *slp;
|
|
|
|
|
u_quad_t cur_usec;
|
|
|
|
|
|
|
|
|
|
s = splnet();
|
|
|
|
|
/*
|
|
|
|
|
* Scan the write gathering queues for writes that need to be
|
|
|
|
|
* completed now.
|
|
|
|
|
*/
|
|
|
|
|
cur_usec = nfs_curusec();
|
|
|
|
|
TAILQ_FOREACH(slp, &nfssvc_sockhead, ns_chain) {
|
|
|
|
|
if (LIST_FIRST(&slp->ns_tq) && LIST_FIRST(&slp->ns_tq)->nd_time<=cur_usec)
|
|
|
|
|
nfsrv_wakenfsd(slp);
|
|
|
|
|
}
|
|
|
|
|
splx(s);
|
|
|
|
|
nfsrv_timer_handle = timeout(nfsrv_timer, (void *)0, nfs_ticks);
|
|
|
|
|
}
|
