![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fs1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386|
Return to fs1.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 root 1: /* $Header: /src386/STREAMS/coh.386/RCS/fs1.c,v 2.5 93/08/09 13:35:29 bin Exp Locker: bin $ */
2: /* (lgl-
3: * The information contained herein is a trade secret of Mark Williams
4: * Company, and is confidential information. It is provided under a
5: * license agreement, and may be copied or disclosed only under the
6: * terms of that agreement. Any reproduction or disclosure of this
7: * material without the express written authorization of Mark Williams
8: * Company or persuant to the license agreement is unlawful.
9: *
10: * COHERENT Version 2.3.37
11: * Copyright (c) 1982, 1983, 1984.
12: * An unpublished work by Mark Williams Company, Chicago.
13: * All rights reserved.
14: -lgl) */
15: /*
16: * Coherent.
17: * Filesystem (mostly handling of in core inodes).
18: *
19: * $Log: fs1.c,v $
20: * Revision 2.5 93/08/09 13:35:29 bin
21: * Kernel 82 changes
22: *
23: * Revision 2.2 93/07/26 15:19:00 nigel
24: * Nigel's R80
25: *
26: * Revision 1.8 93/04/14 10:06:28 root
27: * r75
28: *
29: * Revision 1.7 93/02/23 15:50:51 root
30: * after caddr_t change, before blclear
31: *
32: * Revision 1.4 92/07/16 16:33:32 hal
33: * Kernel #58
34: *
35: * Revision 1.3 92/02/06 17:55:36 vlad
36: * Fix typo in ialloc panic.
37: *
38: * Revision 1.2 92/01/06 11:59:17 hal
39: * Compile with cc.mwc.
40: *
41: * Revision 1.1 88/03/24 16:13:47 src
42: * Initial revision
43: *
44: * 86/12/13 Allan Cornish /usr/src/sys/coh/fs1.c
45: * isync() no longer updates the disk image of a character device inode.
46: *
47: * 86/11/19 Allan Cornish /usr/src/sys/coh/fs1.c
48: * idirent() initializes the (new) (IO).io_flag field to 0.
49: */
50: #include <sys/coherent.h>
51: #include <sys/buf.h>
52: #include <canon.h>
53: #include <dirent.h>
54: #include <sys/errno.h>
55: #include <sys/filsys.h>
56: #include <sys/ino.h>
57: #include <sys/inode.h>
58: #include <sys/io.h>
59: #include <sys/mount.h>>
60: #include <sys/stat.h>
61: #include <sys/file.h>
62:
63: /*
64: * Get character for `ftoi' depending on what space the characters are
65: * coming from.
66: */
67:
68: #define ftoic(p,seg) ((seg) == IOSYS ? * (p) : getubd (p))
69:
70: /*
71: * Map the given filename to an inode. If an error is encountered,
72: * `u.u_error' is set. `u.u_error' is always returned. As this routine
73: * needs to set several things, depending on the type of access, `t',
74: * there are places in the processes' user area reserved for this routine
75: * to set. These are defined in the user process structure. The seek
76: * position is always set to the position of the directory entry of the
77: * child if the child exists or the first free position if it doesn't.
78: * 'r' => Reference. A pointer to the child's inode is returned locked.
79: * 'c' => Create. If the child exists, a pointer to the inode is returned
80: * locked. Otherwise if the parent directory exists, a pointer to
81: * the parent directory is returned locked. Otherwise, an error.
82: * 'u' => Unlink. The parent directory is returned unlocked. The child's
83: * inode number is returned. The seek position is also set.
84: */
85:
86: int
87: ftoi (np, t, iop, dirent)
88: char * np;
89: int t;
90: IO * iop;
91: struct direct * dirent;
92: {
93: return file_to_inode (np, t, 0, iop, dirent);
94: }
95:
96: /*
97: * Does main ftoi job. Was created to solve the problem with rmdir.
98: * doRmdir is 0 for all cases except when called from rmdir.
99: */
100:
101: int
102: file_to_inode (np, t, doRmdir, iop, dirent)
103: char * np;
104: int t;
105: int doRmdir;
106: IO * iop;
107: struct direct * dirent;
108: {
109: register INODE *cip;
110: register char *cp;
111: register int c;
112: register struct direct *dp;
113: register BUF *bp;
114: off_t cseek, fseek, s;
115: int fflag, mflag;
116: dev_t dev;
117: ino_t ino;
118: daddr_t b;
119:
120: u.u_cdirn = 0;
121: u.u_cdiri = NULL;
122: u.u_pdiri = NULL;
123:
124: if ((c = ftoic (np ++, iop->io_seg)) != '/') {
125: cip = u.u_cdir;
126: } else {
127: c = ftoic (np ++, iop->io_seg);
128: cip = u.u_rdir;
129: }
130: while (c == '/')
131: c = ftoic (np ++, iop->io_seg);
132: ilock (cip);
133: cip->i_refc ++;
134:
135: if (c == '\0') {
136: if (t == 'r') {
137: u.u_cdiri = cip;
138: return u.u_error;
139: }
140:
141: idetach (cip);
142: return u.u_error = ENOENT;
143: }
144:
145: for (;;) {
146: cp = dirent->d_name;
147: while (c != '/' && c != '\0') {
148: if (cp < & dirent->d_name [sizeof (dirent->d_name)])
149: * cp ++ = c;
150: c = ftoic (np ++, iop->io_seg);
151: }
152:
153: while (c == '/')
154: c = ftoic (np ++, iop->io_seg);
155:
156: while (cp < & dirent->d_name [sizeof (dirent->d_name)])
157: * cp ++ = '\0';
158:
159: if ((cip->i_mode & IFMT) != IFDIR)
160: u.u_error = ENOTDIR;
161: else {
162: /* For rmdir we need only write */
163: if (doRmdir)
164: iaccess (cip, IPW);
165: else
166: iaccess (cip, IPE);
167: }
168:
169: if (u.u_error) {
170: idetach (cip);
171: return u.u_error;
172: }
173:
174: cp = dirent->d_name;
175:
176: if (cip->i_ino == ROOTIN && cip->i_dev != rootdev &&
177: * cp ++ == '.' && * cp ++ == '.' && * cp ++ == '\0')
178: cip = ftoim (cip);
179:
180: b = 0;
181: fflag = 0;
182: mflag = 0;
183: cseek = 0;
184: s = cip->i_size;
185:
186: while (s > 0) {
187: if ((bp = vread (cip, b ++)) == NULL) {
188: idetach (cip);
189: return u.u_error;
190: }
191:
192: dp = bp->b_vaddr;
193: while (dp < bp->b_vaddr + BSIZE) {
194:
195: if ((s -= sizeof (* dp)) < 0)
196: break;
197:
198: if ((ino = dp->d_ino) == 0) {
199: if (fflag == 0) {
200: fflag++;
201: fseek = cseek;
202: }
203: } else if (direq (dp, dirent)) {
204: canino (ino);
205: mflag = 1;
206: s = 0;
207: break;
208: }
209: cseek += sizeof (* dp);
210: dp ++;
211: }
212: brelease (bp);
213: }
214:
215: dev = cip->i_dev;
216: if (fflag == 0)
217: fseek = cseek;
218:
219: if (mflag == 0) {
220: if (c == '\0' && t == 'c') {
221: u.u_pdiri = cip;
222: iop->io_seek = fseek;
223: } else {
224: u.u_error = ENOENT;
225: idetach (cip);
226: }
227: return u.u_error;
228: }
229:
230: if (c == '\0') {
231: if (t == 'u') {
232: u.u_cdirn = ino;
233: u.u_pdiri = cip;
234: iop->io_seek = cseek;
235: return u.u_error;
236: }
237:
238: idetach (cip);
239: u.u_cdiri = iattach (dev, ino);
240: return u.u_error;
241: }
242:
243: idetach (cip);
244: if ((cip = iattach (dev, ino)) == NULL)
245: return u.u_error;
246: }
247: }
248:
249:
250: /*
251: * Given an inode which is the root of a file system, return the inode
252: * on which the file system was mounted.
253: */
254: INODE *
255: ftoim(ip)
256: register INODE *ip;
257: {
258: register MOUNT *mp;
259:
260: for (mp = mountp ; mp != NULL ; mp = mp->m_next) {
261: if (mp->m_dev == ip->i_dev) {
262: idetach (ip);
263: ip = mp->m_ip;
264: ilock (ip);
265: ip->i_refc ++;
266: break;
267: }
268: }
269: return ip;
270: }
271:
272:
273: /*
274: * Compare the string in `u.u_direct.d_name' with the name in the
275: * given directory pointer.
276: */
277:
278: direq (dp1, dp2)
279: struct direct * dp1;
280: struct direct * dp2;
281: {
282: return dp1->d_ino == 0 ? 0 :
283: strncmp (dp1->d_name, dp2->d_name, sizeof (dp1->d_name)) == 0;
284: }
285:
286:
287: /*
288: * Make an inode of the given mode and device. The parent directory,
289: * name and such stuff is set by ftoi.
290: */
291:
292: INODE *
293: imake (mode, rdev, iop, dirent)
294: unsigned mode;
295: dev_t rdev;
296: IO * iop;
297: struct direct * dirent;
298: {
299: register INODE *ip;
300:
301: ip = NULL;
302: mode &= ~ u.u_umask;
303: if ((mode & ISVTXT) != 0 && super () == 0)
304: goto det;
305:
306: if (iaccess (u.u_pdiri, IPW) == 0)
307: goto det;
308:
309: if ((ip = ialloc (u.u_pdiri->i_dev, mode)) == NULL)
310: goto det;
311:
312: ip->i_nlink = 1;
313: ip->i_a.i_rdev = rdev;
314: idirent (ip->i_ino, iop, dirent);
315: iamc (ip); /* creat/mknod - atime/mtime/ctime */
316: det:
317: idetach (u.u_pdiri);
318: return ip;
319: }
320:
321:
322: /*
323: * Write a directory entry out. Everything necessary has been conveniently
324: * set by `ftoi', except the new inode number of this directory entry.
325: */
326:
327: idirent (ino, iop, dirent)
328: IO * iop;
329: struct direct * dirent;
330: {
331: dirent->d_ino = ino;
332: canino (dirent->d_ino);
333:
334: iop->io_ioc = sizeof (struct direct);
335: iop->io.vbase = dirent;
336: iop->io_seg = IOSYS;
337: iop->io_flag = 0;
338:
339: iwrite (u.u_pdiri, iop);
340: }
341:
342:
343: /*
344: * Return a pointer to a locked inode in core containing the given
345: * inode number and device.
346: */
347:
348: INODE *
349: iattach (dev, ino)
350: {
351: register INODE *ip;
352: register INODE *fip;
353: register unsigned lrt;
354: register MOUNT *mp;
355:
356: for (;;) {
357: fip = NULL;
358: for (ip = & inodep [NINODE - 1] ; ip >= inodep ; -- ip) {
359: if (ip->i_ino == ino && ip->i_dev == dev)
360: break;
361: if (ip->i_refc == 0) {
362: if (fip == NULL || ip->i_lrt < lrt) {
363: fip = ip;
364: lrt = ip->i_lrt;
365: }
366: }
367: }
368:
369: if (ip < inodep) {
370: if ((ip = fip) == NULL) {
371: devmsg (dev, "Inode table overflow");
372: u.u_error = ENFILE;
373: return NULL;
374: }
375: ilock (ip);
376: if (ip->i_refc != 0) {
377: iunlock (ip);
378: continue;
379: }
380: ip->i_dev = dev;
381: ip->i_ino = ino;
382: ip->i_refc = 1;
383: ip->i_lrt = timer.t_time;
384: ip->i_lastblock = -1;
385: if (icopydm (ip) == 0) {
386: ip->i_ino = 0;
387: ip->i_refc = 0;
388: iunlock (ip);
389: return NULL;
390: }
391: return ip;
392: }
393: if ((ip->i_flag & IFMNT) != 0) {
394: for (mp = mountp ; mp != NULL ; mp = mp->m_next) {
395: if (mp->m_ip == ip) {
396: ino = ROOTIN;
397: dev = mp->m_dev;
398: break;
399: }
400: }
401: continue;
402: }
403: ilock (ip);
404: if (ip->i_ino != ino || ip->i_dev != dev) {
405: iunlock (ip);
406: continue;
407: }
408: if (ip->i_refc < 0)
409: panic ("iattach(%x)", ip);
410: ip->i_refc ++;
411: ip->i_lrt = timer.t_time;
412: return ip;
413: }
414: }
415:
416: /*
417: * Given a locked inode, deaccess it.
418: */
419: idetach(ip)
420: register INODE *ip;
421: {
422: #if 0
423: if (ilocked (ip) == 0 || ip->i_refc <= 0)
424: panic("idetach(%p)", ip);
425: #else
426: if (ilocked (ip) == 0) {
427: printf ("bad unlocked inode, dev=%x, ino=%d, flags=%x\n",
428: ip->i_dev, ip->i_ino, ip->i_flag);
429: panic ("idetach(%p)", ip);
430: }
431: if (ip->i_refc <= 0) {
432: printf ("negative refc, dev=%x, ino=%d, flags=%x, refc=%d\n",
433: ip->i_dev, ip->i_ino, ip->i_flag, ip->i_refc);
434: panic ("idetach(%p)", ip);
435: }
436: #endif
437: if (-- ip->i_refc == 0) {
438: #if 1
439: if (ip->i_rl)
440: panic ("idetach(%p) with locked records", ip);
441: #endif
442: if ((ip->i_flag & (IFACC | IFMOD | IFCRT)) != 0 ||
443: ip->i_nlink == 0)
444: icopymd (ip);
445: }
446: iunlock (ip);
447: }
448:
449: /*
450: * Given a inode which isn't locked, lock it and then deaccess.
451: */
452: ldetach(ip)
453: register INODE *ip;
454: {
455: ilock (ip);
456: idetach (ip);
457: }
458:
459: /*
460: * A specialized routine for finding whether the given inode may be unlinked.
461: * Quite simple you say, but we already have an inode locked and could run
462: * into gating problems if we were to lock another. So we look through the
463: * cache to see if the inode is there. If it is, we can easily tell. If it
464: * isn't, `icopydm' is called with a static. This routine is only used by
465: * `uunlink'.
466: */
467: iucheck(dev, ino)
468: register dev_t dev;
469: register ino_t ino;
470: {
471: register INODE *ip;
472: INODE inode;
473:
474: for (ip = & inodep [NINODE - 1] ; ip >= inodep; -- ip) {
475: if (ip->i_ino == ino && ip->i_dev == dev)
476: break;
477: }
478: if (ip < inodep) {
479: ip = & inode;
480: ip->i_dev = dev;
481: ip->i_ino = ino;
482: if (icopydm (ip) == 0)
483: return 0;
484: }
485: if ((ip->i_mode & IFMT) == IFDIR) {
486: if (super () == 0)
487: return 0;
488: }
489: return 1;
490: }
491:
492: /*
493: * Copy an inode from disk to memory performing canonization.
494: */
495: icopydm(ip)
496: register INODE *ip;
497: {
498: register struct dinode *dip;
499: register BUF *bp;
500: register ino_t ino;
501: struct dinode dinode;
502: caddr_t v;
503:
504: ip->i_flag = 0;
505: ino = ip->i_ino;
506:
507: if ((bp = bread (ip->i_dev, (daddr_t) iblockn (ino),
508: BUF_SYNC)) == NULL)
509: return 0;
510:
511: dip = & dinode;
512: v = (char *) ((struct dinode *) bp->b_vaddr + iblocko (ino));
513: memcpy (dip, v, sizeof (dinode));
514: brelease (bp);
515:
516: ip->i_mode = dip->di_mode;
517: canshort (ip->i_mode);
518: ip->i_nlink = dip->di_nlink;
519: canshort (ip->i_nlink);
520: ip->i_uid = dip->di_uid;
521: canshort (ip->i_uid);
522: ip->i_gid = dip->di_gid;
523: canshort (ip->i_gid);
524: ip->i_size = dip->di_size;
525: cansize (ip->i_size);
526:
527: switch (ip->i_mode & IFMT) {
528: case IFBLK:
529: case IFCHR:
530: ip->i_a.i_rdev = dip->di_a.di_rdev;
531: candev (ip->i_a.i_rdev);
532: break;
533:
534: case IFREG:
535: case IFDIR:
536: l3tol (ip->i_a.i_addr, dip->di_a.di_addb, NADDR);
537: break;
538:
539: case IFPIPE:
540: l3tol (ip->i_pipe, dip->di_addp, ND);
541: ip->i_pnc = dip->di_pnc;
542: canshort (ip->i_pnc);
543: ip->i_prx = dip->di_prx;
544: canshort (ip->i_prx);
545: ip->i_pwx = dip->di_pwx;
546: canshort (ip->i_pwx);
547: break;
548:
549: default:
550: kclear (& ip->i_a, sizeof (ip->i_a));
551: break;
552: }
553:
554: ip->i_atime = dip->di_atime;
555: cantime (ip->i_atime);
556: ip->i_mtime = dip->di_mtime;
557: cantime (ip->i_mtime);
558: ip->i_ctime = dip->di_ctime;
559: cantime (ip->i_ctime);
560: ip->i_rl = NULL;
561: return 1;
562: }
563:
564: /*
565: * Copy an inode from memory back on to disk performing canonization.
566: */
567: icopymd(ip)
568: register INODE *ip;
569: {
570: register struct dinode *dip;
571: register BUF *bp;
572: register ino_t ino;
573: struct dinode dinode;
574: caddr_t v;
575:
576: if (getment (ip->i_dev, 0) == NULL)
577: return;
578:
579: ino = ip->i_ino;
580: if (ip->i_refc == 0 && ip->i_nlink == 0 && ino != BADFIN &&
581: ino != ROOTIN) {
582: iclear (ip);
583: ip->i_lrt = 0;
584: ip->i_mode = 0;
585: }
586:
587: dip = & dinode;
588: dip->di_mode = ip->i_mode;
589: canshort (dip->di_mode);
590: dip->di_nlink = ip->i_nlink;
591: canshort (dip->di_nlink);
592: dip->di_uid = ip->i_uid;
593: canshort (dip->di_uid);
594: dip->di_gid = ip->i_gid;
595: canshort (dip->di_gid);
596: dip->di_size = ip->i_size;
597: cansize (dip->di_size);
598:
599: switch (ip->i_mode & IFMT) {
600: case IFBLK:
601: case IFCHR:
602: dip->di_a.di_rdev = ip->i_a.i_rdev;
603: candev (dip->di_a.di_rdev);
604: break;
605:
606: case IFREG:
607: case IFDIR:
608: ltol3 (dip->di_addr, ip->i_a.i_addr, NADDR);
609: break;
610:
611: case IFPIPE:
612: ltol3 (dip->di_addp, ip->i_pipe, ND);
613: dip->di_pnc = ip->i_pnc;
614: canshort (dip->di_pnc);
615: dip->di_prx = ip->i_prx;
616: canshort (dip->di_prx);
617: dip->di_pwx = ip->i_pwx;
618: canshort (dip->di_pwx);
619: break;
620:
621: default:
622: kclear (& dip->di_a, sizeof (dip->di_a));
623: break;
624: }
625:
626: dip->di_atime = ip->i_atime;
627: cantime (dip->di_atime);
628: dip->di_mtime = ip->i_mtime;
629: cantime (dip->di_mtime);
630: dip->di_ctime = ip->i_ctime;
631: cantime (dip->di_ctime);
632:
633: if ((bp = bread (ip->i_dev, (daddr_t) iblockn (ino),
634: BUF_SYNC)) == NULL)
635: return;
636:
637: v = (char *) ((struct dinode *) bp->b_vaddr + iblocko (ino));
638: memcpy (v, dip, sizeof (dinode));
639: bp->b_flag |= BFMOD;
640: brelease (bp);
641: ip->i_flag &= ~ (IFACC | IFMOD | IFCRT);
642: if (ip->i_refc == 0 && ip->i_nlink == 0 && ino != BADFIN &&
643: ino != ROOTIN)
644: ifree (ip->i_dev, ino);
645: }
646:
647: /*
648: * Copy all relevant inodes out on device `dev'.
649: */
650: isync(dev)
651: register dev_t dev;
652: {
653: register INODE *ip;
654:
655: for (ip = & inodep [NINODE - 1] ; ip >= inodep ; -- ip) {
656: if (ip->i_refc == 0)
657: continue;
658: if (ip->i_dev != dev)
659: continue;
660: if ((ip->i_mode & IFMT) == IFCHR)
661: continue;
662: if ((ip->i_flag & (IFACC | IFMOD | IFCRT)) == 0)
663: continue;
664: icopymd (ip);
665: }
666: }
667:
668: /*
669: * Clear the given inode and all space associated with it.
670: */
671:
672: iclear (ip)
673: register INODE *ip;
674: {
675: register int n;
676: register daddr_t b;
677:
678: switch (ip->i_mode & IFMT) {
679: case IFPIPE:
680: ip->i_pnc = ip->i_prx = ip->i_pwx = 0;
681: n = ND;
682: while (n > 0) {
683: if ((b = ip->i_pipe [-- n]) != 0)
684: bfree (ip->i_dev, b);
685: }
686: memset (ip->i_pipe, 0, sizeof (ip->i_pipe));
687: break;
688:
689: case IFDIR:
690: case IFREG:
691: n = NADDR;
692: while (n > ND) {
693: if ((b = ip->i_a.i_addr [-- n]) != 0)
694: indfree (ip->i_dev, b, 1 + n - ND);
695: }
696: while (n > 0) {
697: if ((b = ip->i_a.i_addr [-- n]) != 0)
698: bfree (ip->i_dev, b);
699: }
700: memset (ip->i_a.i_addr, 0, sizeof (ip->i_a.i_addr));
701: break;
702:
703: default:
704: return;
705: }
706: ip->i_size = 0;
707: iamc (ip); /* creat/pipe - atime/mtime/ctime */
708: }
709:
710: /*
711: * blclear(ip, lbn) -- Clear all blocks in inode ip beginning with
712: * logical blocks number lbn. Called from uchsize() in sys5.c
713: */
714: blclear(ip, lbn)
715: register INODE *ip;
716: fsize_t lbn;
717: {}
718:
719: /*
720: * Copy the appropriate information from the inode to the stat buffer.
721: */
722: istat(ip, sbp)
723: register INODE *ip;
724: register struct stat *sbp;
725: {
726: sbp->st_dev = ip->i_dev;
727: sbp->st_ino = ip->i_ino;
728: sbp->st_mode = ip->i_mode;
729: sbp->st_nlink = ip->i_nlink;
730: sbp->st_uid = ip->i_uid;
731: sbp->st_gid = ip->i_gid;
732: sbp->st_rdev = NODEV;
733: sbp->st_size = ip->i_size;
734: sbp->st_atime = ip->i_atime;
735: sbp->st_mtime = ip->i_mtime;
736: sbp->st_ctime = ip->i_ctime;
737:
738: switch (ip->i_mode & IFMT) {
739: case IFBLK:
740: case IFCHR:
741: sbp->st_rdev = ip->i_a.i_rdev;
742: sbp->st_size = 0;
743: break;
744:
745: case IFPIPE:
746: sbp->st_size = ip->i_pnc;
747: break;
748: }
749: }
750:
751: /*
752: * See if it is possible to access the given inode with the bits in
753: * the given mode.
754: * If the mode includes writing, and i_refc is > 1, then check for
755: * shared text problems.
756: */
757: iaccess(ip, mode)
758: register INODE *ip;
759: register int mode;
760: {
761: /* Super user can do everything with directories */
762: if (((ip->i_mode & IFMT) != IFDIR) || u.u_uid)
763: if ((imode (ip, u.u_uid, u.u_gid) & mode) != mode) {
764: u.u_error = EACCES;
765: return 0;
766: }
767:
768: if ((mode & IPW) != 0 && ip->i_refc > 1 && sbusy (ip)) {
769: u.u_error = ETXTBSY;
770: return 0;
771: }
772: return 1;
773: }
774:
775:
776: /*
777: * Get the maximum allowable mode on a file.
778: */
779:
780: imode(ip, uid, gid)
781: register INODE *ip;
782: {
783: if (uid == 0) {
784: /* Superuser can read or write anything. */
785: int ret = IPR | IPW;
786: /*
787: * If superuser, say the file is executable if any
788: * of the 'x' perm bits is set.
789: */
790: if ((ip->i_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0)
791: ret |= IPE;
792: return ret;
793: }
794: if (uid == ip->i_uid)
795: return (ip->i_mode & S_IRWXU) >> 6;
796: if (gid == ip->i_gid)
797: return (ip->i_mode & S_IRWXG) >> 3;
798: return ip->i_mode & S_IRWXO;
799: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.