![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to netb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / lsys / fs|
Return to netb.c CVS log | Up to [Research Unix] / researchv10dc / lsys / fs |
1.1 root 1: #include "sys/param.h"
2: #include "sys/user.h"
3: #include "sys/netb.h"
4: #include "sys/inode.h"
5: #include "sys/buf.h"
6: #include "sys/systm.h"
7: #include "sys/stat.h"
8: #include "sys/file.h"
9: #include "sys/conf.h"
10: #include "sys/nbio.h"
11:
12: static long nbtrannum;
13: static int nbfstyp;
14: int nbdebug;
15: int nbput(), nbupdat(), nbread(), nbwrite(), nbtrunc(), nbstat();
16: int nbnami(), nbioctl(), nbmount(), nbdirread();
17: struct fstypsw nbfs =
18: fsinit(nbput, nbupdat, nbread, nbwrite, nbtrunc, nbstat,
19: nbnami, nbmount, nbioctl, nullopen, nbdirread);
20: unsigned char *getnbbuf();
21: #define NBMAXMSG (5*1024) /* probably enough */
22: int nbbsz = NBMAXMSG;
23:
24: /*
25: * flags in i_un.i_fsflags
26: * valid only in the root inode
27: */
28: #define NBUSY 01 /* already a message outstanding */
29: #define NWANT 02 /* someone waiting for BUSY */
30: #define NDEAD 04 /* communication line assumed dead */
31:
32: /*
33: * flags valid in any netb inode
34: */
35: #define NSTOK 010 /* inode data is fresh; skip next stat message */
36:
37: nbput(ip)
38: register struct inode *ip;
39: {
40: unsigned char sbuf[SNBSIZE];
41: unsigned char rbuf[RNBSIZE];
42: register unsigned char *sp;
43:
44:
45: /* don't put root, as optimization. pointless? */
46: if (ip->i_mpoint->i_mroot == ip)
47: return;
48: if(ip->i_flag & ICHG) /* this is an extra message, but not often? */
49: nbupdat(ip, &time, &time, 0);
50: sp = sbuf;
51: bzero(sp, sizeof(sbuf));
52: tonetchar(sp, SNB_VERSION, NETB);
53: tonetchar(sp, SNB_CMD, NBPUT);
54: tonetlong(sp, SNB_LEN, sizeof(sbuf));
55: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
56: nbsend(ip, sp, rbuf, sizeof(rbuf));
57: }
58:
59: nbtrunc(ip)
60: register struct inode *ip;
61: {
62: unsigned char sbuf[SNBSIZE];
63: unsigned char rbuf[RNBSIZE];
64: register unsigned char *sp;
65:
66: ip->i_un.i_fsflags &=~ NSTOK;
67: sp = sbuf;
68: bzero(sp, sizeof(sbuf));
69: tonetchar(sp, SNB_VERSION, NETB);
70: tonetchar(sp, SNB_CMD, NBTRNC);
71: tonetlong(sp, SNB_LEN, sizeof(sbuf));
72: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
73: nbsend(ip, sp, rbuf, sizeof(rbuf));
74: }
75:
76: /*
77: * the only times we're interested in are those which have waitfor == 0
78: * (or those which have ta or tb != &time)
79: */
80: nbupdat(ip, ta, tb, waitfor)
81: register time_t *ta, *tb;
82: register struct inode *ip;
83: {
84: unsigned char sbuf[SUPSIZE];
85: unsigned char rbuf[RNBSIZE];
86: register unsigned char *sp;
87:
88: ip->i_un.i_fsflags &=~ NSTOK;
89: sp = sbuf;
90: bzero(sp, sizeof(sbuf));
91: tonetchar(sp, SNB_VERSION, NETB);
92: tonetchar(sp, SNB_CMD, NBUPD);
93: tonetlong(sp, SNB_LEN, sizeof(sbuf));
94: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
95: tonetshort(sp, SUP_MODE, ip->i_mode);
96: /*
97: * in theory *ta or *tb could be incremented
98: * while we are copying them char-by-char
99: * in practice, it doesn't matter,
100: * as *t? != &time
101: */
102: if((ta != &time) && (ip->i_flag & IACC))
103: tonetlong(sp, SUP_ATIME, *ta);
104: if((tb != &time) && (ip->i_flag & IUPD))
105: tonetlong(sp, SUP_MTIME, *tb);
106: nbsend(ip, sp, rbuf, sizeof(rbuf));
107: ip->i_flag &= ~(IUPD|IACC|ICHG);
108: }
109:
110: /*
111: * if NSTOK is set,
112: * the inode is full of stat data from a recent namei
113: * for stat, NSTOK always set, because we just called namei
114: * (except for the root, for which namei isn't called)
115: * for fstat, it is probably not set
116: */
117: nbstat(ip, ub)
118: register struct inode *ip;
119: struct stat *ub;
120: {
121: unsigned char sbuf[SSTSIZE];
122: unsigned char rbuf[RSTSIZE];
123: struct stat ds;
124: register unsigned char *p;
125: long now;
126:
127: if ((ip->i_un.i_fsflags & NSTOK) == 0) {
128: p = sbuf;
129: bzero(p, sizeof(sbuf));
130: tonetchar(p, SNB_VERSION, NETB);
131: tonetchar(p, SNB_CMD, NBSTAT);
132: tonetlong(p, SNB_LEN, sizeof(sbuf));
133: tonetlong(p, SNB_TAG, ip->i_un.i_tag);
134: now = time; /* in case clock ticks */
135: tonetlong(p, SST_TIME, now);
136: nbsend(ip, p, rbuf, sizeof(rbuf));
137: if(u.u_error)
138: return;
139: p = rbuf;
140: ip->i_mode = frnetshort(p, RST_MODE);
141: ip->i_nlink = frnetshort(p, RST_NLINK);
142: ip->i_uid = frnetshort(p, RST_UID);
143: ip->i_gid = frnetshort(p, RST_GID);
144: ip->i_size = frnetlong(p, RST_SIZE);
145: ip->i_un.i_netatime = frnetlong(p, RST_ATIME);
146: ip->i_un.i_netmtime = frnetlong(p, RST_MTIME);
147: ip->i_un.i_netctime = frnetlong(p, RST_CTIME);
148: ip->i_un.i_netrdev = frnetlong(p, RST_RDEV);
149: }
150: ds.st_dev = ip->i_dev;
151: ds.st_ino = ip->i_number;
152: ds.st_mode = ip->i_mode;
153: ds.st_nlink = ip->i_nlink;
154: ds.st_uid = ip->i_uid;
155: ds.st_gid = ip->i_gid;
156: ds.st_size = ip->i_size;
157: ds.st_atime = ip->i_un.i_netatime;
158: ds.st_mtime = ip->i_un.i_netmtime;
159: ds.st_ctime = ip->i_un.i_netctime;
160: ds.st_rdev = ip->i_un.i_netrdev;
161: if(copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)))
162: u.u_error = EFAULT;
163: ip->i_un.i_fsflags &=~ NSTOK; /* so repeated fstats check for changes */
164: }
165:
166: nbread(ip)
167: register struct inode *ip;
168: {
169: unsigned char sbuf[SRDSIZE];
170: register unsigned char *rp;
171: register unsigned char *sp;
172: register int n;
173:
174: ip->i_un.i_fsflags &=~ NSTOK;
175: rp = getnbbuf();
176: sp = sbuf;
177: bzero(sp, sizeof(sbuf));
178: tonetchar(sp, SNB_VERSION, NETB);
179: tonetchar(sp, SNB_CMD, NBREAD);
180: tonetlong(sp, SNB_LEN, sizeof(sbuf));
181: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
182: do {
183: n = u.u_count;
184: if(n > nbbsz - RNBSIZE)
185: n = nbbsz - RNBSIZE;
186: tonetlong(sp, SRD_LEN, n);
187: tonetlong(sp, SRD_OFFSET, Ltol(u.u_offset));
188: nbsend(ip, sp, rp, nbbsz);
189: if (u.u_error)
190: break;
191: n = frnetlong(rp, RNB_LEN) - RNBSIZE;
192: if(n > 0 && n <= nbbsz) /* give it to user */
193: iomove(rp + RNBSIZE, n, B_READ);
194: } while (u.u_error == 0 && u.u_count > 0 && n > 0
195: && frnetchar(rp, RNB_FLAGS) != NBEND);
196: putnbbuf(rp);
197: }
198:
199: nbdirread(ip, len)
200: register struct inode *ip;
201: {
202: unsigned char sbuf[SRDSIZE];
203: register unsigned char *sp;
204: register unsigned char *rp; /* RDISIZE */
205: int n;
206:
207: ip->i_un.i_fsflags &=~ NSTOK;
208: rp = getnbbuf();
209: sp = sbuf;
210: bzero(sp, sizeof(sbuf));
211: tonetchar(sp, SNB_VERSION, NETB);
212: tonetchar(sp, SNB_CMD, NBDIR);
213: tonetlong(sp, SNB_LEN, sizeof(sbuf));
214: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
215: if(len > nbbsz - RDISIZE)
216: len = nbbsz - RDISIZE;
217: tonetlong(sp, SRD_LEN, len);
218: tonetlong(sp, SRD_OFFSET, Ltol(u.u_offset));
219: nbsend(ip, sp, rp, nbbsz);
220: if(u.u_error)
221: goto out;
222: n = frnetlong(rp, RNB_LEN) - RDISIZE;
223: if(n > 0) { /* why not iomove? */
224: if(u.u_segflg != SEGSYS) {
225: if(copyout(rp + RDISIZE, u.u_base, n))
226: u.u_error = EFAULT;
227: }
228: else
229: bcopy(rp + RDISIZE, u.u_base, n);
230: }
231: u.u_offset = Lladd(u.u_offset, frnetlong(rp, RDI_USED));
232: u.u_r.r_val1 = n;
233: out:
234: putnbbuf(rp);
235: }
236:
237: nbwrite(ip)
238: register struct inode *ip;
239: {
240: register unsigned char *sp;
241: unsigned char rbuf[RNBSIZE];
242: int n;
243:
244: ip->i_un.i_fsflags &=~ NSTOK;
245: sp = getnbbuf();
246: bzero(sp, SWRSIZE);
247: tonetchar(sp, SNB_VERSION, NETB);
248: tonetchar(sp, SNB_CMD, NBWRT);
249: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
250: do {
251: n = u.u_count;
252: if(n > nbbsz - SWRSIZE)
253: n = nbbsz - SWRSIZE;
254: tonetlong(sp, SNB_LEN, n + SWRSIZE);
255: tonetlong(sp, SWR_LEN, n);
256: tonetlong(sp, SWR_OFFSET, Ltol(u.u_offset));
257: iomove(sp + SWRSIZE, n, B_WRITE);
258: if (u.u_error)
259: break;
260: nbsend(ip, sp, rbuf, sizeof(rbuf));
261: if (u.u_error)
262: break;
263: ip->i_flag |= IUPD|ICHG;
264: } while(u.u_count > 0);
265: if(u.u_error == 0)
266: ip->i_size = frnetlong(rbuf, RNB_FSIZE);
267: putnbbuf(sp);
268: }
269:
270: nbioctl(ip, cmd, addr, flag) /* fp->f_flag */
271: register struct inode *ip;
272: caddr_t addr;
273: {
274: register unsigned char *p;
275: int size;
276:
277: switch(cmd) {
278: case NBIOCON:
279: nbdebug = 1;
280: return;
281: case NBIOCOFF:
282: nbdebug = 0;
283: return;
284: case NBIOCBSZ:
285: if (copyin(addr, (caddr_t)&size, sizeof(size))) {
286: u.u_error = EFAULT;
287: return;
288: }
289: if (size > 1024 && size <= NBMAXMSG)
290: nbbsz = size & ~1023; /* round to even 1K */
291: if (copyout(addr, (caddr_t)&nbbsz, sizeof(nbbsz)))
292: u.u_error = EFAULT;
293: return;
294: }
295: /*
296: * one buffer, used first for sbuf, then for rbuf
297: */
298: p = getnbbuf();
299: bzero(p, SIOSIZE);
300: tonetchar(p, SNB_VERSION, NETB);
301: tonetchar(p, SNB_CMD, NBIOCTL);
302: tonetlong(p, SNB_LEN, SIOSIZE + SIODATA);
303: tonetlong(p, SNB_TAG, ip->i_un.i_tag);
304: tonetlong(p, SIO_CMD, cmd);
305: tonetshort(p, SIO_FLAG, flag);
306: if(copyin(addr, p + SIOSIZE, SIODATA)) {
307: u.u_error = EFAULT;
308: goto out;
309: }
310: nbsend(ip, p, p, RNBSIZE + SIODATA);
311: if (u.u_error)
312: goto out;
313: if(frnetlong(p, RNB_LEN) != RNBSIZE + SIODATA) {
314: printf("netb: nbioc got %d, not %d\n",
315: frnetlong(p, RNB_LEN), RNBSIZE+SIODATA);
316: u.u_error = EIO;
317: goto out;
318: }
319: if(copyout(p+RNBSIZE, addr, SIODATA))
320: u.u_error = EFAULT;
321: out:
322: putnbbuf(p);
323: }
324:
325: /*
326: * namei:
327: * send the whole pathname
328: * wrong if another filesystem is mounted
329: * atop some file in this one
330: */
331: nbnami(p, flagp, follow)
332: register struct nx *p;
333: register struct argnamei *flagp;
334: {
335: register char *cp;
336: register struct inode *dp;
337: register unsigned char *pp;
338: register int nlen;
339: int used;
340: dev_t dev;
341:
342: dp = p->dp;
343: /*
344: * special case:
345: * if simple lookup of "" in the root,
346: * and the connection is dead,
347: * return OK even though dead so it's possible to unmount
348: */
349: if (dp->i_mpoint->i_mroot == dp
350: && dp->i_un.i_fsflags & NDEAD
351: && flagp->flag == NI_SEARCH && *p->cp == 0)
352: return (0); /* with the same dp and cp */
353: /*
354: * one buffer for rbuf and sbuf
355: */
356: pp = getnbbuf();
357: bzero(pp, SNMSIZE);
358: tonetchar(pp, SNB_VERSION, NETB);
359: tonetchar(pp, SNB_CMD, NBNAMI);
360: tonetlong(pp, SNB_TAG, dp->i_un.i_tag);
361: cp = p->cp;
362: while (*cp++)
363: ;
364: nlen = cp - p->cp; /* length of name, including NUL */
365: if (nlen + SNMSIZE >= nbbsz) {
366: u.u_error = ENOENT;
367: goto outnull;
368: }
369: used = nlen + SNMSIZE - 1; /* temporary to improve code */
370: tonetlong(pp, SNB_LEN, used);
371: bcopy(p->cp, pp + SNMSIZE, nlen);
372: tonetchar(pp, SNB_FLAGS, flagp->flag);
373: switch (flagp->flag) {
374:
375: case NI_CREAT:
376: case NI_NXCREAT:
377: case NI_MKDIR:
378: tonetshort(pp, SNM_MODE, flagp->un.mode);
379: break;
380:
381: case NI_LINK:
382: tonetlong(pp, SNM_INO, flagp->un.il->i_un.i_tag);
383: break;
384: }
385: nbsend(dp, pp, pp, RNMSIZE);
386: if(u.u_error)
387: goto outnull;
388: if (frnetchar(pp, RNB_FLAGS) == NBROOT) {
389: /* find my root */
390: dp = dp->i_mpoint;
391: iput(p->dp);
392: if(dp == NULL) {
393: u.u_error = EGREG;
394: goto out;
395: }
396: plock(dp);
397: dp->i_count++;
398: used = frnetlong(pp, RNM_USED);
399: if (used < 2 || used >= nlen) {
400: u.u_error = EGREG;
401: goto outnull;
402: }
403: cp = p->cp + used;
404: *--cp == '.';
405: *--cp == '.';
406: p->cp = cp;
407: goto outmore;
408: }
409: switch(flagp->flag) {
410:
411: default:
412: panic("nbnami");
413:
414: case NI_CREAT: /* only case where flagp is used later (creat()) */
415: case NI_NXCREAT: /* return an inode, like search */
416: flagp->un.mode = ~flagp->un.mode; /* obscure side-effects! */
417: case NI_SEARCH:
418: break;
419:
420: case NI_DEL: /* nothing returned */
421: case NI_LINK: /* nothing returned */
422: case NI_MKDIR: /* nothing returned */
423: case NI_RMDIR: /* nothing returned */
424: goto outnull;
425: }
426: /*
427: * release directory inode, construct a new one
428: * fill in the attributes even if inode was already in core;
429: * the new data is more correct (server gets priority)
430: */
431: prele(dp); /* in case new == old */
432: /* cheat: first character of RNM_DEV == minor */
433: dev = makedev(major(dp->i_dev), frnetchar(pp, RNM_DEV));
434: dp = iget(dp, dev, frnetlong(pp, RNM_INO));
435: /* p->dp == dp before iget was called */
436: if (dp == NULL) {
437: idec(p->dp);
438: goto out;
439: }
440: if (p->dp->i_mpoint != dp->i_mpoint) { /* something mounted here */
441: idec(p->dp);
442: p->cp += nlen - 1; /* point to NUL at the end */
443: goto outmore;
444: }
445: dp->i_un.i_cip = p->dp->i_un.i_cip;
446: idec(p->dp);
447: nbunpack(dp, pp);
448: /*
449: * no filename to save for accounting; oh well
450: */
451: if(flagp->flag == NI_SEARCH && flagp->un.buf)
452: bcopy("netb exec", flagp->un.buf, flagp->len);
453:
454: /*
455: * return the inode in dp
456: */
457: out:
458: p->dp = dp;
459: putnbbuf(pp);
460: return (0);
461:
462: /*
463: * discard dp, return NULL
464: */
465: outnull:
466: iput(dp);
467: p->dp = NULL;
468: putnbbuf(pp);
469: return (0);
470:
471: /*
472: * crossed to a different filesystem;
473: * return cp and dp
474: */
475: outmore:
476: p->dp = dp;
477: putnbbuf(pp);
478: return (1);
479: }
480:
481: nbmount(cip, dip, flag, mnt, fstyp)
482: struct inode *cip, *dip;
483: {
484:
485: nbfstyp = fstyp;
486: if (mnt)
487: nbon(cip, dip, flag, fstyp);
488: else
489: nboff(dip);
490: }
491:
492: /*
493: * mount the filesystem
494: * fake up a namei message to fetch the root
495: * don't call nbnami because it's too hard to get
496: * all the first-time error checks right
497: */
498:
499: nbon(cip, dip, flag, fstyp)
500: struct inode *cip;
501: struct inode *dip;
502: {
503: register struct inode *rip;
504: struct inode pi;
505: register unsigned char *pp;
506: unsigned char sbuf[SNMSIZE+1];
507: unsigned char rbuf[RNMSIZE];
508: register dev_t dev;
509:
510: if(cip->i_sptr == NULL) { /* shouting into the storm */
511: u.u_error = ENXIO;
512: return;
513: }
514: if (dip->i_fstyp == fstyp && major(dip->i_dev) == major(flag)) {
515: u.u_error = EBUSY;
516: return;
517: }
518: /*
519: * fake up an inode to represent the connection
520: * to nbsend and iget
521: */
522: pi.i_fstyp = fstyp;
523: pi.i_mpoint = π
524: pi.i_mroot = π /* pi.i_mpoint->i_mroot == &pi */
525: pi.i_un.i_cip = cip;
526: pi.i_un.i_fsflags = 0;
527: pp = sbuf;
528: bzero(pp, sizeof(sbuf));
529: tonetchar(pp, SNB_VERSION, NETB);
530: tonetchar(pp, SNB_CMD, NBNAMI);
531: tonetlong(pp, SNB_TAG, NBROOTTAG); /* lookup in the root */
532: tonetlong(pp, SNB_LEN, SNMSIZE+1); /* one char of filename */
533: /* tonetchar(pp, SNMSIZE, 0); /* "" */
534: tonetchar(pp, SNB_FLAGS, NI_SEARCH);
535: nbsend(&pi, pp, rbuf, sizeof(rbuf));
536: if (u.u_error)
537: return;
538: pp = rbuf;
539: if (frnetchar(pp, RNB_FLAGS) != 0) {
540: u.u_error = EINVAL;
541: return;
542: }
543: dev = makedev(major(flag), frnetchar(pp, RNM_DEV));
544: if ((rip = iget(&pi, dev, frnetlong(pp, RNM_INO))) == NULL)
545: return;
546: if (rip->i_count != 1) {
547: iput(rip);
548: u.u_error = EBUSY;
549: return;
550: }
551: nbunpack(rip, pp);
552: rip->i_un.i_cip = cip;
553: dip->i_mroot = rip;
554: rip->i_mpoint = dip;
555: prele(rip);
556: dip->i_count++;
557: cip->i_count++;
558: }
559:
560: /*
561: * unpack inode info from namei response
562: * a pity stat can't use this too,
563: * but the stat response isn't quite the same format
564: */
565: nbunpack(dp, pp)
566: register struct inode *dp;
567: register unsigned char *pp;
568: {
569:
570: dp->i_un.i_tag = frnetlong(pp, RNM_TAG);
571: dp->i_mode = frnetshort(pp, RNM_MODE);
572: dp->i_nlink = frnetshort(pp, RNM_NLINK);
573: dp->i_uid = frnetshort(pp, RNM_UID);
574: dp->i_gid = frnetshort(pp, RNM_GID);
575: dp->i_size = frnetlong(pp, RNM_SIZE);
576: dp->i_un.i_netatime = frnetlong(pp, RNM_ATIME);
577: dp->i_un.i_netmtime = frnetlong(pp, RNM_MTIME);
578: dp->i_un.i_netctime = frnetlong(pp, RNM_CTIME);
579: dp->i_un.i_netrdev = frnetlong(pp, RNM_RDEV);
580: if (dp->i_count == 1)
581: dp->i_un.i_fsflags = 0;
582: dp->i_un.i_fsflags |= NSTOK;
583: }
584:
585: /*
586: * unmount a netb--
587: * called from above, or from nbsend when there's an error
588: * mip is the mount point
589: * locking needs some thought
590: */
591: nboff(mip)
592: register struct inode *mip;
593: {
594: register struct inode *rip;
595:
596: rip = mip->i_mroot;
597: plock(rip);
598: if (rip->i_mpoint != mip) { /* already unmounted */
599: prele(rip);
600: return;
601: }
602: xumount(rip);
603: iupdat(rip, &time, &time, 1);
604: ifsinacc(rip); /* turn all, including rip, to errfs */
605: plock(mip);
606: mip->i_mroot = NULL;
607: iput(mip);
608: if (rip->i_un.i_cip == NULL)
609: panic("nboff");
610: iput(rip->i_un.i_cip);
611: iput(rip); /* errput, not nbput */
612: }
613:
614: nbsend(ip, sp, rp, size)
615: struct inode *ip;
616: register unsigned char *sp;
617: unsigned char *rp;
618: {
619: int bad;
620: long tn;
621: struct inode *cip;
622: register struct inode *rip;
623:
624: cip = ip->i_un.i_cip;
625: rip = ip->i_mpoint->i_mroot;
626: if (rip == NULL || rip->i_fstyp != ip->i_fstyp) {
627: u.u_error = EIO;
628: return;
629: }
630: while ((rip->i_un.i_fsflags & (NBUSY|NDEAD)) == NBUSY
631: && ip->i_fstyp == nbfstyp) {
632: rip->i_un.i_fsflags |= NWANT;
633: if (tsleep((caddr_t)cip, PZERO+1, 0) != TS_OK) {
634: u.u_error = EIO;
635: return;
636: }
637: }
638: if (ip->i_fstyp != nbfstyp /* unmounted under us */
639: || rip->i_un.i_fsflags & NDEAD) { /* or connection fell down */
640: u.u_error = EIO;
641: return;
642: }
643: rip->i_un.i_fsflags |= NBUSY;
644: tonetshort(sp, SNB_UID, u.u_uid);
645: tonetshort(sp, SNB_GID, u.u_gid);
646: tn = nbtrannum++;
647: tonetlong(sp, SNB_TRANNUM, tn);
648: if (istwrite(cip, sp, frnetlong(sp, SNB_LEN)) >= 0
649: && nbrecv(cip, rp, size, tn) >= 0)
650: bad = 0;
651: else
652: bad = 1;
653: if (ip->i_fstyp == nbfstyp) { /* in case unmounted while asleep */
654: rip->i_un.i_fsflags &=~ NBUSY;
655: if (rip->i_un.i_fsflags & NWANT) {
656: wakeup((caddr_t)cip);
657: rip->i_un.i_fsflags &=~ NWANT;
658: }
659: if (bad)
660: rip->i_un.i_fsflags |= NDEAD;
661: }
662: if (bad)
663: u.u_error = EIO;
664: else if ((bad = frnetshort(rp, RNB_ERRNO)) != 0)
665: u.u_error = bad;
666: }
667:
668: /*
669: * read an answer,
670: * and make sure it smells like one of ours
671: */
672:
673: int
674: nbrecv(cip, rp, size, tn)
675: struct inode *cip;
676: register unsigned char *rp;
677: int size;
678: long tn;
679: {
680: unsigned char *p;
681: register int n, len, netlen;
682:
683: loop:
684: p = rp;
685: len = 0;
686: /*
687: * header
688: */
689: while (len < RNBSIZE) {
690: n = istread(cip, p, size - len, 0);
691: if (n <= 0)
692: return (-1);
693: len += n;
694: p += n;
695: }
696: netlen = frnetlong(rp, RNB_LEN);
697: if (netlen > size || netlen < RNBSIZE) {
698: printf("netb: rcv len %d\n", netlen);
699: return (-1);
700: }
701: /*
702: * following data, if any
703: */
704: while (len < netlen) {
705: n = istread(cip, p, size - len, 0);
706: if (n <= 0)
707: return (-1);
708: len += n;
709: p += n;
710: }
711: if (frnetlong(rp, RNB_TRANNUM) != tn) {
712: if (frnetlong(rp, RNB_TRANNUM) < tn) /* echo from the past */
713: goto loop;
714: printf("netb: exp tran %d, got %d\n", tn, frnetlong(rp, RNB_TRANNUM));
715: return (-1);
716: }
717: return (len);
718: }
719:
720: /* oh no, it's got its own tiny buffer pool: want to avoid breakage on
721: normal (4k reads for now). we could replace this with a real
722: memory manager in the kernel */
723: #define NBUF 7 /* who knows? */
724: char nb_lock;
725: char nbflgs[NBUF];
726: unsigned char nbbuf[NBUF][NBMAXMSG];
727:
728: unsigned char *
729: getnbbuf()
730: {
731: register int i;
732:
733: loop:
734: for(i = 0; i < NBUF; i++)
735: if(!nbflgs[i]) {
736: nbflgs[i] = 1;
737: return(nbbuf[i]);
738: }
739: nb_lock = 1;
740: sleep((caddr_t)&nb_lock, PZERO);
741: goto loop;
742: }
743:
744: putnbbuf(s)
745: unsigned char *s;
746: {
747: register int i;
748:
749: for(i = 0; i < NBUF; i++)
750: if(nbbuf[i] == s) {
751: nbflgs[i] = 0;
752: if(nb_lock) {
753: nb_lock = 0;
754: wakeup((caddr_t) &nb_lock);
755: }
756: return;
757: }
758: panic("putnbbuf");
759: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.