nfs_syscalls.c revision 1.1
1 /* 2 * Copyright (c) 1989 The Regents of the University of California. 3 * 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_syscalls.c 7.26 (Berkeley) 4/16/91 37 */ 38 39 #include "param.h" 40 #include "systm.h" 41 #include "kernel.h" 42 #include "file.h" 43 #include "stat.h" 44 #include "namei.h" 45 #include "vnode.h" 46 #include "mount.h" 47 #include "proc.h" 48 #include "malloc.h" 49 #include "buf.h" 50 #include "mbuf.h" 51 #include "socket.h" 52 #include "socketvar.h" 53 #include "domain.h" 54 #include "protosw.h" 55 56 #include "../netinet/in.h" 57 #include "../netinet/tcp.h" 58 59 #include "nfsv2.h" 60 #include "nfs.h" 61 #include "nfsrvcache.h" 62 63 /* Global defs. */ 64 extern u_long nfs_prog, nfs_vers; 65 extern int (*nfsrv_procs[NFS_NPROCS])(); 66 extern struct buf nfs_bqueue; 67 extern int nfs_numasync; 68 extern struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON]; 69 extern int nfs_tcpnodelay; 70 struct mbuf *nfs_compress(); 71 72 #define TRUE 1 73 #define FALSE 0 74 75 static int nfs_asyncdaemon[NFS_MAXASYNCDAEMON]; 76 static int compressreply[NFS_NPROCS] = { 77 FALSE, 78 TRUE, 79 TRUE, 80 FALSE, 81 TRUE, 82 TRUE, 83 FALSE, 84 FALSE, 85 TRUE, 86 TRUE, 87 TRUE, 88 TRUE, 89 TRUE, 90 TRUE, 91 TRUE, 92 TRUE, 93 TRUE, 94 TRUE, 95 }; 96 /* 97 * NFS server system calls 98 * getfh() lives here too, but maybe should move to kern/vfs_syscalls.c 99 */ 100 101 /* 102 * Get file handle system call 103 */ 104 /* ARGSUSED */ 105 getfh(p, uap, retval) 106 struct proc *p; 107 register struct args { 108 char *fname; 109 fhandle_t *fhp; 110 } *uap; 111 int *retval; 112 { 113 register struct nameidata *ndp; 114 register struct vnode *vp; 115 fhandle_t fh; 116 int error; 117 struct nameidata nd; 118 119 /* 120 * Must be super user 121 */ 122 if (error = suser(p->p_ucred, &p->p_acflag)) 123 return (error); 124 ndp = &nd; 125 ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW; 126 ndp->ni_segflg = UIO_USERSPACE; 127 ndp->ni_dirp = uap->fname; 128 if (error = namei(ndp, p)) 129 return (error); 130 vp = ndp->ni_vp; 131 bzero((caddr_t)&fh, sizeof(fh)); 132 fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid; 133 error = VFS_VPTOFH(vp, &fh.fh_fid); 134 vput(vp); 135 if (error) 136 return (error); 137 error = copyout((caddr_t)&fh, (caddr_t)uap->fhp, sizeof (fh)); 138 return (error); 139 } 140 141 /* 142 * Nfs server psuedo system call for the nfsd's 143 * Never returns unless it fails or gets killed 144 */ 145 /* ARGSUSED */ 146 nfssvc(p, uap, retval) 147 struct proc *p; 148 register struct args { 149 int s; 150 caddr_t mskval; 151 int msklen; 152 caddr_t mtchval; 153 int mtchlen; 154 } *uap; 155 int *retval; 156 { 157 register struct mbuf *m; 158 register int siz; 159 register struct ucred *cr; 160 struct file *fp; 161 struct mbuf *mreq, *mrep, *nam, *md; 162 struct mbuf msk, mtch; 163 struct socket *so; 164 caddr_t dpos; 165 int procid, repstat, error, cacherep, wascomp; 166 u_long retxid; 167 168 /* 169 * Must be super user 170 */ 171 if (error = suser(p->p_ucred, &p->p_acflag)) 172 return (error); 173 if (error = getsock(p->p_fd, uap->s, &fp)) 174 return (error); 175 so = (struct socket *)fp->f_data; 176 if (sosendallatonce(so)) 177 siz = NFS_MAXPACKET; 178 else 179 siz = NFS_MAXPACKET + sizeof(u_long); 180 if (error = soreserve(so, siz, siz)) 181 goto bad; 182 if (error = sockargs(&nam, uap->mskval, uap->msklen, MT_SONAME)) 183 goto bad; 184 bcopy((caddr_t)nam, (caddr_t)&msk, sizeof (struct mbuf)); 185 msk.m_data = msk.m_dat; 186 m_freem(nam); 187 if (error = sockargs(&nam, uap->mtchval, uap->mtchlen, MT_SONAME)) 188 goto bad; 189 bcopy((caddr_t)nam, (caddr_t)&mtch, sizeof (struct mbuf)); 190 mtch.m_data = mtch.m_dat; 191 m_freem(nam); 192 193 /* Copy the cred so others don't see changes */ 194 cr = p->p_ucred = crcopy(p->p_ucred); 195 196 /* 197 * Set protocol specific options { for now TCP only } and 198 * reserve some space. For datagram sockets, this can get called 199 * repeatedly for the same socket, but that isn't harmful. 200 */ 201 if (so->so_proto->pr_flags & PR_CONNREQUIRED) { 202 MGET(m, M_WAIT, MT_SOOPTS); 203 *mtod(m, int *) = 1; 204 m->m_len = sizeof(int); 205 sosetopt(so, SOL_SOCKET, SO_KEEPALIVE, m); 206 } 207 if (so->so_proto->pr_domain->dom_family == AF_INET && 208 so->so_proto->pr_protocol == IPPROTO_TCP && 209 nfs_tcpnodelay) { 210 MGET(m, M_WAIT, MT_SOOPTS); 211 *mtod(m, int *) = 1; 212 m->m_len = sizeof(int); 213 sosetopt(so, IPPROTO_TCP, TCP_NODELAY, m); 214 } 215 so->so_rcv.sb_flags &= ~SB_NOINTR; 216 so->so_rcv.sb_timeo = 0; 217 so->so_snd.sb_flags &= ~SB_NOINTR; 218 so->so_snd.sb_timeo = 0; 219 220 /* 221 * Just loop around doin our stuff until SIGKILL 222 */ 223 for (;;) { 224 if (error = nfs_getreq(so, nfs_prog, nfs_vers, NFS_NPROCS-1, 225 &nam, &mrep, &md, &dpos, &retxid, &procid, cr, 226 &msk, &mtch, &wascomp)) { 227 if (nam) 228 m_freem(nam); 229 if (error == EPIPE || error == EINTR || 230 error == ERESTART) { 231 error = 0; 232 goto bad; 233 } 234 so->so_error = 0; 235 continue; 236 } 237 238 if (nam) 239 cacherep = nfsrv_getcache(nam, retxid, procid, &mreq); 240 else 241 cacherep = RC_DOIT; 242 switch (cacherep) { 243 case RC_DOIT: 244 if (error = (*(nfsrv_procs[procid]))(mrep, md, dpos, 245 cr, retxid, &mreq, &repstat, p)) { 246 nfsstats.srv_errs++; 247 if (nam) { 248 nfsrv_updatecache(nam, retxid, procid, 249 FALSE, repstat, mreq); 250 m_freem(nam); 251 } 252 break; 253 } 254 nfsstats.srvrpccnt[procid]++; 255 if (nam) 256 nfsrv_updatecache(nam, retxid, procid, TRUE, 257 repstat, mreq); 258 mrep = (struct mbuf *)0; 259 case RC_REPLY: 260 m = mreq; 261 siz = 0; 262 while (m) { 263 siz += m->m_len; 264 m = m->m_next; 265 } 266 if (siz <= 0 || siz > NFS_MAXPACKET) { 267 printf("mbuf siz=%d\n",siz); 268 panic("Bad nfs svc reply"); 269 } 270 mreq->m_pkthdr.len = siz; 271 mreq->m_pkthdr.rcvif = (struct ifnet *)0; 272 if (wascomp && compressreply[procid]) { 273 mreq = nfs_compress(mreq); 274 siz = mreq->m_pkthdr.len; 275 } 276 /* 277 * For non-atomic protocols, prepend a Sun RPC 278 * Record Mark. 279 */ 280 if (!sosendallatonce(so)) { 281 M_PREPEND(mreq, sizeof(u_long), M_WAIT); 282 *mtod(mreq, u_long *) = htonl(0x80000000 | siz); 283 } 284 error = nfs_send(so, nam, mreq, (struct nfsreq *)0); 285 if (nam) 286 m_freem(nam); 287 if (mrep) 288 m_freem(mrep); 289 if (error) { 290 if (error == EPIPE || error == EINTR || 291 error == ERESTART) 292 goto bad; 293 so->so_error = 0; 294 } 295 break; 296 case RC_DROPIT: 297 m_freem(mrep); 298 m_freem(nam); 299 break; 300 }; 301 } 302 bad: 303 return (error); 304 } 305 306 /* 307 * Nfs pseudo system call for asynchronous i/o daemons. 308 * These babies just pretend to be disk interrupt service routines 309 * for client nfs. They are mainly here for read ahead/write behind. 310 * Never returns unless it fails or gets killed 311 */ 312 /* ARGSUSED */ 313 async_daemon(p, uap, retval) 314 struct proc *p; 315 struct args *uap; 316 int *retval; 317 { 318 register struct buf *bp, *dp; 319 register int i, myiod; 320 int error; 321 322 /* 323 * Must be super user 324 */ 325 if (error = suser(p->p_ucred, &p->p_acflag)) 326 return (error); 327 /* 328 * Assign my position or return error if too many already running 329 */ 330 myiod = -1; 331 for (i = 0; i < NFS_MAXASYNCDAEMON; i++) 332 if (nfs_asyncdaemon[i] == 0) { 333 nfs_asyncdaemon[i]++; 334 myiod = i; 335 break; 336 } 337 if (myiod == -1) 338 return (EBUSY); 339 nfs_numasync++; 340 dp = &nfs_bqueue; 341 /* 342 * Just loop around doin our stuff until SIGKILL 343 */ 344 for (;;) { 345 while (dp->b_actf == NULL && error == 0) { 346 nfs_iodwant[myiod] = p; 347 error = tsleep((caddr_t)&nfs_iodwant[myiod], 348 PWAIT | PCATCH, "nfsidl", 0); 349 nfs_iodwant[myiod] = (struct proc *)0; 350 } 351 while (dp->b_actf != NULL) { 352 /* Take one off the end of the list */ 353 bp = dp->b_actl; 354 if (bp->b_actl == dp) { 355 dp->b_actf = dp->b_actl = (struct buf *)0; 356 } else { 357 dp->b_actl = bp->b_actl; 358 bp->b_actl->b_actf = dp; 359 } 360 (void) nfs_doio(bp); 361 } 362 if (error) { 363 nfs_asyncdaemon[myiod] = 0; 364 nfs_numasync--; 365 return (error); 366 } 367 } 368 } 369
Indexes created Mon Oct 20 20:10:13 GMT 2025