![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfs_syscalls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / nfs|
Return to nfs_syscalls.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / nfs |
1.1 root 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 is only permitted until one year after the first shipment
9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
10: * binary forms are permitted provided that: (1) source distributions retain
11: * this entire copyright notice and comment, and (2) distributions including
12: * binaries display the following acknowledgement: This product includes
13: * software developed by the University of California, Berkeley and its
14: * contributors'' in the documentation or other materials provided with the
15: * distribution and in all advertising materials mentioning features or use
16: * of this software. Neither the name of the University nor the names of
17: * its contributors may be used to endorse or promote products derived from
18: * this software without specific prior written permission.
19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22: *
23: * @(#)nfs_syscalls.c 7.18 (Berkeley) 6/28/90
24: */
25:
26: #include "param.h"
27: #include "systm.h"
28: #include "user.h"
29: #include "kernel.h"
30: #include "file.h"
31: #include "stat.h"
32: #include "vnode.h"
33: #include "mount.h"
34: #include "proc.h"
35: #include "uio.h"
36: #include "malloc.h"
37: #include "buf.h"
38: #include "mbuf.h"
39: #include "socket.h"
40: #include "socketvar.h"
41: #include "domain.h"
42: #include "protosw.h"
43: #include "../netinet/in.h"
44: #include "../netinet/tcp.h"
45: #include "nfsv2.h"
46: #include "nfs.h"
47: #include "nfsrvcache.h"
48:
49: /* Global defs. */
50: extern u_long nfs_prog, nfs_vers;
51: extern int (*nfsrv_procs[NFS_NPROCS])();
52: extern struct buf nfs_bqueue;
53: extern int nfs_asyncdaemons;
54: extern struct proc *nfs_iodwant[NFS_MAXASYNCDAEMON];
55: extern int nfs_tcpnodelay;
56: struct file *getsock();
57:
58: #define TRUE 1
59: #define FALSE 0
60:
61: /*
62: * NFS server system calls
63: * getfh() lives here too, but maybe should move to kern/vfs_syscalls.c
64: */
65:
66: /*
67: * Get file handle system call
68: */
69: /* ARGSUSED */
70: getfh(p, uap, retval)
71: struct proc *p;
72: register struct args {
73: char *fname;
74: fhandle_t *fhp;
75: } *uap;
76: int *retval;
77: {
78: register struct nameidata *ndp = &u.u_nd;
79: register struct vnode *vp;
80: fhandle_t fh;
81: int error;
82:
83: /*
84: * Must be super user
85: */
86: if (error = suser(ndp->ni_cred, &u.u_acflag))
87: return (error);
88: ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
89: ndp->ni_segflg = UIO_USERSPACE;
90: ndp->ni_dirp = uap->fname;
91: if (error = namei(ndp))
92: return (error);
93: vp = ndp->ni_vp;
94: bzero((caddr_t)&fh, sizeof(fh));
95: fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
96: error = VFS_VPTOFH(vp, &fh.fh_fid);
97: vput(vp);
98: if (error)
99: return (error);
100: error = copyout((caddr_t)&fh, (caddr_t)uap->fhp, sizeof (fh));
101: return (error);
102: }
103:
104: /*
105: * Nfs server psuedo system call for the nfsd's
106: * Never returns unless it fails or gets killed
107: */
108: /* ARGSUSED */
109: nfssvc(p, uap, retval)
110: struct proc *p;
111: register struct args {
112: int s;
113: caddr_t mskval;
114: int msklen;
115: caddr_t mtchval;
116: int mtchlen;
117: } *uap;
118: int *retval;
119: {
120: register struct mbuf *m;
121: register int siz;
122: register struct ucred *cr;
123: struct file *fp;
124: struct mbuf *mreq, *mrep, *nam, *md;
125: struct mbuf msk, mtch;
126: struct socket *so;
127: caddr_t dpos;
128: int procid, repstat, error, cacherep;
129: u_long retxid;
130:
131: /*
132: * Must be super user
133: */
134: if (error = suser(u.u_cred, &u.u_acflag))
135: goto bad;
136: fp = getsock(uap->s);
137: if (fp == 0)
138: return;
139: so = (struct socket *)fp->f_data;
140: if (sosendallatonce(so))
141: siz = NFS_MAXPACKET;
142: else
143: siz = NFS_MAXPACKET + sizeof(u_long);
144: if (error = soreserve(so, siz, siz))
145: goto bad;
146: if (error = sockargs(&nam, uap->mskval, uap->msklen, MT_SONAME))
147: goto bad;
148: bcopy((caddr_t)nam, (caddr_t)&msk, sizeof (struct mbuf));
149: msk.m_data = msk.m_dat;
150: m_freem(nam);
151: if (error = sockargs(&nam, uap->mtchval, uap->mtchlen, MT_SONAME))
152: goto bad;
153: bcopy((caddr_t)nam, (caddr_t)&mtch, sizeof (struct mbuf));
154: mtch.m_data = mtch.m_dat;
155: m_freem(nam);
156:
157: /* Copy the cred so others don't see changes */
158: cr = u.u_cred = crcopy(u.u_cred);
159:
160: /*
161: * Set protocol specific options { for now TCP only } and
162: * reserve some space. For datagram sockets, this can get called
163: * repeatedly for the same socket, but that isn't harmful.
164: */
165: if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
166: MGET(m, M_WAIT, MT_SOOPTS);
167: *mtod(m, int *) = 1;
168: m->m_len = sizeof(int);
169: sosetopt(so, SOL_SOCKET, SO_KEEPALIVE, m);
170: }
171: if (so->so_proto->pr_domain->dom_family == AF_INET &&
172: so->so_proto->pr_protocol == IPPROTO_TCP &&
173: nfs_tcpnodelay) {
174: MGET(m, M_WAIT, MT_SOOPTS);
175: *mtod(m, int *) = 1;
176: m->m_len = sizeof(int);
177: sosetopt(so, IPPROTO_TCP, TCP_NODELAY, m);
178: }
179: so->so_rcv.sb_flags &= ~SB_NOINTR;
180: so->so_rcv.sb_timeo = 0;
181: so->so_snd.sb_flags &= ~SB_NOINTR;
182: so->so_snd.sb_timeo = 0;
183:
184: /*
185: * Just loop around doin our stuff until SIGKILL
186: */
187: for (;;) {
188: if (error = nfs_getreq(so, nfs_prog, nfs_vers, NFS_NPROCS-1,
189: &nam, &mrep, &md, &dpos, &retxid, &procid, cr,
190: &msk, &mtch)) {
191: if (nam)
192: m_freem(nam);
193: if (error == EPIPE || error == EINTR ||
194: error == ERESTART) {
195: error = 0;
196: goto bad;
197: }
198: so->so_error = 0;
199: continue;
200: }
201:
202: if (nam)
203: cacherep = nfsrv_getcache(nam, retxid, procid, &mreq);
204: else
205: cacherep = RC_DOIT;
206: switch (cacherep) {
207: case RC_DOIT:
208: if (error = (*(nfsrv_procs[procid]))(mrep, md, dpos,
209: cr, retxid, &mreq, &repstat)) {
210: nfsstats.srv_errs++;
211: if (nam) {
212: nfsrv_updatecache(nam, retxid, procid,
213: FALSE, repstat, mreq);
214: m_freem(nam);
215: }
216: break;
217: }
218: nfsstats.srvrpccnt[procid]++;
219: if (nam)
220: nfsrv_updatecache(nam, retxid, procid, TRUE,
221: repstat, mreq);
222: mrep = (struct mbuf *)0;
223: case RC_REPLY:
224: m = mreq;
225: siz = 0;
226: while (m) {
227: siz += m->m_len;
228: m = m->m_next;
229: }
230: if (siz <= 0 || siz > NFS_MAXPACKET) {
231: printf("mbuf siz=%d\n",siz);
232: panic("Bad nfs svc reply");
233: }
234: mreq->m_pkthdr.len = siz;
235: mreq->m_pkthdr.rcvif = (struct ifnet *)0;
236: /*
237: * For non-atomic protocols, prepend a Sun RPC
238: * Record Mark.
239: */
240: if (!sosendallatonce(so)) {
241: M_PREPEND(mreq, sizeof(u_long), M_WAIT);
242: *mtod(mreq, u_long *) = htonl(0x80000000 | siz);
243: }
244: error = nfs_send(so, nam, mreq, (struct nfsreq *)0);
245: if (nam)
246: m_freem(nam);
247: if (mrep)
248: m_freem(mrep);
249: if (error) {
250: if (error == EPIPE || error == EINTR ||
251: error == ERESTART)
252: goto bad;
253: so->so_error = 0;
254: }
255: break;
256: case RC_DROPIT:
257: m_freem(mrep);
258: m_freem(nam);
259: break;
260: };
261: }
262: bad:
263: return (error);
264: }
265:
266: /*
267: * Nfs pseudo system call for asynchronous i/o daemons.
268: * These babies just pretend to be disk interrupt service routines
269: * for client nfs. They are mainly here for read ahead/write behind.
270: * Never returns unless it fails or gets killed
271: */
272: /* ARGSUSED */
273: async_daemon(p, uap, retval)
274: struct proc *p;
275: struct args *uap;
276: int *retval;
277: {
278: register struct buf *bp, *dp;
279: int error;
280: int myiod;
281:
282: /*
283: * Must be super user
284: */
285: if (error = suser(u.u_cred, &u.u_acflag))
286: return (error);
287: /*
288: * Assign my position or return error if too many already running
289: */
290: if (nfs_asyncdaemons > NFS_MAXASYNCDAEMON)
291: return (EBUSY);
292: myiod = nfs_asyncdaemons++;
293: dp = &nfs_bqueue;
294: /*
295: * Just loop around doin our stuff until SIGKILL
296: */
297: for (;;) {
298: while (dp->b_actf == NULL) {
299: nfs_iodwant[myiod] = p;
300: if (error = tsleep((caddr_t)&nfs_iodwant[myiod],
301: PWAIT | PCATCH, "nfsidl", 0))
302: return (error);
303: }
304: /* Take one off the end of the list */
305: bp = dp->b_actl;
306: if (bp->b_actl == dp) {
307: dp->b_actf = dp->b_actl = (struct buf *)0;
308: } else {
309: dp->b_actl = bp->b_actl;
310: bp->b_actl->b_actf = dp;
311: }
312: (void) nfs_doio(bp);
313: }
314: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.