![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to namei.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / fs / minix|
Return to namei.c CVS log | Up to [Early Linux] / linux / fs / minix |
1.1 ! root 1: /* ! 2: * linux/fs/minix/namei.c ! 3: * ! 4: * (C) 1991 Linus Torvalds ! 5: */ ! 6: ! 7: #include <linux/sched.h> ! 8: #include <linux/minix_fs.h> ! 9: #include <linux/kernel.h> ! 10: #include <asm/segment.h> ! 11: ! 12: #include <string.h> ! 13: #include <fcntl.h> ! 14: #include <errno.h> ! 15: #include <const.h> ! 16: #include <sys/stat.h> ! 17: ! 18: extern int permission(struct inode * inode,int mask); ! 19: extern struct inode * _namei(const char * filename, struct inode * base, ! 20: int follow_links); ! 21: ! 22: /* ! 23: * comment out this line if you want names > MINIX_NAME_LEN chars to be ! 24: * truncated. Else they will be disallowed. ! 25: */ ! 26: /* #define NO_TRUNCATE */ ! 27: ! 28: /* ! 29: * ok, we cannot use strncmp, as the name is not in our data space. ! 30: * Thus we'll have to use minix_match. No big problem. Match also makes ! 31: * some sanity tests. ! 32: * ! 33: * NOTE! unlike strncmp, minix_match returns 1 for success, 0 for failure. ! 34: */ ! 35: static int minix_match(int len,const char * name,struct minix_dir_entry * de) ! 36: { ! 37: register int same __asm__("ax"); ! 38: ! 39: if (!de || !de->inode || len > MINIX_NAME_LEN) ! 40: return 0; ! 41: /* "" means "." ---> so paths like "/usr/lib//libc.a" work */ ! 42: if (!len && (de->name[0]=='.') && (de->name[1]=='\0')) ! 43: return 1; ! 44: if (len < MINIX_NAME_LEN && de->name[len]) ! 45: return 0; ! 46: __asm__("cld\n\t" ! 47: "fs ; repe ; cmpsb\n\t" ! 48: "setz %%al" ! 49: :"=a" (same) ! 50: :"0" (0),"S" ((long) name),"D" ((long) de->name),"c" (len) ! 51: :"cx","di","si"); ! 52: return same; ! 53: } ! 54: ! 55: /* ! 56: * minix_find_entry() ! 57: * ! 58: * finds an entry in the specified directory with the wanted name. It ! 59: * returns the cache buffer in which the entry was found, and the entry ! 60: * itself (as a parameter - res_dir). It does NOT read the inode of the ! 61: * entry - you'll have to do that yourself if you want to. ! 62: */ ! 63: static struct buffer_head * minix_find_entry(struct inode * dir, ! 64: const char * name, int namelen, struct minix_dir_entry ** res_dir) ! 65: { ! 66: int entries; ! 67: int block,i; ! 68: struct buffer_head * bh; ! 69: struct minix_dir_entry * de; ! 70: ! 71: *res_dir = NULL; ! 72: if (!dir) ! 73: return NULL; ! 74: #ifdef NO_TRUNCATE ! 75: if (namelen > MINIX_NAME_LEN) ! 76: return NULL; ! 77: #else ! 78: if (namelen > MINIX_NAME_LEN) ! 79: namelen = MINIX_NAME_LEN; ! 80: #endif ! 81: entries = dir->i_size / (sizeof (struct minix_dir_entry)); ! 82: if (!(block = dir->i_data[0])) ! 83: return NULL; ! 84: if (!(bh = bread(dir->i_dev,block))) ! 85: return NULL; ! 86: i = 0; ! 87: de = (struct minix_dir_entry *) bh->b_data; ! 88: while (i < entries) { ! 89: if ((char *)de >= BLOCK_SIZE+bh->b_data) { ! 90: brelse(bh); ! 91: bh = NULL; ! 92: if (!(block = bmap(dir,i/MINIX_DIR_ENTRIES_PER_BLOCK)) || ! 93: !(bh = bread(dir->i_dev,block))) { ! 94: i += MINIX_DIR_ENTRIES_PER_BLOCK; ! 95: continue; ! 96: } ! 97: de = (struct minix_dir_entry *) bh->b_data; ! 98: } ! 99: if (minix_match(namelen,name,de)) { ! 100: *res_dir = de; ! 101: return bh; ! 102: } ! 103: de++; ! 104: i++; ! 105: } ! 106: brelse(bh); ! 107: return NULL; ! 108: } ! 109: ! 110: struct inode * minix_follow_link(struct inode * dir, struct inode * inode) ! 111: { ! 112: unsigned short fs; ! 113: struct buffer_head * bh; ! 114: ! 115: if (!dir) { ! 116: dir = current->root; ! 117: dir->i_count++; ! 118: } ! 119: if (!inode) { ! 120: iput(dir); ! 121: return NULL; ! 122: } ! 123: if (!S_ISLNK(inode->i_mode)) { ! 124: iput(dir); ! 125: return inode; ! 126: } ! 127: __asm__("mov %%fs,%0":"=r" (fs)); ! 128: if ((current->link_count > 5) || !inode->i_data[0] || ! 129: !(bh = bread(inode->i_dev, inode->i_data[0]))) { ! 130: iput(dir); ! 131: iput(inode); ! 132: return NULL; ! 133: } ! 134: iput(inode); ! 135: __asm__("mov %0,%%fs"::"r" ((unsigned short) 0x10)); ! 136: current->link_count++; ! 137: inode = _namei(bh->b_data,dir,1); ! 138: current->link_count--; ! 139: __asm__("mov %0,%%fs"::"r" (fs)); ! 140: brelse(bh); ! 141: return inode; ! 142: } ! 143: ! 144: int minix_lookup(struct inode * dir,const char * name, int len, ! 145: struct inode ** result) ! 146: { ! 147: int ino; ! 148: struct minix_dir_entry * de; ! 149: struct buffer_head * bh; ! 150: ! 151: *result = NULL; ! 152: if (!dir) ! 153: return -ENOENT; ! 154: if (!S_ISDIR(dir->i_mode)) { ! 155: iput(dir); ! 156: return -ENOENT; ! 157: } ! 158: if (!(bh = minix_find_entry(dir,name,len,&de))) { ! 159: iput(dir); ! 160: return -ENOENT; ! 161: } ! 162: ino = de->inode; ! 163: brelse(bh); ! 164: if (!(*result = iget(dir->i_dev,ino))) { ! 165: iput(dir); ! 166: return -EACCES; ! 167: } ! 168: iput(dir); ! 169: return 0; ! 170: } ! 171: ! 172: /* ! 173: * minix_add_entry() ! 174: * ! 175: * adds a file entry to the specified directory, using the same ! 176: * semantics as minix_find_entry(). It returns NULL if it failed. ! 177: * ! 178: * NOTE!! The inode part of 'de' is left at 0 - which means you ! 179: * may not sleep between calling this and putting something into ! 180: * the entry, as someone else might have used it while you slept. ! 181: */ ! 182: static struct buffer_head * minix_add_entry(struct inode * dir, ! 183: const char * name, int namelen, struct minix_dir_entry ** res_dir) ! 184: { ! 185: int block,i; ! 186: struct buffer_head * bh; ! 187: struct minix_dir_entry * de; ! 188: ! 189: *res_dir = NULL; ! 190: if (!dir) ! 191: return NULL; ! 192: #ifdef NO_TRUNCATE ! 193: if (namelen > MINIX_NAME_LEN) ! 194: return NULL; ! 195: #else ! 196: if (namelen > MINIX_NAME_LEN) ! 197: namelen = MINIX_NAME_LEN; ! 198: #endif ! 199: if (!namelen) ! 200: return NULL; ! 201: if (!(block = dir->i_data[0])) ! 202: return NULL; ! 203: if (!(bh = bread(dir->i_dev,block))) ! 204: return NULL; ! 205: i = 0; ! 206: de = (struct minix_dir_entry *) bh->b_data; ! 207: while (1) { ! 208: if ((char *)de >= BLOCK_SIZE+bh->b_data) { ! 209: brelse(bh); ! 210: bh = NULL; ! 211: block = minix_create_block(dir,i/MINIX_DIR_ENTRIES_PER_BLOCK); ! 212: if (!block) ! 213: return NULL; ! 214: if (!(bh = bread(dir->i_dev,block))) { ! 215: i += MINIX_DIR_ENTRIES_PER_BLOCK; ! 216: continue; ! 217: } ! 218: de = (struct minix_dir_entry *) bh->b_data; ! 219: } ! 220: if (i*sizeof(struct minix_dir_entry) >= dir->i_size) { ! 221: de->inode=0; ! 222: dir->i_size = (i+1)*sizeof(struct minix_dir_entry); ! 223: dir->i_dirt = 1; ! 224: dir->i_ctime = CURRENT_TIME; ! 225: } ! 226: if (!de->inode) { ! 227: dir->i_mtime = CURRENT_TIME; ! 228: for (i=0; i < MINIX_NAME_LEN ; i++) ! 229: de->name[i]=(i<namelen)?get_fs_byte(name+i):0; ! 230: bh->b_dirt = 1; ! 231: *res_dir = de; ! 232: return bh; ! 233: } ! 234: de++; ! 235: i++; ! 236: } ! 237: brelse(bh); ! 238: return NULL; ! 239: } ! 240: ! 241: int minix_create(struct inode * dir,const char * name, int len, int mode, ! 242: struct inode ** result) ! 243: { ! 244: struct inode * inode; ! 245: struct buffer_head * bh; ! 246: struct minix_dir_entry * de; ! 247: ! 248: *result = NULL; ! 249: if (!dir) ! 250: return -ENOENT; ! 251: inode = minix_new_inode(dir->i_dev); ! 252: if (!inode) { ! 253: iput(dir); ! 254: return -ENOSPC; ! 255: } ! 256: inode->i_mode = mode; ! 257: inode->i_dirt = 1; ! 258: bh = minix_add_entry(dir,name,len,&de); ! 259: if (!bh) { ! 260: inode->i_nlink--; ! 261: iput(inode); ! 262: iput(dir); ! 263: return -ENOSPC; ! 264: } ! 265: de->inode = inode->i_ino; ! 266: bh->b_dirt = 1; ! 267: brelse(bh); ! 268: iput(dir); ! 269: *result = inode; ! 270: return 0; ! 271: } ! 272: ! 273: int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev) ! 274: { ! 275: struct inode * inode; ! 276: struct buffer_head * bh; ! 277: struct minix_dir_entry * de; ! 278: ! 279: if (!dir) ! 280: return -ENOENT; ! 281: bh = minix_find_entry(dir,name,len,&de); ! 282: if (bh) { ! 283: brelse(bh); ! 284: iput(dir); ! 285: return -EEXIST; ! 286: } ! 287: inode = minix_new_inode(dir->i_dev); ! 288: if (!inode) { ! 289: iput(dir); ! 290: return -ENOSPC; ! 291: } ! 292: inode->i_uid = current->euid; ! 293: inode->i_mode = mode; ! 294: if (S_ISBLK(mode) || S_ISCHR(mode)) ! 295: inode->i_rdev = rdev; ! 296: inode->i_mtime = inode->i_atime = CURRENT_TIME; ! 297: inode->i_dirt = 1; ! 298: bh = minix_add_entry(dir,name,len,&de); ! 299: if (!bh) { ! 300: inode->i_nlink--; ! 301: iput(inode); ! 302: iput(dir); ! 303: return -ENOSPC; ! 304: } ! 305: de->inode = inode->i_ino; ! 306: bh->b_dirt = 1; ! 307: brelse(bh); ! 308: iput(dir); ! 309: iput(inode); ! 310: return 0; ! 311: } ! 312: ! 313: int minix_mkdir(struct inode * dir, const char * name, int len, int mode) ! 314: { ! 315: struct inode * inode; ! 316: struct buffer_head * bh, *dir_block; ! 317: struct minix_dir_entry * de; ! 318: ! 319: bh = minix_find_entry(dir,name,len,&de); ! 320: if (bh) { ! 321: brelse(bh); ! 322: iput(dir); ! 323: return -EEXIST; ! 324: } ! 325: inode = minix_new_inode(dir->i_dev); ! 326: if (!inode) { ! 327: iput(dir); ! 328: return -ENOSPC; ! 329: } ! 330: inode->i_size = 32; ! 331: inode->i_dirt = 1; ! 332: inode->i_mtime = inode->i_atime = CURRENT_TIME; ! 333: if (!(inode->i_data[0] = minix_new_block(inode->i_dev))) { ! 334: iput(dir); ! 335: inode->i_nlink--; ! 336: iput(inode); ! 337: return -ENOSPC; ! 338: } ! 339: inode->i_dirt = 1; ! 340: if (!(dir_block = bread(inode->i_dev,inode->i_data[0]))) { ! 341: iput(dir); ! 342: inode->i_nlink--; ! 343: iput(inode); ! 344: return -ERROR; ! 345: } ! 346: de = (struct minix_dir_entry *) dir_block->b_data; ! 347: de->inode=inode->i_ino; ! 348: strcpy(de->name,"."); ! 349: de++; ! 350: de->inode = dir->i_ino; ! 351: strcpy(de->name,".."); ! 352: inode->i_nlink = 2; ! 353: dir_block->b_dirt = 1; ! 354: brelse(dir_block); ! 355: inode->i_mode = I_DIRECTORY | (mode & 0777 & ~current->umask); ! 356: inode->i_dirt = 1; ! 357: bh = minix_add_entry(dir,name,len,&de); ! 358: if (!bh) { ! 359: iput(dir); ! 360: inode->i_nlink=0; ! 361: iput(inode); ! 362: return -ENOSPC; ! 363: } ! 364: de->inode = inode->i_ino; ! 365: bh->b_dirt = 1; ! 366: dir->i_nlink++; ! 367: dir->i_dirt = 1; ! 368: iput(dir); ! 369: iput(inode); ! 370: brelse(bh); ! 371: return 0; ! 372: } ! 373: ! 374: /* ! 375: * routine to check that the specified directory is empty (for rmdir) ! 376: */ ! 377: static int empty_dir(struct inode * inode) ! 378: { ! 379: int nr,block; ! 380: int len; ! 381: struct buffer_head * bh; ! 382: struct minix_dir_entry * de; ! 383: ! 384: len = inode->i_size / sizeof (struct minix_dir_entry); ! 385: if (len<2 || !inode->i_data[0] || ! 386: !(bh=bread(inode->i_dev,inode->i_data[0]))) { ! 387: printk("warning - bad directory on dev %04x\n",inode->i_dev); ! 388: return 0; ! 389: } ! 390: de = (struct minix_dir_entry *) bh->b_data; ! 391: if (de[0].inode != inode->i_ino || !de[1].inode || ! 392: strcmp(".",de[0].name) || strcmp("..",de[1].name)) { ! 393: printk("warning - bad directory on dev %04x\n",inode->i_dev); ! 394: return 0; ! 395: } ! 396: nr = 2; ! 397: de += 2; ! 398: while (nr<len) { ! 399: if ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) { ! 400: brelse(bh); ! 401: block=bmap(inode,nr/MINIX_DIR_ENTRIES_PER_BLOCK); ! 402: if (!block) { ! 403: nr += MINIX_DIR_ENTRIES_PER_BLOCK; ! 404: continue; ! 405: } ! 406: if (!(bh=bread(inode->i_dev,block))) ! 407: return 0; ! 408: de = (struct minix_dir_entry *) bh->b_data; ! 409: } ! 410: if (de->inode) { ! 411: brelse(bh); ! 412: return 0; ! 413: } ! 414: de++; ! 415: nr++; ! 416: } ! 417: brelse(bh); ! 418: return 1; ! 419: } ! 420: ! 421: int minix_rmdir(struct inode * dir, const char * name, int len) ! 422: { ! 423: int retval; ! 424: struct inode * inode; ! 425: struct buffer_head * bh; ! 426: struct minix_dir_entry * de; ! 427: ! 428: inode = NULL; ! 429: bh = minix_find_entry(dir,name,len,&de); ! 430: retval = -ENOENT; ! 431: if (!bh) ! 432: goto end_rmdir; ! 433: retval = -EPERM; ! 434: if (!(inode = iget(dir->i_dev, de->inode))) ! 435: goto end_rmdir; ! 436: if ((dir->i_mode & S_ISVTX) && current->euid && ! 437: inode->i_uid != current->euid) ! 438: goto end_rmdir; ! 439: if (inode->i_dev != dir->i_dev) ! 440: goto end_rmdir; ! 441: if (inode == dir) /* we may not delete ".", but "../dir" is ok */ ! 442: goto end_rmdir; ! 443: if (!S_ISDIR(inode->i_mode)) { ! 444: retval = -ENOTDIR; ! 445: goto end_rmdir; ! 446: } ! 447: if (!empty_dir(inode)) { ! 448: retval = -ENOTEMPTY; ! 449: goto end_rmdir; ! 450: } ! 451: if (inode->i_count > 1) { ! 452: retval = -EBUSY; ! 453: goto end_rmdir; ! 454: } ! 455: if (inode->i_nlink != 2) ! 456: printk("empty directory has nlink!=2 (%d)\n",inode->i_nlink); ! 457: de->inode = 0; ! 458: bh->b_dirt = 1; ! 459: inode->i_nlink=0; ! 460: inode->i_dirt=1; ! 461: dir->i_nlink--; ! 462: dir->i_ctime = dir->i_mtime = CURRENT_TIME; ! 463: dir->i_dirt=1; ! 464: retval = 0; ! 465: end_rmdir: ! 466: iput(dir); ! 467: iput(inode); ! 468: brelse(bh); ! 469: return retval; ! 470: } ! 471: ! 472: int minix_unlink(struct inode * dir, const char * name, int len) ! 473: { ! 474: int retval; ! 475: struct inode * inode; ! 476: struct buffer_head * bh; ! 477: struct minix_dir_entry * de; ! 478: ! 479: retval = -ENOENT; ! 480: inode = NULL; ! 481: bh = minix_find_entry(dir,name,len,&de); ! 482: if (!bh) ! 483: goto end_unlink; ! 484: if (!(inode = iget(dir->i_dev, de->inode))) ! 485: goto end_unlink; ! 486: retval = -EPERM; ! 487: if ((dir->i_mode & S_ISVTX) && !suser() && ! 488: current->euid != inode->i_uid && ! 489: current->euid != dir->i_uid) ! 490: goto end_unlink; ! 491: if (S_ISDIR(inode->i_mode)) ! 492: goto end_unlink; ! 493: if (!inode->i_nlink) { ! 494: printk("Deleting nonexistent file (%04x:%d), %d\n", ! 495: inode->i_dev,inode->i_ino,inode->i_nlink); ! 496: inode->i_nlink=1; ! 497: } ! 498: de->inode = 0; ! 499: bh->b_dirt = 1; ! 500: inode->i_nlink--; ! 501: inode->i_dirt = 1; ! 502: inode->i_ctime = CURRENT_TIME; ! 503: retval = 0; ! 504: end_unlink: ! 505: brelse(bh); ! 506: iput(inode); ! 507: iput(dir); ! 508: return retval; ! 509: } ! 510: ! 511: int minix_symlink(struct inode * dir, const char * name, int len, const char * symname) ! 512: { ! 513: struct minix_dir_entry * de; ! 514: struct inode * inode = NULL; ! 515: struct buffer_head * bh = NULL, * name_block = NULL; ! 516: int i; ! 517: char c; ! 518: ! 519: if (!(inode = minix_new_inode(dir->i_dev))) { ! 520: iput(dir); ! 521: return -ENOSPC; ! 522: } ! 523: inode->i_mode = S_IFLNK | 0777; ! 524: inode->i_dirt = 1; ! 525: if (!(inode->i_data[0] = minix_new_block(inode->i_dev))) { ! 526: iput(dir); ! 527: inode->i_nlink--; ! 528: iput(inode); ! 529: return -ENOSPC; ! 530: } ! 531: inode->i_dirt = 1; ! 532: if (!(name_block = bread(inode->i_dev,inode->i_data[0]))) { ! 533: iput(dir); ! 534: inode->i_nlink--; ! 535: iput(inode); ! 536: return -ERROR; ! 537: } ! 538: i = 0; ! 539: while (i < 1023 && (c=get_fs_byte(symname++))) ! 540: name_block->b_data[i++] = c; ! 541: name_block->b_data[i] = 0; ! 542: name_block->b_dirt = 1; ! 543: brelse(name_block); ! 544: inode->i_size = i; ! 545: inode->i_dirt = 1; ! 546: bh = minix_find_entry(dir,name,len,&de); ! 547: if (bh) { ! 548: inode->i_nlink--; ! 549: iput(inode); ! 550: brelse(bh); ! 551: iput(dir); ! 552: return -EEXIST; ! 553: } ! 554: bh = minix_add_entry(dir,name,len,&de); ! 555: if (!bh) { ! 556: inode->i_nlink--; ! 557: iput(inode); ! 558: iput(dir); ! 559: return -ENOSPC; ! 560: } ! 561: de->inode = inode->i_ino; ! 562: bh->b_dirt = 1; ! 563: brelse(bh); ! 564: iput(dir); ! 565: iput(inode); ! 566: return 0; ! 567: } ! 568: ! 569: int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len) ! 570: { ! 571: struct minix_dir_entry * de; ! 572: struct buffer_head * bh; ! 573: ! 574: if (S_ISDIR(oldinode->i_mode)) { ! 575: iput(oldinode); ! 576: iput(dir); ! 577: return -EPERM; ! 578: } ! 579: bh = minix_find_entry(dir,name,len,&de); ! 580: if (bh) { ! 581: brelse(bh); ! 582: iput(dir); ! 583: iput(oldinode); ! 584: return -EEXIST; ! 585: } ! 586: bh = minix_add_entry(dir,name,len,&de); ! 587: if (!bh) { ! 588: iput(dir); ! 589: iput(oldinode); ! 590: return -ENOSPC; ! 591: } ! 592: de->inode = oldinode->i_ino; ! 593: bh->b_dirt = 1; ! 594: brelse(bh); ! 595: iput(dir); ! 596: oldinode->i_nlink++; ! 597: oldinode->i_ctime = CURRENT_TIME; ! 598: oldinode->i_dirt = 1; ! 599: iput(oldinode); ! 600: return 0; ! 601: } ! 602: ! 603: static int subdir(struct inode * new, struct inode * old) ! 604: { ! 605: unsigned short fs; ! 606: int ino; ! 607: int result; ! 608: ! 609: __asm__("mov %%fs,%0":"=r" (fs)); ! 610: __asm__("mov %0,%%fs"::"r" ((unsigned short) 0x10)); ! 611: new->i_count++; ! 612: result = 0; ! 613: for (;;) { ! 614: if (new == old) { ! 615: result = 1; ! 616: break; ! 617: } ! 618: if (new->i_dev != old->i_dev) ! 619: break; ! 620: ino = new->i_ino; ! 621: if (minix_lookup(new,"..",2,&new)) ! 622: break; ! 623: if (new->i_ino == ino) ! 624: break; ! 625: } ! 626: iput(new); ! 627: __asm__("mov %0,%%fs"::"r" (fs)); ! 628: return result; ! 629: } ! 630: ! 631: #define PARENT_INO(buffer) \ ! 632: (((struct minix_dir_entry *) (buffer))[1].inode) ! 633: ! 634: #define PARENT_NAME(buffer) \ ! 635: (((struct minix_dir_entry *) (buffer))[1].name) ! 636: ! 637: /* ! 638: * rename uses retrying to avoid race-conditions: at least they should be minimal. ! 639: * it tries to allocate all the blocks, then sanity-checks, and if the sanity- ! 640: * checks fail, it tries to restart itself again. Very practical - no changes ! 641: * are done until we know everything works ok.. and then all the changes can be ! 642: * done in one fell swoop when we have claimed all the buffers needed. ! 643: * ! 644: * Anybody can rename anything with this: the permission checks are left to the ! 645: * higher-level routines. ! 646: */ ! 647: static int do_minix_rename(struct inode * old_dir, const char * old_name, int old_len, ! 648: struct inode * new_dir, const char * new_name, int new_len) ! 649: { ! 650: struct inode * old_inode, * new_inode; ! 651: struct buffer_head * old_bh, * new_bh, * dir_bh; ! 652: struct minix_dir_entry * old_de, * new_de; ! 653: int retval; ! 654: ! 655: goto start_up; ! 656: try_again: ! 657: brelse(old_bh); ! 658: brelse(new_bh); ! 659: brelse(dir_bh); ! 660: iput(old_inode); ! 661: iput(new_inode); ! 662: current->counter = 0; ! 663: schedule(); ! 664: start_up: ! 665: old_inode = new_inode = NULL; ! 666: old_bh = new_bh = dir_bh = NULL; ! 667: old_bh = minix_find_entry(old_dir,old_name,old_len,&old_de); ! 668: retval = -ENOENT; ! 669: if (!old_bh) ! 670: goto end_rename; ! 671: old_inode = iget(old_dir->i_dev, old_de->inode); ! 672: if (!old_inode) ! 673: goto end_rename; ! 674: new_bh = minix_find_entry(new_dir,new_name,new_len,&new_de); ! 675: if (new_bh) { ! 676: new_inode = iget(new_dir->i_dev, new_de->inode); ! 677: if (!new_inode) { ! 678: brelse(new_bh); ! 679: new_bh = NULL; ! 680: } ! 681: } ! 682: if (new_inode == old_inode) { ! 683: retval = 0; ! 684: goto end_rename; ! 685: } ! 686: if (S_ISDIR(old_inode->i_mode)) { ! 687: retval = -EEXIST; ! 688: if (new_bh) ! 689: goto end_rename; ! 690: retval = -EACCES; ! 691: if (!permission(old_inode, MAY_WRITE)) ! 692: goto end_rename; ! 693: retval = -EINVAL; ! 694: if (subdir(new_dir, old_inode)) ! 695: goto end_rename; ! 696: retval = -EIO; ! 697: if (!old_inode->i_data[0]) ! 698: goto end_rename; ! 699: if (!(dir_bh = bread(old_inode->i_dev, old_inode->i_data[0]))) ! 700: goto end_rename; ! 701: if (PARENT_INO(dir_bh->b_data) != old_dir->i_ino) ! 702: goto end_rename; ! 703: } ! 704: if (!new_bh) ! 705: new_bh = minix_add_entry(new_dir,new_name,new_len,&new_de); ! 706: retval = -ENOSPC; ! 707: if (!new_bh) ! 708: goto end_rename; ! 709: /* sanity checking before doing the rename - avoid races */ ! 710: if (new_inode && (new_de->inode != new_inode->i_ino)) ! 711: goto try_again; ! 712: if (new_de->inode && !new_inode) ! 713: goto try_again; ! 714: if (old_de->inode != old_inode->i_ino) ! 715: goto try_again; ! 716: /* ok, that's it */ ! 717: old_de->inode = 0; ! 718: new_de->inode = old_inode->i_ino; ! 719: if (new_inode) ! 720: new_inode->i_nlink--; ! 721: old_bh->b_dirt = 1; ! 722: new_bh->b_dirt = 1; ! 723: if (dir_bh) { ! 724: PARENT_INO(dir_bh->b_data) = new_dir->i_ino; ! 725: dir_bh->b_dirt = 1; ! 726: old_dir->i_nlink--; ! 727: new_dir->i_nlink++; ! 728: old_dir->i_dirt = 1; ! 729: new_dir->i_dirt = 1; ! 730: } ! 731: retval = 0; ! 732: end_rename: ! 733: brelse(dir_bh); ! 734: brelse(old_bh); ! 735: brelse(new_bh); ! 736: iput(old_inode); ! 737: iput(new_inode); ! 738: iput(old_dir); ! 739: iput(new_dir); ! 740: return retval; ! 741: } ! 742: ! 743: /* ! 744: * Ok, rename also locks out other renames, as they can change the parent of ! 745: * a directory, and we don't want any races. Other races are checked for by ! 746: * "do_rename()", which restarts if there are inconsistencies. ! 747: * ! 748: * Note that there is no race between different filesystems: it's only within ! 749: * the same device that races occur: many renames can happen at once, as long ! 750: * as they are on different partitions. ! 751: */ ! 752: int minix_rename(struct inode * old_dir, const char * old_name, int old_len, ! 753: struct inode * new_dir, const char * new_name, int new_len) ! 754: { ! 755: static struct task_struct * wait = NULL; ! 756: static int lock = 0; ! 757: int result; ! 758: ! 759: while (lock) ! 760: sleep_on(&wait); ! 761: lock = 1; ! 762: result = do_minix_rename(old_dir, old_name, old_len, ! 763: new_dir, new_name, new_len); ! 764: lock = 0; ! 765: wake_up(&wait); ! 766: return result; ! 767: } ! 768: ! 769: int minix_readlink(struct inode * inode, char * buffer, int buflen) ! 770: { ! 771: struct buffer_head * bh; ! 772: int i; ! 773: char c; ! 774: ! 775: if (!S_ISLNK(inode->i_mode)) { ! 776: iput(inode); ! 777: return -EINVAL; ! 778: } ! 779: if (buflen > 1023) ! 780: buflen = 1023; ! 781: if (inode->i_data[0]) ! 782: bh = bread(inode->i_dev, inode->i_data[0]); ! 783: else ! 784: bh = NULL; ! 785: iput(inode); ! 786: if (!bh) ! 787: return 0; ! 788: i = 0; ! 789: while (i<buflen && (c = bh->b_data[i])) { ! 790: i++; ! 791: put_fs_byte(c,buffer++); ! 792: } ! 793: brelse(bh); ! 794: return i; ! 795: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.