![[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 / d / 286_KERNEL / USRSRC / coh|
Return to fs1.c CVS log | Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / coh |
1.1 ! root 1: /* $Header: /newbits/286_KERNEL/USRSRC/coh/RCS/fs1.c,v 1.2 92/01/09 13:27:53 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 1.2 92/01/09 13:27:53 bin ! 21: * new sources provided by hal as new kit designed for 386 sources to be ! 22: * included. ! 23: * ! 24: * Revision 1.1 88/03/24 16:13:47 src ! 25: * Initial revision ! 26: * ! 27: * 87/11/25 Allan Cornish /usr/src/sys/coh/fs1.c ! 28: * vaddr_t bp->b_vaddr --> faddr_t bp->b_faddr. ! 29: * ! 30: * 86/12/13 Allan Cornish /usr/src/sys/coh/fs1.c ! 31: * isync() no longer updates the disk image of a character device inode. ! 32: * ! 33: * 86/11/19 Allan Cornish /usr/src/sys/coh/fs1.c ! 34: * idirent() initializes the (new) (IO).io_flag field to 0. ! 35: */ ! 36: #include <sys/coherent.h> ! 37: #include <sys/buf.h> ! 38: #include <canon.h> ! 39: #include <sys/dir.h> ! 40: #include <errno.h> ! 41: #include <sys/filsys.h> ! 42: #include <sys/ino.h> ! 43: #include <sys/inode.h> ! 44: #include <sys/io.h> ! 45: #include <sys/mount.h>> ! 46: #include <sys/stat.h> ! 47: #include <sys/uproc.h> ! 48: ! 49: /* ! 50: * Get character for `ftoi' depending on what space the characters are ! 51: * coming from. ! 52: */ ! 53: #define ftoic(p) (u.u_io.io_seg==IOSYS ? *p : getubd(p)) ! 54: ! 55: /* ! 56: * Map the given filename to an inode. If an error is encountered, ! 57: * `u.u_error' is set. `u.u_error' is always returned. As this routine ! 58: * needs to set several things, depending on the type of access, `t', ! 59: * there are places in the processes' user area reserved for this routine ! 60: * to set. These are defined in the user process structure. The seek ! 61: * position is always set to the position of the directory entry of the ! 62: * child if the child exists or the first free position if it doesn't. ! 63: * 'r' => Reference. A pointer to the child's inode is returned locked. ! 64: * 'c' => Create. If the child exists, a pointer to the inode is returned ! 65: * locked. Otherwise if the parent directory exists, a pointer to ! 66: * the parent directory is returned locked. Otherwise, an error. ! 67: * 'u' => Unlink. The parent directory is returned unlocked. The child's ! 68: * inode number is returned. The seek position is also set. ! 69: */ ! 70: ftoi(np, t) ! 71: char *np; ! 72: { ! 73: register INODE *cip; ! 74: register char *cp; ! 75: register int c; ! 76: register struct direct *dp; ! 77: register BUF *bp; ! 78: fsize_t cseek, fseek, s; ! 79: int fflag, mflag; ! 80: dev_t dev; ! 81: ino_t ino; ! 82: daddr_t b; ! 83: ! 84: u.u_cdirn = 0; ! 85: u.u_cdiri = NULL; ! 86: u.u_pdiri = NULL; ! 87: if ((c=ftoic(np++)) != '/') ! 88: cip = u.u_cdir; ! 89: else { ! 90: c = ftoic(np++); ! 91: cip = u.u_rdir; ! 92: } ! 93: while (c == '/') ! 94: c = ftoic(np++); ! 95: ilock(cip); ! 96: cip->i_refc++; ! 97: if (c == '\0') { ! 98: if (t == 'r') { ! 99: u.u_cdiri = cip; ! 100: return (u.u_error); ! 101: } ! 102: u.u_error = ENOENT; ! 103: idetach(cip); ! 104: return (u.u_error); ! 105: } ! 106: for (;;) { ! 107: cp = u.u_direct.d_name; ! 108: while (c!='/' && c!='\0') { ! 109: if (cp < &u.u_direct.d_name[DIRSIZ]) ! 110: *cp++ = c; ! 111: c = ftoic(np++); ! 112: } ! 113: while (c == '/') ! 114: c = ftoic(np++); ! 115: while (cp < &u.u_direct.d_name[DIRSIZ]) ! 116: *cp++ = '\0'; ! 117: if ((cip->i_mode&IFMT) != IFDIR) ! 118: u.u_error = ENOTDIR; ! 119: else ! 120: iaccess(cip, IPE); ! 121: if (u.u_error) { ! 122: idetach(cip); ! 123: return (u.u_error); ! 124: } ! 125: cp = u.u_direct.d_name; ! 126: if (cip->i_ino==ROOTIN && cip->i_dev!=rootdev) ! 127: if (*cp++=='.' && *cp++=='.' && *cp++=='\0') ! 128: cip = ftoim(cip); ! 129: b = 0; ! 130: fflag = 0; ! 131: mflag = 0; ! 132: cseek = 0; ! 133: s = cip->i_size; ! 134: while (s > 0) { ! 135: if ((bp=vread(cip, b++)) == NULL) { ! 136: idetach(cip); ! 137: return (u.u_error); ! 138: } ! 139: dp = FP_OFF(bp->b_faddr); ! 140: while (dp < FP_OFF(bp->b_faddr)+BSIZE) { ! 141: if ((s-=sizeof(*dp)) < 0) ! 142: break; ! 143: if ((ino=dp->d_ino) == 0) { ! 144: if (fflag == 0) { ! 145: fflag++; ! 146: fseek = cseek; ! 147: } ! 148: } else { ! 149: if (direq(dp)) { ! 150: canino(ino); ! 151: mflag = 1; ! 152: s = 0; ! 153: break; ! 154: } ! 155: } ! 156: cseek += sizeof(*dp); ! 157: dp++; ! 158: } ! 159: brelease(bp); ! 160: } ! 161: dev = cip->i_dev; ! 162: if (fflag == 0) ! 163: fseek = cseek; ! 164: if (mflag == 0) { ! 165: if (c=='\0' && t=='c') { ! 166: u.u_pdiri = cip; ! 167: u.u_io.io_seek = fseek; ! 168: } else { ! 169: u.u_error = ENOENT; ! 170: idetach(cip); ! 171: } ! 172: return (u.u_error); ! 173: } ! 174: if (c == '\0') { ! 175: if (t == 'u') { ! 176: u.u_cdirn = ino; ! 177: u.u_pdiri = cip; ! 178: u.u_io.io_seek = cseek; ! 179: return (u.u_error); ! 180: } ! 181: idetach(cip); ! 182: u.u_cdiri = iattach(dev, ino); ! 183: return (u.u_error); ! 184: } ! 185: idetach(cip); ! 186: if ((cip=iattach(dev, ino)) == NULL) ! 187: return (u.u_error); ! 188: } ! 189: } ! 190: ! 191: /* ! 192: * Given an inode which is the root of a file system, return the inode ! 193: * on which the file system was mounted. ! 194: */ ! 195: INODE * ! 196: ftoim(ip) ! 197: register INODE *ip; ! 198: { ! 199: register MOUNT *mp; ! 200: ! 201: for (mp=mountp; mp!=NULL; mp=mp->m_next) { ! 202: if (mp->m_dev == ip->i_dev) { ! 203: idetach(ip); ! 204: ip = mp->m_ip; ! 205: ilock(ip); ! 206: ip->i_refc++; ! 207: break; ! 208: } ! 209: } ! 210: return (ip); ! 211: } ! 212: ! 213: /* ! 214: * Compare the string in `u.u_direct.d_name' with the name in the ! 215: * given directory pointer. ! 216: */ ! 217: direq(dp) ! 218: struct direct *dp; ! 219: { ! 220: register char *cp1, *cp2; ! 221: register unsigned n; ! 222: ! 223: if (dp->d_ino == 0) ! 224: return (0); ! 225: cp1 = dp->d_name; ! 226: cp2 = u.u_direct.d_name; ! 227: n = DIRSIZ; ! 228: do { ! 229: if (*cp1++ != *cp2++) ! 230: return (0); ! 231: } while (--n); ! 232: return (1); ! 233: } ! 234: ! 235: /* ! 236: * Make an inode of the given mode and device. The parent directory, ! 237: * name and such stuff is set by ftoi. ! 238: */ ! 239: INODE * ! 240: imake(mode, rdev) ! 241: unsigned mode; ! 242: dev_t rdev; ! 243: { ! 244: register INODE *ip; ! 245: ! 246: ip = NULL; ! 247: mode &= ~u.u_umask; ! 248: if ((mode&ISVTXT)!=0 && super()==0) ! 249: goto det; ! 250: if (iaccess(u.u_pdiri, IPW) == 0) ! 251: goto det; ! 252: if ((ip=ialloc(u.u_pdiri->i_dev, mode)) == NULL) ! 253: goto det; ! 254: ip->i_nlink = 1; ! 255: ip->i_a.i_rdev = rdev; ! 256: idirent(ip->i_ino); ! 257: iamc(ip); /* creat/mknod - atime/mtime/ctime */ ! 258: det: ! 259: idetach(u.u_pdiri); ! 260: return (ip); ! 261: } ! 262: ! 263: /* ! 264: * Write a directory entry out. Everything necessary has been conveniently ! 265: * set by `ftoi', except the new inode number of this directory entry. ! 266: */ ! 267: idirent(ino) ! 268: { ! 269: u.u_direct.d_ino = ino; ! 270: canino(u.u_direct.d_ino); ! 271: u.u_io.io_ioc = sizeof (struct direct); ! 272: u.u_io.io_base = &u.u_direct; ! 273: u.u_io.io_seg = IOSYS; ! 274: u.u_io.io_flag = 0; ! 275: iwrite(u.u_pdiri, &u.u_io); ! 276: } ! 277: ! 278: /* ! 279: * Return a pointer to a locked inode in core containing the given ! 280: * inode number and device. ! 281: */ ! 282: INODE * ! 283: iattach(dev, ino) ! 284: { ! 285: register INODE *ip; ! 286: register INODE *fip; ! 287: register unsigned lrt; ! 288: register MOUNT *mp; ! 289: ! 290: for (;;) { ! 291: fip = NULL; ! 292: for (ip=&inodep[NINODE-1]; ip>=inodep; --ip) { ! 293: if (ip->i_ino==ino && ip->i_dev==dev) ! 294: break; ! 295: if (ip->i_refc == 0) { ! 296: if (fip==NULL || ip->i_lrt<lrt) { ! 297: fip = ip; ! 298: lrt = ip->i_lrt; ! 299: } ! 300: } ! 301: } ! 302: if (ip < inodep) { ! 303: if ((ip=fip) == NULL) { ! 304: devmsg(dev, "Inode table overflow"); ! 305: /*DEBUG*/ ! 306: { char cmd[11];int i; ! 307: for(i=0;i<10&&u.u_comm[i];i++) ! 308: cmd[i]=u.u_comm[i]; ! 309: cmd[i]='\0'; ! 310: printf("cmd=%s time=%lu\n",cmd, u.u_btime); ! 311: } ! 312: u.u_error = ENFILE; ! 313: return (NULL); ! 314: } ! 315: ilock(ip); ! 316: if (ip->i_refc != 0) { ! 317: iunlock(ip); ! 318: continue; ! 319: } ! 320: ip->i_dev = dev; ! 321: ip->i_ino = ino; ! 322: ip->i_refc = 1; ! 323: ip->i_lrt = timer.t_time; ! 324: if (icopydm(ip) == 0) { ! 325: ip->i_ino = 0; ! 326: ip->i_refc = 0; ! 327: iunlock(ip); ! 328: return (NULL); ! 329: } ! 330: return (ip); ! 331: } ! 332: if ((ip->i_flag&IFMNT) != 0) { ! 333: for (mp=mountp; mp!=NULL; mp=mp->m_next) { ! 334: if (mp->m_ip == ip) { ! 335: ino = ROOTIN; ! 336: dev = mp->m_dev; ! 337: break; ! 338: } ! 339: } ! 340: continue; ! 341: } ! 342: ilock(ip); ! 343: if (ip->i_ino!=ino || ip->i_dev!=dev) { ! 344: iunlock(ip); ! 345: continue; ! 346: } ! 347: if (ip->i_refc < 0) ! 348: panic("ialloc(%p), ip"); ! 349: ip->i_refc++; ! 350: ip->i_lrt = timer.t_time; ! 351: return (ip); ! 352: } ! 353: } ! 354: ! 355: /* ! 356: * Given a locked inode, deaccess it. ! 357: */ ! 358: idetach(ip) ! 359: register INODE *ip; ! 360: { ! 361: if (ilocked(ip)==0 || ip->i_refc<=0) ! 362: panic("idetach(%p)", ip); ! 363: if (--ip->i_refc == 0) { ! 364: if ((ip->i_flag&(IFACC|IFMOD|IFCRT)) != 0 ! 365: || ip->i_nlink == 0) ! 366: icopymd(ip); ! 367: } ! 368: iunlock(ip); ! 369: } ! 370: ! 371: /* ! 372: * Given a inode which isn't locked, lock it and then deaccess. ! 373: */ ! 374: ldetach(ip) ! 375: register INODE *ip; ! 376: { ! 377: ilock(ip); ! 378: idetach(ip); ! 379: } ! 380: ! 381: /* ! 382: * A specialized routine for finding whether the given inode may be unlinked. ! 383: * Quite simple you say, but we already have an inode locked and could run ! 384: * into gating problems if we were to lock another. So we look through the ! 385: * cache to see if the inode is there. If it is, we can easily tell. If it ! 386: * isn't, `icopydm' is called with a static. This routine is only used by ! 387: * `uunlink'. ! 388: */ ! 389: iucheck(dev, ino) ! 390: register dev_t dev; ! 391: register ino_t ino; ! 392: { ! 393: register INODE *ip; ! 394: INODE inode; ! 395: ! 396: for (ip=&inodep[NINODE-1]; ip>=inodep; --ip) { ! 397: if (ip->i_ino==ino && ip->i_dev==dev) ! 398: break; ! 399: } ! 400: if (ip < inodep) { ! 401: ip = &inode; ! 402: ip->i_dev = dev; ! 403: ip->i_ino = ino; ! 404: if (icopydm(ip) == 0) ! 405: return (0); ! 406: } ! 407: if ((ip->i_mode&IFMT) == IFDIR) { ! 408: if (super() == 0) ! 409: return (0); ! 410: } ! 411: return (1); ! 412: } ! 413: ! 414: /* ! 415: * Copy an inode from disk to memory performing canonization. ! 416: */ ! 417: icopydm(ip) ! 418: register INODE *ip; ! 419: { ! 420: register struct dinode *dip; ! 421: register BUF *bp; ! 422: register ino_t ino; ! 423: struct dinode dinode; ! 424: vaddr_t v; ! 425: ! 426: ip->i_flag = 0; ! 427: ino = ip->i_ino; ! 428: ! 429: if ((bp=bread(ip->i_dev, (daddr_t)iblockn(ino), 1)) == NULL) ! 430: return (0); ! 431: ! 432: dip = &dinode; ! 433: v = (char *)((struct dinode *)FP_OFF(bp->b_faddr) + iblocko(ino)); ! 434: kkcopy( v, dip, sizeof(dinode)); ! 435: brelease(bp); ! 436: ip->i_mode = dip->di_mode; ! 437: canshort(ip->i_mode); ! 438: ip->i_nlink = dip->di_nlink; ! 439: canshort(ip->i_nlink); ! 440: ip->i_uid = dip->di_uid; ! 441: canshort(ip->i_uid); ! 442: ip->i_gid = dip->di_gid; ! 443: canshort(ip->i_gid); ! 444: ip->i_size = dip->di_size; ! 445: cansize(ip->i_size); ! 446: ! 447: switch (ip->i_mode&IFMT) { ! 448: case IFBLK: ! 449: case IFCHR: ! 450: ip->i_a.i_rdev = dip->di_a.di_rdev; ! 451: candev(ip->i_a.i_rdev); ! 452: break; ! 453: case IFREG: ! 454: case IFDIR: ! 455: l3tol(ip->i_a.i_addr, dip->di_a.di_addb, NADDR); ! 456: break; ! 457: case IFPIPE: ! 458: l3tol(ip->i_pipe, dip->di_addp, ND); ! 459: ip->i_pnc = dip->di_pnc; ! 460: canint(ip->i_pnc); ! 461: ip->i_prx = dip->di_prx; ! 462: canint(ip->i_prx); ! 463: ip->i_pwx = dip->di_pwx; ! 464: canint(ip->i_pwx); ! 465: break; ! 466: default: ! 467: kclear(&ip->i_a, sizeof(ip->i_a)); ! 468: break; ! 469: } ! 470: ! 471: ip->i_atime = dip->di_atime; ! 472: cantime(ip->i_atime); ! 473: ip->i_mtime = dip->di_mtime; ! 474: cantime(ip->i_mtime); ! 475: ip->i_ctime = dip->di_ctime; ! 476: cantime(ip->i_ctime); ! 477: return (1); ! 478: } ! 479: ! 480: /* ! 481: * Copy an inode from memory back on to disk performing canonization. ! 482: */ ! 483: icopymd(ip) ! 484: register INODE *ip; ! 485: { ! 486: register struct dinode *dip; ! 487: register BUF *bp; ! 488: register ino_t ino; ! 489: struct dinode dinode; ! 490: vaddr_t v; ! 491: ! 492: if (getment(ip->i_dev, 0) == NULL) ! 493: return; ! 494: ! 495: ino = ip->i_ino; ! 496: if (ip->i_refc==0 && ip->i_nlink==0 && ino!=BADFIN && ino!=ROOTIN) { ! 497: iclear(ip); ! 498: ip->i_lrt = 0; ! 499: ip->i_mode = 0; ! 500: ifree(ip->i_dev, ino); ! 501: } ! 502: ! 503: dip = &dinode; ! 504: dip->di_mode = ip->i_mode; ! 505: canshort(dip->di_mode); ! 506: dip->di_nlink = ip->i_nlink; ! 507: canshort(dip->di_nlink); ! 508: dip->di_uid = ip->i_uid; ! 509: canshort(dip->di_uid); ! 510: dip->di_gid = ip->i_gid; ! 511: canshort(dip->di_gid); ! 512: dip->di_size = ip->i_size; ! 513: cansize(dip->di_size); ! 514: ! 515: switch (ip->i_mode&IFMT) { ! 516: case IFBLK: ! 517: case IFCHR: ! 518: dip->di_a.di_rdev = ip->i_a.i_rdev; ! 519: candev(dip->di_a.di_rdev); ! 520: break; ! 521: case IFREG: ! 522: case IFDIR: ! 523: ltol3(dip->di_addr, ip->i_a.i_addr, NADDR); ! 524: break; ! 525: case IFPIPE: ! 526: ltol3(dip->di_addp, ip->i_pipe, ND); ! 527: dip->di_pnc = ip->i_pnc; ! 528: canshort(dip->di_pnc); ! 529: dip->di_prx = ip->i_prx; ! 530: canshort(dip->di_prx); ! 531: dip->di_pwx = ip->i_pwx; ! 532: canshort(dip->di_pwx); ! 533: break; ! 534: default: ! 535: kclear(&dip->di_a, sizeof(dip->di_a)); ! 536: break; ! 537: } ! 538: ! 539: dip->di_atime = ip->i_atime; ! 540: cantime(dip->di_atime); ! 541: dip->di_mtime = ip->i_mtime; ! 542: cantime(dip->di_mtime); ! 543: dip->di_ctime = ip->i_ctime; ! 544: cantime(dip->di_ctime); ! 545: ! 546: if ((bp=bread(ip->i_dev, (daddr_t)iblockn(ino), 1)) == NULL) ! 547: return; ! 548: ! 549: v = (char *)((struct dinode *)FP_OFF(bp->b_faddr) + iblocko(ino)); ! 550: kkcopy(dip, v, sizeof(dinode)); ! 551: bp->b_flag |= BFMOD; ! 552: brelease(bp); ! 553: ip->i_flag &= ~(IFACC|IFMOD|IFCRT); ! 554: } ! 555: ! 556: /* ! 557: * Copy all relevant inodes out on device `dev'. ! 558: */ ! 559: isync(dev) ! 560: register dev_t dev; ! 561: { ! 562: register INODE *ip; ! 563: ! 564: for (ip=&inodep[NINODE-1]; ip>=inodep; --ip) { ! 565: if (ip->i_refc == 0) ! 566: continue; ! 567: if (ip->i_dev != dev) ! 568: continue; ! 569: if ( (ip->i_mode & IFMT) == IFCHR ) ! 570: continue; ! 571: if ((ip->i_flag&(IFACC|IFMOD|IFCRT)) == 0) ! 572: continue; ! 573: icopymd(ip); ! 574: } ! 575: } ! 576: ! 577: /* ! 578: * Clear the given inode and all space associated with it. ! 579: */ ! 580: iclear(ip) ! 581: register INODE *ip; ! 582: { ! 583: register int n; ! 584: register daddr_t b; ! 585: ! 586: switch (ip->i_mode&IFMT) { ! 587: case IFPIPE: ! 588: ip->i_pnc = 0; ! 589: ip->i_prx = 0; ! 590: ip->i_pwx = 0; ! 591: n = ND; ! 592: break; ! 593: case IFDIR: ! 594: case IFREG: ! 595: n = NADDR; ! 596: break; ! 597: default: ! 598: return; ! 599: } ! 600: while (n > ND) { ! 601: if ((b=ip->i_a.i_addr[--n]) != 0) ! 602: indfree(ip->i_dev, b, 1+n-ND); ! 603: } ! 604: while (n > 0) { ! 605: if ((b=ip->i_a.i_addr[--n]) != 0) ! 606: bfree(ip->i_dev, b); ! 607: } ! 608: ip->i_size = 0; ! 609: kclear(ip->i_a.i_addr, sizeof(ip->i_a.i_addr)); ! 610: iamc(ip); /* creat/pipe - atime/mtime/ctime */ ! 611: } ! 612: ! 613: /* ! 614: * Copy the appropriate information from the inode to the stat buffer. ! 615: */ ! 616: istat(ip, sbp) ! 617: register INODE *ip; ! 618: register struct stat *sbp; ! 619: { ! 620: sbp->st_dev = ip->i_dev; ! 621: sbp->st_ino = ip->i_ino; ! 622: sbp->st_mode = ip->i_mode; ! 623: sbp->st_nlink = ip->i_nlink; ! 624: sbp->st_uid = ip->i_uid; ! 625: sbp->st_gid = ip->i_gid; ! 626: sbp->st_rdev = NODEV; ! 627: sbp->st_size = ip->i_size; ! 628: sbp->st_atime = ip->i_atime; ! 629: sbp->st_mtime = ip->i_mtime; ! 630: sbp->st_ctime = ip->i_ctime; ! 631: switch (ip->i_mode&IFMT) { ! 632: case IFBLK: ! 633: case IFCHR: ! 634: sbp->st_rdev = ip->i_a.i_rdev; ! 635: sbp->st_size = 0; ! 636: break; ! 637: case IFPIPE: ! 638: sbp->st_size = ip->i_pnc; ! 639: break; ! 640: } ! 641: } ! 642: ! 643: /* ! 644: * See if it is possible to access the given inode with the bits in ! 645: * the given mode. ! 646: * If the mode includes writing, and i_refc is > 1, then check for ! 647: * shared text problems. ! 648: */ ! 649: iaccess(ip, mode) ! 650: register INODE *ip; ! 651: register int mode; ! 652: { ! 653: if ((imode(ip, u.u_uid, u.u_gid)&mode) != mode) { ! 654: u.u_error = EACCES; ! 655: return (0); ! 656: } ! 657: if ((mode&IPW) != 0 && ip->i_refc > 1 && sbusy(ip)) { ! 658: u.u_error = ETXTBSY; ! 659: return (0); ! 660: } ! 661: return (1); ! 662: } ! 663: ! 664: /* ! 665: * Get the maximum allowable mode on a file. ! 666: */ ! 667: imode(ip, uid, gid) ! 668: register INODE *ip; ! 669: { ! 670: if (uid == 0) ! 671: return (IPR|IPW|IPE); ! 672: if (uid == ip->i_uid) ! 673: return ((ip->i_mode>>6)&07); ! 674: if (gid == ip->i_gid) ! 675: return ((ip->i_mode>>3)&07); ! 676: return (ip->i_mode&07); ! 677: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.