![[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] / researchv10no / sys / fs|
Return to netb.c CVS log | Up to [Research Unix] / researchv10no / sys / 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: /*
167: * here and in nbwrite, `tonetlong(..., Ltol(u.u_offset))' is OK.
168: * it looks like four function calls, one per byte,
169: * but Ltol is a macro without side effects.
170: * maybe there should just be a temporary for clarity
171: */
172: nbread(ip)
173: register struct inode *ip;
174: {
175: unsigned char sbuf[SRDSIZE];
176: register unsigned char *rp;
177: register unsigned char *sp;
178: register int n;
179:
180: ip->i_un.i_fsflags &=~ NSTOK;
181: rp = getnbbuf();
182: sp = sbuf;
183: bzero(sp, sizeof(sbuf));
184: tonetchar(sp, SNB_VERSION, NETB);
185: tonetchar(sp, SNB_CMD, NBREAD);
186: tonetlong(sp, SNB_LEN, sizeof(sbuf));
187: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
188: do {
189: n = u.u_count;
190: if(n > nbbsz - RNBSIZE)
191: n = nbbsz - RNBSIZE;
192: tonetlong(sp, SRD_LEN, n);
193: tonetlong(sp, SRD_OFFSET, Ltol(u.u_offset));
194: nbsend(ip, sp, rp, nbbsz);
195: if (u.u_error)
196: break;
197: n = frnetlong(rp, RNB_LEN) - RNBSIZE;
198: if(n > 0 && n <= nbbsz) /* give it to user */
199: iomove(rp + RNBSIZE, n, B_READ);
200: } while (u.u_error == 0 && u.u_count > 0 && n > 0
201: && frnetchar(rp, RNB_FLAGS) != NBEND);
202: putnbbuf(rp);
203: }
204:
205: nbdirread(ip, len)
206: register struct inode *ip;
207: {
208: unsigned char sbuf[SRDSIZE];
209: register unsigned char *sp;
210: register unsigned char *rp; /* RDISIZE */
211: int n;
212: llong_t oldoff;
213: long netoff; /* just the 32-bit part */
214:
215: ip->i_un.i_fsflags &=~ NSTOK;
216: rp = getnbbuf();
217: sp = sbuf;
218: bzero(sp, sizeof(sbuf));
219: tonetchar(sp, SNB_VERSION, NETB);
220: tonetchar(sp, SNB_CMD, NBDIR);
221: tonetlong(sp, SNB_LEN, sizeof(sbuf));
222: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
223: if(len > nbbsz - RDISIZE)
224: len = nbbsz - RDISIZE;
225: tonetlong(sp, SRD_LEN, len);
226: oldoff = u.u_offset;
227: netoff = Ltol(u.u_offset);
228: tonetlong(sp, SRD_OFFSET, netoff);
229: nbsend(ip, sp, rp, nbbsz);
230: if(u.u_error)
231: goto out;
232: n = frnetlong(rp, RNB_LEN) - RDISIZE;
233: if (n > 0 && n <= nbbsz)
234: iomove(rp + RDISIZE, n, B_READ);
235: if (u.u_error)
236: goto out;
237: u.u_offset = Lladd(oldoff, frnetlong(rp, RDI_USED));
238: u.u_r.r_val1 = n;
239: out:
240: putnbbuf(rp);
241: }
242:
243: nbwrite(ip)
244: register struct inode *ip;
245: {
246: register unsigned char *sp;
247: unsigned char rbuf[RNBSIZE];
248: int n;
249:
250: ip->i_un.i_fsflags &=~ NSTOK;
251: sp = getnbbuf();
252: bzero(sp, SWRSIZE);
253: tonetchar(sp, SNB_VERSION, NETB);
254: tonetchar(sp, SNB_CMD, NBWRT);
255: tonetlong(sp, SNB_TAG, ip->i_un.i_tag);
256: do {
257: n = u.u_count;
258: if(n > nbbsz - SWRSIZE)
259: n = nbbsz - SWRSIZE;
260: tonetlong(sp, SNB_LEN, n + SWRSIZE);
261: tonetlong(sp, SWR_LEN, n);
262: tonetlong(sp, SWR_OFFSET, Ltol(u.u_offset));
263: iomove(sp + SWRSIZE, n, B_WRITE);
264: if (u.u_error)
265: break;
266: nbsend(ip, sp, rbuf, sizeof(rbuf));
267: if (u.u_error)
268: break;
269: ip->i_flag |= IUPD|ICHG;
270: } while(u.u_count > 0);
271: if(u.u_error == 0)
272: ip->i_size = frnetlong(rbuf, RNB_FSIZE);
273: putnbbuf(sp);
274: }
275:
276: nbioctl(ip, cmd, addr, flag) /* fp->f_flag */
277: register struct inode *ip;
278: caddr_t addr;
279: {
280: register unsigned char *p;
281: int size;
282:
283: switch(cmd) {
284: case NBIOCON:
285: nbdebug = 1;
286: return;
287: case NBIOCOFF:
288: nbdebug = 0;
289: return;
290: case NBIOCBSZ:
291: if (copyin(addr, (caddr_t)&size, sizeof(size))) {
292: u.u_error = EFAULT;
293: return;
294: }
295: if (size > 1024 && size <= NBMAXMSG)
296: nbbsz = size & ~1023; /* round to even 1K */
297: if (copyout(addr, (caddr_t)&nbbsz, sizeof(nbbsz)))
298: u.u_error = EFAULT;
299: return;
300: }
301: /*
302: * one buffer, used first for sbuf, then for rbuf
303: */
304: p = getnbbuf();
305: bzero(p, SIOSIZE);
306: tonetchar(p, SNB_VERSION, NETB);
307: tonetchar(p, SNB_CMD, NBIOCTL);
308: tonetlong(p, SNB_LEN, SIOSIZE + SIODATA);
309: tonetlong(p, SNB_TAG, ip->i_un.i_tag);
310: tonetlong(p, SIO_CMD, cmd);
311: tonetshort(p, SIO_FLAG, flag);
312: if(copyin(addr, p + SIOSIZE, SIODATA)) {
313: u.u_error = EFAULT;
314: goto out;
315: }
316: nbsend(ip, p, p, RNBSIZE + SIODATA);
317: if (u.u_error)
318: goto out;
319: if(frnetlong(p, RNB_LEN) != RNBSIZE + SIODATA) {
320: printf("netb: nbioc got %d, not %d\n",
321: frnetlong(p, RNB_LEN), RNBSIZE+SIODATA);
322: u.u_error = EIO;
323: goto out;
324: }
325: if(copyout(p+RNBSIZE, addr, SIODATA))
326: u.u_error = EFAULT;
327: out:
328: putnbbuf(p);
329: }
330:
331: /*
332: * namei:
333: * send the whole pathname
334: * wrong if another filesystem is mounted
335: * atop some file in this one
336: */
337: nbnami(p, flagp, follow)
338: register struct nx *p;
339: register struct argnamei *flagp;
340: {
341: register char *cp;
342: register struct inode *dp;
343: register unsigned char *pp;
344: register int nlen;
345: int used;
346: dev_t dev;
347:
348: dp = p->dp;
349: /*
350: * special case:
351: * if simple lookup of "" in the root,
352: * and the connection is dead,
353: * return OK even though dead so it's possible to unmount
354: */
355: if (dp->i_mpoint->i_mroot == dp
356: && dp->i_un.i_fsflags & NDEAD
357: && flagp->flag == NI_SEARCH && *p->cp == 0)
358: return (0); /* with the same dp and cp */
359: /*
360: * one buffer for rbuf and sbuf
361: */
362: pp = getnbbuf();
363: bzero(pp, SNMSIZE);
364: tonetchar(pp, SNB_VERSION, NETB);
365: tonetchar(pp, SNB_CMD, NBNAMI);
366: tonetlong(pp, SNB_TAG, dp->i_un.i_tag);
367: cp = p->cp;
368: while (*cp++)
369: ;
370: nlen = cp - p->cp; /* length of name, including NUL */
371: if (nlen + SNMSIZE >= nbbsz) {
372: u.u_error = ENOENT;
373: goto outnull;
374: }
375: used = nlen + SNMSIZE - 1; /* temporary to improve code */
376: tonetlong(pp, SNB_LEN, used);
377: bcopy(p->cp, pp + SNMSIZE, nlen);
378: tonetchar(pp, SNB_FLAGS, flagp->flag);
379: switch (flagp->flag) {
380:
381: case NI_CREAT:
382: case NI_NXCREAT:
383: case NI_MKDIR:
384: tonetshort(pp, SNM_MODE, flagp->un.mode);
385: break;
386:
387: case NI_LINK:
388: tonetlong(pp, SNM_INO, flagp->un.il->i_un.i_tag);
389: break;
390: }
391: nbsend(dp, pp, pp, RNMSIZE);
392: if(u.u_error)
393: goto outnull;
394: if (frnetchar(pp, RNB_FLAGS) == NBROOT) {
395: /* find my root */
396: dp = dp->i_mpoint;
397: iput(p->dp);
398: if(dp == NULL) {
399: u.u_error = EGREG;
400: goto out;
401: }
402: plock(dp);
403: dp->i_count++;
404: used = frnetlong(pp, RNM_USED);
405: if (used < 2 || used >= nlen) {
406: u.u_error = EGREG;
407: goto outnull;
408: }
409: cp = p->cp + used;
410: *--cp == '.';
411: *--cp == '.';
412: p->cp = cp;
413: goto outmore;
414: }
415: switch(flagp->flag) {
416:
417: default:
418: panic("nbnami");
419:
420: case NI_CREAT: /* only case where flagp is used later (creat()) */
421: case NI_NXCREAT: /* return an inode, like search */
422: flagp->un.mode = ~flagp->un.mode; /* obscure side-effects! */
423: case NI_SEARCH:
424: break;
425:
426: case NI_DEL: /* nothing returned */
427: case NI_LINK: /* nothing returned */
428: case NI_MKDIR: /* nothing returned */
429: case NI_RMDIR: /* nothing returned */
430: goto outnull;
431: }
432: /*
433: * release directory inode, construct a new one
434: * fill in the attributes even if inode was already in core;
435: * the new data is more correct (server gets priority)
436: */
437: prele(dp); /* in case new == old */
438: /* cheat: first character of RNM_DEV == minor */
439: dev = makedev(major(dp->i_dev), frnetchar(pp, RNM_DEV));
440: dp = iget(dp, dev, frnetlong(pp, RNM_INO));
441: /* p->dp == dp before iget was called */
442: if (dp == NULL) {
443: idec(p->dp);
444: goto out;
445: }
446: if (p->dp->i_mpoint != dp->i_mpoint) { /* something mounted here */
447: idec(p->dp);
448: p->cp += nlen - 1; /* point to NUL at the end */
449: goto outmore;
450: }
451: dp->i_un.i_cip = p->dp->i_un.i_cip;
452: idec(p->dp);
453: nbunpack(dp, pp);
454: /*
455: * no filename to save for accounting; oh well
456: */
457: if(flagp->flag == NI_SEARCH && flagp->un.buf)
458: bcopy("netb exec", flagp->un.buf, flagp->len);
459:
460: /*
461: * return the inode in dp
462: */
463: out:
464: p->dp = dp;
465: putnbbuf(pp);
466: return (0);
467:
468: /*
469: * discard dp, return NULL
470: */
471: outnull:
472: iput(dp);
473: p->dp = NULL;
474: putnbbuf(pp);
475: return (0);
476:
477: /*
478: * crossed to a different filesystem;
479: * return cp and dp
480: */
481: outmore:
482: p->dp = dp;
483: putnbbuf(pp);
484: return (1);
485: }
486:
487: nbmount(cip, dip, flag, mnt, fstyp)
488: struct inode *cip, *dip;
489: {
490:
491: nbfstyp = fstyp;
492: if (mnt)
493: nbon(cip, dip, flag, fstyp);
494: else
495: nboff(dip);
496: }
497:
498: /*
499: * data structures for keeping track of device numbers in use
500: */
501: #define NDEVS 256
502: static char nbdevs[NDEVS];
503:
504: #define D_SET(dev) nbdevs[dev] = 1
505: #define D_CLR(dev) nbdevs[dev] = 0
506: #define D_ISSET(dev) nbdevs[dev]
507:
508: /*
509: * mount the filesystem
510: * fake up a namei message to fetch the root
511: * don't call nbnami because it's too hard to get
512: * all the first-time error checks right
513: */
514:
515: nbon(cip, dip, flag, fstyp)
516: struct inode *cip;
517: struct inode *dip;
518: {
519: register struct inode *rip;
520: struct inode pi;
521: register unsigned char *pp;
522: unsigned char sbuf[SNMSIZE+1];
523: unsigned char rbuf[RNMSIZE];
524: register int dmaj;
525:
526: if(cip->i_sptr == NULL) { /* shouting into the storm */
527: u.u_error = ENXIO;
528: return;
529: }
530: for (dmaj = 0; dmaj < NDEVS; dmaj++)
531: if (D_ISSET(dmaj) == 0)
532: break;
533: if (dmaj >= NDEVS) {
534: u.u_error = EMFILE;
535: return;
536: }
537: D_SET(dmaj);
538: /*
539: * fake up an inode to represent the connection
540: * to nbsend and iget
541: */
542: pi.i_fstyp = fstyp;
543: pi.i_mpoint = π
544: pi.i_mroot = π /* pi.i_mpoint->i_mroot == &pi */
545: pi.i_un.i_cip = cip;
546: pi.i_un.i_fsflags = 0;
547: pp = sbuf;
548: bzero(pp, sizeof(sbuf));
549: tonetchar(pp, SNB_VERSION, NETB);
550: tonetchar(pp, SNB_CMD, NBNAMI);
551: tonetlong(pp, SNB_TAG, NBROOTTAG); /* lookup in the root */
552: tonetlong(pp, SNB_LEN, SNMSIZE+1); /* one char of filename */
553: /* tonetchar(pp, SNMSIZE, 0); /* "" */
554: tonetchar(pp, SNB_FLAGS, NI_SEARCH);
555: nbsend(&pi, pp, rbuf, sizeof(rbuf));
556: if (u.u_error) {
557: D_CLR(dmaj);
558: return;
559: }
560: pp = rbuf;
561: if (frnetchar(pp, RNB_FLAGS) != 0) {
562: D_CLR(dmaj);
563: u.u_error = EINVAL;
564: return;
565: }
566: if ((rip = iget(&pi, makedev(dmaj, frnetchar(pp, RNM_DEV)), frnetlong(pp, RNM_INO))) == NULL) {
567: D_CLR(dmaj);
568: return;
569: }
570: if (rip->i_count != 1) {
571: printf("nbon busy, dev %d\n", dmaj); /* shouldn't happen */
572: iput(rip);
573: D_CLR(dmaj);
574: u.u_error = EBUSY;
575: return;
576: }
577: nbunpack(rip, pp);
578: rip->i_un.i_cip = cip;
579: dip->i_mroot = rip;
580: rip->i_mpoint = dip;
581: prele(rip);
582: dip->i_count++;
583: cip->i_count++;
584: }
585:
586: /*
587: * unpack inode info from namei response
588: * a pity stat can't use this too,
589: * but the stat response isn't quite the same format
590: */
591: nbunpack(dp, pp)
592: register struct inode *dp;
593: register unsigned char *pp;
594: {
595:
596: dp->i_un.i_tag = frnetlong(pp, RNM_TAG);
597: dp->i_mode = frnetshort(pp, RNM_MODE);
598: dp->i_nlink = frnetshort(pp, RNM_NLINK);
599: dp->i_uid = frnetshort(pp, RNM_UID);
600: dp->i_gid = frnetshort(pp, RNM_GID);
601: dp->i_size = frnetlong(pp, RNM_SIZE);
602: dp->i_un.i_netatime = frnetlong(pp, RNM_ATIME);
603: dp->i_un.i_netmtime = frnetlong(pp, RNM_MTIME);
604: dp->i_un.i_netctime = frnetlong(pp, RNM_CTIME);
605: dp->i_un.i_netrdev = frnetlong(pp, RNM_RDEV);
606: if (dp->i_count == 1)
607: dp->i_un.i_fsflags = 0;
608: dp->i_un.i_fsflags |= NSTOK;
609: }
610:
611: /*
612: * unmount a netb--
613: * mip is the mount point
614: * locking needs some thought
615: */
616: nboff(mip)
617: register struct inode *mip;
618: {
619: register struct inode *rip;
620:
621: rip = mip->i_mroot;
622: plock(rip);
623: if (rip->i_mpoint != mip) { /* already unmounted */
624: prele(rip);
625: return;
626: }
627: xumount(rip);
628: iupdat(rip, &time, &time, 1);
629: ifsinacc(rip); /* turn all, including rip, to errfs */
630: plock(mip);
631: mip->i_mroot = NULL;
632: iput(mip);
633: if (rip->i_un.i_cip == NULL)
634: panic("nboff");
635: iput(rip->i_un.i_cip);
636: D_CLR(major(rip->i_dev));
637: iput(rip); /* errput, not nbput */
638: }
639:
640: nbsend(ip, sp, rp, size)
641: struct inode *ip;
642: register unsigned char *sp;
643: unsigned char *rp;
644: {
645: int bad;
646: long tn;
647: struct inode *cip;
648: register struct inode *rip;
649:
650: cip = ip->i_un.i_cip;
651: rip = ip->i_mpoint->i_mroot;
652: if (rip == NULL || rip->i_fstyp != ip->i_fstyp) {
653: u.u_error = EIO;
654: return;
655: }
656: while ((rip->i_un.i_fsflags & (NBUSY|NDEAD)) == NBUSY
657: && ip->i_fstyp == nbfstyp) {
658: rip->i_un.i_fsflags |= NWANT;
659: if (tsleep((caddr_t)cip, PZERO+1, 0) != TS_OK) {
660: u.u_error = EIO;
661: return;
662: }
663: }
664: if (ip->i_fstyp != nbfstyp /* unmounted under us */
665: || rip->i_un.i_fsflags & NDEAD) { /* or connection fell down */
666: u.u_error = EIO;
667: return;
668: }
669: rip->i_un.i_fsflags |= NBUSY;
670: tonetshort(sp, SNB_UID, u.u_uid);
671: tonetshort(sp, SNB_GID, u.u_gid);
672: tn = nbtrannum++;
673: tonetlong(sp, SNB_TRANNUM, tn);
674: if (istwrite(cip, sp, frnetlong(sp, SNB_LEN)) >= 0
675: && nbrecv(cip, rp, size, tn) >= 0)
676: bad = 0;
677: else
678: bad = 1;
679: if (ip->i_fstyp == nbfstyp) { /* in case unmounted while asleep */
680: rip->i_un.i_fsflags &=~ NBUSY;
681: if (rip->i_un.i_fsflags & NWANT) {
682: wakeup((caddr_t)cip);
683: rip->i_un.i_fsflags &=~ NWANT;
684: }
685: if (bad)
686: rip->i_un.i_fsflags |= NDEAD;
687: }
688: if (bad)
689: u.u_error = EIO;
690: else if ((bad = frnetshort(rp, RNB_ERRNO)) != 0)
691: u.u_error = bad;
692: }
693:
694: /*
695: * read an answer,
696: * and make sure it smells like one of ours
697: */
698:
699: int
700: nbrecv(cip, rp, size, tn)
701: struct inode *cip;
702: register unsigned char *rp;
703: int size;
704: long tn;
705: {
706: unsigned char *p;
707: register int n, len, netlen;
708:
709: loop:
710: p = rp;
711: len = 0;
712: /*
713: * header
714: */
715: while (len < RNBSIZE) {
716: n = istread(cip, p, size - len, 0);
717: if (n <= 0)
718: return (-1);
719: len += n;
720: p += n;
721: }
722: netlen = frnetlong(rp, RNB_LEN);
723: if (netlen > size || netlen < RNBSIZE) {
724: printf("netb: rcv len %d\n", netlen);
725: return (-1);
726: }
727: /*
728: * following data, if any
729: */
730: while (len < netlen) {
731: n = istread(cip, p, size - len, 0);
732: if (n <= 0)
733: return (-1);
734: len += n;
735: p += n;
736: }
737: if (frnetlong(rp, RNB_TRANNUM) != tn) {
738: if (frnetlong(rp, RNB_TRANNUM) < tn) /* echo from the past */
739: goto loop;
740: printf("netb: exp tran %d, got %d\n", tn, frnetlong(rp, RNB_TRANNUM));
741: return (-1);
742: }
743: return (len);
744: }
745:
746: /* oh no, it's got its own tiny buffer pool: want to avoid breakage on
747: normal (4k reads for now). we could replace this with a real
748: memory manager in the kernel */
749: #define NBUF 7 /* who knows? */
750: char nb_lock;
751: char nbflgs[NBUF];
752: unsigned char nbbuf[NBUF][NBMAXMSG];
753:
754: unsigned char *
755: getnbbuf()
756: {
757: register int i;
758:
759: loop:
760: for(i = 0; i < NBUF; i++)
761: if(!nbflgs[i]) {
762: nbflgs[i] = 1;
763: return(nbbuf[i]);
764: }
765: nb_lock = 1;
766: sleep((caddr_t)&nb_lock, PZERO);
767: goto loop;
768: }
769:
770: putnbbuf(s)
771: unsigned char *s;
772: {
773: register int i;
774:
775: for(i = 0; i < NBUF; i++)
776: if(nbbuf[i] == s) {
777: nbflgs[i] = 0;
778: if(nb_lock) {
779: nb_lock = 0;
780: wakeup((caddr_t) &nb_lock);
781: }
782: return;
783: }
784: panic("putnbbuf");
785: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.