fs/sysv/namei.c

   1 /*
   2  *  linux/fs/sysv/namei.c
   3  *
   4  *  minix/namei.c
   5  *  Copyright (C) 1991, 1992  Linus Torvalds
   6  *
   7  *  coh/namei.c
   8  *  Copyright (C) 1993  Pascal Haible, Bruno Haible
   9  *
  10  *  sysv/namei.c
  11  *  Copyright (C) 1993  Bruno Haible
  12  *  Copyright (C) 1997, 1998  Krzysztof G. Baranowski
  13  */
  14
  15
  16 #include <linux/sched.h>
  17 #include <linux/kernel.h>
  18 #include <linux/fs.h>
  19 #include <linux/sysv_fs.h>
  20 #include <linux/string.h>
  21 #include <linux/stat.h>
  22 #include <linux/errno.h>
  23
  24 /* compare strings: name[0..len-1] (not zero-terminated) and
  25  * buffer[0..] (filled with zeroes up to buffer[0..maxlen-1])
  26  */
  27 static inline int namecompare(int len, int maxlen,
  28         const char * name, const char * buffer)
  29 {
  30         if (len > maxlen)
  31                 return 0;
  32         if (len < maxlen && buffer[len])
  33                 return 0;
  34         return !memcmp(name, buffer, len);
  35 }
  36
  37 /*
  38  * ok, we cannot use strncmp, as the name is not in our data space. [Now it is!]
  39  * Thus we'll have to use sysv_match. No big problem. Match also makes
  40  * some sanity tests.
  41  *
  42  * NOTE! unlike strncmp, sysv_match returns 1 for success, 0 for failure.
  43  */
  44 static int sysv_match(int len, const char * name, struct sysv_dir_entry * de)
  45 {
  46         if (!de->inode || len > SYSV_NAMELEN)
  47                 return 0;
  48         /* "" means "." ---> so paths like "/usr/lib//libc.a" work */
  49         if (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
  50                 return 1;
  51         return namecompare(len, SYSV_NAMELEN, name, de->name);
  52 }
  53
  54 /*
  55  *      sysv_find_entry()
  56  *
  57  * finds an entry in the specified directory with the wanted name. It
  58  * returns the cache buffer in which the entry was found, and the entry
  59  * itself (as a parameter - res_dir). It does NOT read the inode of the
  60  * entry - you'll have to do that yourself if you want to.
  61  */
  62 static struct buffer_head * sysv_find_entry(struct inode * dir,
  63         const char * name, int namelen, struct sysv_dir_entry ** res_dir)
  64 {
  65         struct super_block * sb;
  66         unsigned long pos, block, offset; /* pos = block * block_size + offset */
  67         struct buffer_head * bh;
  68
  69         *res_dir = NULL;
  70         if (!dir)
  71                 return NULL;
  72         sb = dir->i_sb;
  73         if (namelen > SYSV_NAMELEN) {
  74                 if (sb->sv_truncate)
  75                         namelen = SYSV_NAMELEN;
  76                 else
  77                         return NULL;
  78         }
  79         bh = NULL;
  80         pos = block = offset = 0;
  81         while (pos < dir->i_size) {
  82                 if (!bh) {
  83                         bh = sysv_file_bread(dir, block, 0);
  84                         if (!bh) {
  85                                 /* offset = 0; */ block++;
  86                                 pos += sb->sv_block_size;
  87                                 continue;
  88                         }
  89                 }
  90                 if (sysv_match(namelen, name,
  91                                *res_dir = (struct sysv_dir_entry *) (bh->b_data + offset) ))
  92                         return bh;
  93                 pos += SYSV_DIRSIZE;
  94                 offset += SYSV_DIRSIZE;
  95                 if (offset < sb->sv_block_size)
  96                         continue;
  97                 brelse(bh);
  98                 bh = NULL;
  99                 offset = 0; block++;
 100         }
 101         brelse(bh);
 102         *res_dir = NULL;
 103         return NULL;
 104 }
 105
 106 struct dentry *sysv_lookup(struct inode * dir, struct dentry * dentry)
 107 {
 108         struct inode * inode = NULL;
 109         struct sysv_dir_entry * de;
 110         struct buffer_head * bh;
 111
 112         bh = sysv_find_entry(dir, dentry->d_name.name, dentry->d_name.len, &de);
 113
 114         if (bh) {
 115                 int ino = de->inode;
 116                 brelse(bh);
 117                 inode = iget(dir->i_sb, ino);
 118
 119                 if (!inode)
 120                         return ERR_PTR(-EACCES);
 121         }
 122         d_add(dentry, inode);
 123         return NULL;
 124 }
 125
 126 /*
 127  *      sysv_add_entry()
 128  *
 129  * adds a file entry to the specified directory, returning a possible
 130  * error value if it fails.
 131  *
 132  * NOTE!! The inode part of 'de' is left at 0 - which means you
 133  * may not sleep between calling this and putting something into
 134  * the entry, as someone else might have used it while you slept.
 135  */
 136 static int sysv_add_entry(struct inode * dir,
 137         const char * name, int namelen,
 138         struct buffer_head ** res_buf,
 139         struct sysv_dir_entry ** res_dir)
 140 {
 141         struct super_block * sb;
 142         int i;
 143         unsigned long pos, block, offset; /* pos = block * block_size + offset */
 144         struct buffer_head * bh;
 145         struct sysv_dir_entry * de;
 146
 147         *res_buf = NULL;
 148         *res_dir = NULL;
 149         if (!dir)
 150                 return -ENOENT;
 151         sb = dir->i_sb;
 152         if (namelen > SYSV_NAMELEN) {
 153                 if (sb->sv_truncate)
 154                         namelen = SYSV_NAMELEN;
 155                 else
 156                         return -ENAMETOOLONG;
 157         }
 158         if (!namelen)
 159                 return -ENOENT;
 160         bh = NULL;
 161         pos = block = offset = 0;
 162         while (1) {
 163                 if (!bh) {
 164                         bh = sysv_file_bread(dir, block, 1);
 165                         if (!bh)
 166                                 return -ENOSPC;
 167                 }
 168                 de = (struct sysv_dir_entry *) (bh->b_data + offset);
 169                 pos += SYSV_DIRSIZE;
 170                 offset += SYSV_DIRSIZE;
 171                 if (pos > dir->i_size) {
 172                         de->inode = 0;
 173                         dir->i_size = pos;
 174                         mark_inode_dirty(dir);
 175                 }
 176                 if (de->inode) {
 177                         if (namecompare(namelen, SYSV_NAMELEN, name, de->name)) {
 178                                 brelse(bh);
 179                                 return -EEXIST;
 180                         }
 181                 } else {
 182                         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
 183                         mark_inode_dirty(dir);
 184                         for (i = 0; i < SYSV_NAMELEN ; i++)
 185                                 de->name[i] = (i < namelen) ? name[i] : 0;
 186                         mark_buffer_dirty(bh, 1);
 187                         *res_dir = de;
 188                         break;
 189                 }
 190                 if (offset < sb->sv_block_size)
 191                         continue;
 192                 brelse(bh);
 193                 bh = NULL;
 194                 offset = 0; block++;
 195         }
 196         *res_buf = bh;
 197         return 0;
 198 }
 199
 200 int sysv_create(struct inode * dir, struct dentry * dentry, int mode)
 201 {
 202         int error;
 203         struct inode * inode;
 204         struct buffer_head * bh;
 205         struct sysv_dir_entry * de;
 206
 207         inode = sysv_new_inode(dir);
 208         if (!inode)
 209                 return -ENOSPC;
 210         inode->i_op = &sysv_file_inode_operations;
 211         inode->i_mode = mode;
 212         mark_inode_dirty(inode);
 213         error = sysv_add_entry(dir, dentry->d_name.name,
 214                                dentry->d_name.len, &bh, &de);
 215         if (error) {
 216                 inode->i_nlink--;
 217                 mark_inode_dirty(inode);
 218                 iput(inode);
 219                 return error;
 220         }
 221         de->inode = inode->i_ino;
 222         mark_buffer_dirty(bh, 1);
 223         brelse(bh);
 224         d_instantiate(dentry, inode);
 225         return 0;
 226 }
 227
 228 int sysv_mknod(struct inode * dir, struct dentry * dentry, int mode, int rdev)
 229 {
 230         int error;
 231         struct inode * inode;
 232         struct buffer_head * bh;
 233         struct sysv_dir_entry * de;
 234
 235         bh = sysv_find_entry(dir, dentry->d_name.name,
 236                              dentry->d_name.len, &de);
 237         if (bh) {
 238                 brelse(bh);
 239                 return -EEXIST;
 240         }
 241         inode = sysv_new_inode(dir);
 242         if (!inode)
 243                 return -ENOSPC;
 244         inode->i_uid = current->fsuid;
 245         inode->i_mode = mode;
 246         inode->i_op = NULL;
 247         if (S_ISREG(inode->i_mode))
 248                 inode->i_op = &sysv_file_inode_operations;
 249         else if (S_ISCHR(inode->i_mode))
 250                 inode->i_op = &chrdev_inode_operations;
 251         else if (S_ISBLK(inode->i_mode))
 252                 inode->i_op = &blkdev_inode_operations;
 253         else if (S_ISFIFO(inode->i_mode))
 254                 init_fifo(inode);
 255         if (S_ISBLK(mode) || S_ISCHR(mode))
 256                 inode->i_rdev = to_kdev_t(rdev);
 257         mark_inode_dirty(inode);
 258         error = sysv_add_entry(dir, dentry->d_name.name,
 259                                dentry->d_name.len, &bh, &de);
 260         if (error) {
 261                 inode->i_nlink--;
 262                 mark_inode_dirty(inode);
 263                 iput(inode);
 264                 return error;
 265         }
 266         de->inode = inode->i_ino;
 267         mark_buffer_dirty(bh, 1);
 268         brelse(bh);
 269         d_instantiate(dentry, inode);
 270         return 0;
 271 }
 272
 273 int sysv_mkdir(struct inode * dir, struct dentry *dentry, int mode)
 274 {
 275         int error;
 276         struct inode * inode;
 277         struct buffer_head * bh, *dir_block;
 278         struct sysv_dir_entry * de;
 279
 280         bh = sysv_find_entry(dir, dentry->d_name.name,
 281                               dentry->d_name.len, &de);
 282         if (bh) {
 283                 brelse(bh);
 284                 return -EEXIST;
 285         }
 286         if (dir->i_nlink >= dir->i_sb->sv_link_max)
 287                 return -EMLINK;
 288         inode = sysv_new_inode(dir);
 289         if (!inode)
 290                 return -ENOSPC;
 291         inode->i_op = &sysv_dir_inode_operations;
 292         inode->i_size = 2 * SYSV_DIRSIZE;
 293         dir_block = sysv_file_bread(inode,0,1);
 294         if (!dir_block) {
 295                 inode->i_nlink--;
 296                 mark_inode_dirty(inode);
 297                 iput(inode);
 298                 return -ENOSPC;
 299         }
 300         de = (struct sysv_dir_entry *) (dir_block->b_data + 0*SYSV_DIRSIZE);
 301         de->inode = inode->i_ino;
 302         strcpy(de->name,"."); /* rest of de->name is zero, see sysv_new_block */
 303         de = (struct sysv_dir_entry *) (dir_block->b_data + 1*SYSV_DIRSIZE);
 304         de->inode = dir->i_ino;
 305         strcpy(de->name,".."); /* rest of de->name is zero, see sysv_new_block */
 306         inode->i_nlink = 2;
 307         mark_buffer_dirty(dir_block, 1);
 308         brelse(dir_block);
 309         inode->i_mode = S_IFDIR | (mode & 0777 & ~current->fs->umask);
 310         if (dir->i_mode & S_ISGID)
 311                 inode->i_mode |= S_ISGID;
 312         mark_inode_dirty(inode);
 313         error = sysv_add_entry(dir, dentry->d_name.name,
 314                                dentry->d_name.len, &bh, &de);
 315         if (error) {
 316                 inode->i_nlink=0;
 317                 iput(inode);
 318                 return error;
 319         }
 320         de->inode = inode->i_ino;
 321         mark_buffer_dirty(bh, 1);
 322         dir->i_nlink++;
 323         mark_inode_dirty(dir);
 324         brelse(bh);
 325         d_instantiate(dentry, inode);
 326         return 0;
 327 }
 328
 329 /*
 330  * routine to check that the specified directory is empty (for rmdir)
 331  */
 332 static int empty_dir(struct inode * inode)
 333 {
 334         struct super_block * sb;
 335         unsigned long pos, block, offset; /* pos = block * block_size + offset */
 336         struct buffer_head * bh;
 337         struct sysv_dir_entry * de;
 338
 339         if (!inode)
 340                 return 1;
 341         block = 0;
 342         bh = NULL;
 343         pos = offset = 2*SYSV_DIRSIZE;
 344         if (inode->i_size % SYSV_DIRSIZE)
 345                 goto bad_dir;
 346         if (inode->i_size < pos)
 347                 goto bad_dir;
 348         bh = sysv_file_bread(inode, 0, 0);
 349         if (!bh)
 350                 goto bad_dir;
 351         de = (struct sysv_dir_entry *) (bh->b_data + 0*SYSV_DIRSIZE);
 352         if (!de->inode || strcmp(de->name,"."))
 353                 goto bad_dir;
 354         de = (struct sysv_dir_entry *) (bh->b_data + 1*SYSV_DIRSIZE);
 355         if (!de->inode || strcmp(de->name,".."))
 356                 goto bad_dir;
 357         sb = inode->i_sb;
 358         while (pos < inode->i_size) {
 359                 if (!bh) {
 360                         bh = sysv_file_bread(inode, block, 0);
 361                         if (!bh) {
 362                                 /* offset = 0; */ block++;
 363                                 pos += sb->sv_block_size;
 364                                 continue;
 365                         }
 366                 }
 367                 de = (struct sysv_dir_entry *) (bh->b_data + offset);
 368                 pos += SYSV_DIRSIZE;
 369                 offset += SYSV_DIRSIZE;
 370                 if (de->inode) {
 371                         brelse(bh);
 372                         return 0;
 373                 }
 374                 if (offset < sb->sv_block_size)
 375                         continue;
 376                 brelse(bh);
 377                 bh = NULL;
 378                 offset = 0; block++;
 379         }
 380         brelse(bh);
 381         return 1;
 382 bad_dir:
 383         brelse(bh);
 384         printk("Bad directory on device %s\n",
 385                kdevname(inode->i_dev));
 386         return 1;
 387 }
 388
 389 int sysv_rmdir(struct inode * dir, struct dentry * dentry)
 390 {
 391         int retval;
 392         struct inode * inode;
 393         struct buffer_head * bh;
 394         struct sysv_dir_entry * de;
 395
 396         inode = NULL;
 397         bh = sysv_find_entry(dir, dentry->d_name.name,
 398                              dentry->d_name.len, &de);
 399         retval = -ENOENT;
 400         if (!bh)
 401                 goto end_rmdir;
 402         inode = dentry->d_inode;
 403
 404         if (!empty_dir(inode)) {
 405                 retval = -ENOTEMPTY;
 406                 goto end_rmdir;
 407         }
 408         if (de->inode != inode->i_ino) {
 409                 retval = -ENOENT;
 410                 goto end_rmdir;
 411         }
 412         if (!list_empty(&dentry->d_hash)) {
 413                 retval = -EBUSY;
 414                 goto end_rmdir;
 415         }
 416         if (inode->i_nlink != 2)
 417                 printk("empty directory has nlink!=2 (%d)\n", inode->i_nlink);
 418         de->inode = 0;
 419         mark_buffer_dirty(bh, 1);
 420         inode->i_nlink=0;
 421         mark_inode_dirty(inode);
 422         dir->i_nlink--;
 423         inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 424         mark_inode_dirty(dir);
 425         d_delete(dentry);
 426         retval = 0;
 427 end_rmdir:
 428         brelse(bh);
 429         return retval;
 430 }
 431
 432 int sysv_unlink(struct inode * dir, struct dentry * dentry)
 433 {
 434         int retval;
 435         struct inode * inode;
 436         struct buffer_head * bh;
 437         struct sysv_dir_entry * de;
 438
 439 repeat:
 440         retval = -ENOENT;
 441         inode = NULL;
 442         bh = sysv_find_entry(dir, dentry->d_name.name,
 443                              dentry->d_name.len, &de);
 444         if (!bh)
 445                 goto end_unlink;
 446         inode = dentry->d_inode;
 447
 448         retval = -EPERM;
 449         if (de->inode != inode->i_ino) {
 450                 brelse(bh);
 451                 current->counter = 0;
 452                 schedule();
 453                 goto repeat;
 454         }
 455         if (de->inode != inode->i_ino) {
 456                 retval = -ENOENT;
 457                 goto end_unlink;
 458         }
 459         if (!inode->i_nlink) {
 460                 printk("Deleting nonexistent file (%s:%lu), %d\n",
 461                         kdevname(inode->i_dev), inode->i_ino, inode->i_nlink);
 462                 inode->i_nlink=1;
 463         }
 464         de->inode = 0;
 465         mark_buffer_dirty(bh, 1);
 466         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 467         mark_inode_dirty(dir);
 468         inode->i_nlink--;
 469         inode->i_ctime = dir->i_ctime;
 470         mark_inode_dirty(inode);
 471         d_delete(dentry);
 472         retval = 0;
 473 end_unlink:
 474         brelse(bh);
 475         return retval;
 476 }
 477
 478 int sysv_symlink(struct inode * dir, struct dentry * dentry,
 479                  const char * symname)
 480 {
 481         struct sysv_dir_entry * de;
 482         struct inode * inode;
 483         struct buffer_head * name_block;
 484         char * name_block_data;
 485         struct super_block * sb;
 486         int i;
 487         char c;
 488         struct buffer_head * bh;
 489
 490         if (!(inode = sysv_new_inode(dir)))
 491                 return -ENOSPC;
 492
 493         inode->i_mode = S_IFLNK | 0777;
 494         inode->i_op = &sysv_symlink_inode_operations;
 495         name_block = sysv_file_bread(inode, 0, 1);
 496         if (!name_block) {
 497                 inode->i_nlink--;
 498                 mark_inode_dirty(inode);
 499                 iput(inode);
 500                 return -ENOSPC;
 501         }
 502         sb = inode->i_sb;
 503         name_block_data = name_block->b_data;
 504         i = 0;
 505         while (i < sb->sv_block_size_1 && (c = *(symname++)))
 506                 name_block_data[i++] = c;
 507         name_block_data[i] = 0;
 508         mark_buffer_dirty(name_block, 1);
 509         brelse(name_block);
 510         inode->i_size = i;
 511         mark_inode_dirty(inode);
 512         bh = sysv_find_entry(dir, dentry->d_name.name,
 513                              dentry->d_name.len, &de);
 514         if (bh) {
 515                 inode->i_nlink--;
 516                 mark_inode_dirty(inode);
 517                 iput(inode);
 518                 brelse(bh);
 519                 return -EEXIST;
 520         }
 521         i = sysv_add_entry(dir, dentry->d_name.name,
 522                            dentry->d_name.len, &bh, &de);
 523         if (i) {
 524                 inode->i_nlink--;
 525                 mark_inode_dirty(inode);
 526                 iput(inode);
 527                 return i;
 528         }
 529         de->inode = inode->i_ino;
 530         mark_buffer_dirty(bh, 1);
 531         brelse(bh);
 532         d_instantiate(dentry, inode);
 533         return 0;
 534 }
 535
 536 int sysv_link(struct dentry * old_dentry, struct inode * dir,
 537               struct dentry * dentry)
 538 {
 539         struct inode *oldinode = old_dentry->d_inode;
 540         int error;
 541         struct sysv_dir_entry * de;
 542         struct buffer_head * bh;
 543
 544         if (S_ISDIR(oldinode->i_mode)) {
 545                 return -EPERM;
 546         }
 547         if (oldinode->i_nlink >= oldinode->i_sb->sv_link_max) {
 548                 return -EMLINK;
 549         }
 550         bh = sysv_find_entry(dir, dentry->d_name.name,
 551                              dentry->d_name.len, &de);
 552         if (bh) {
 553                 brelse(bh);
 554                 return -EEXIST;
 555         }
 556         error = sysv_add_entry(dir, dentry->d_name.name,
 557                                dentry->d_name.len, &bh, &de);
 558         if (error) {
 559                 brelse(bh);
 560                 return error;
 561         }
 562         de->inode = oldinode->i_ino;
 563         mark_buffer_dirty(bh, 1);
 564         brelse(bh);
 565         oldinode->i_nlink++;
 566         oldinode->i_ctime = CURRENT_TIME;
 567         mark_inode_dirty(oldinode);
 568         oldinode->i_count++;
 569         d_instantiate(dentry, oldinode);
 570         return 0;
 571 }
 572
 573 #define PARENT_INO(buffer) \
 574 (((struct sysv_dir_entry *) ((buffer) + 1*SYSV_DIRSIZE))->inode)
 575
 576 /*
 577  * rename uses retrying to avoid race-conditions: at least they should be minimal.
 578  * it tries to allocate all the blocks, then sanity-checks, and if the sanity-
 579  * checks fail, it tries to restart itself again. Very practical - no changes
 580  * are done until we know everything works ok.. and then all the changes can be
 581  * done in one fell swoop when we have claimed all the buffers needed.
 582  *
 583  * Anybody can rename anything with this: the permission checks are left to the
 584  * higher-level routines.
 585  */
 586 int sysv_rename(struct inode * old_dir, struct dentry * old_dentry,
 587                   struct inode * new_dir, struct dentry * new_dentry)
 588 {
 589         struct inode * old_inode, * new_inode;
 590         struct buffer_head * old_bh, * new_bh, * dir_bh;
 591         struct sysv_dir_entry * old_de, * new_de;
 592         int retval;
 593
 594         goto start_up;
 595 try_again:
 596         brelse(old_bh);
 597         brelse(new_bh);
 598         brelse(dir_bh);
 599         current->counter = 0;
 600         schedule();
 601 start_up:
 602         old_inode = new_inode = NULL;
 603         old_bh = new_bh = dir_bh = NULL;
 604         old_bh = sysv_find_entry(old_dir, old_dentry->d_name.name,
 605                                 old_dentry->d_name.len, &old_de);
 606         retval = -ENOENT;
 607         if (!old_bh)
 608                 goto end_rename;
 609         old_inode = old_dentry->d_inode;        /* don't cross mnt-points */
 610         retval = -EPERM;
 611         new_inode = new_dentry->d_inode;
 612         new_bh = sysv_find_entry(new_dir, new_dentry->d_name.name,
 613                                 new_dentry->d_name.len, &new_de);
 614         if (new_bh) {
 615                 if (!new_inode) {
 616                         brelse(new_bh);
 617                         new_bh = NULL;
 618                 }
 619         }
 620         if (S_ISDIR(old_inode->i_mode)) {
 621                 if (new_inode) {
 622                         retval = -ENOTEMPTY;
 623                         if (!empty_dir(new_inode))
 624                                 goto end_rename;
 625                 }
 626                 retval = -EIO;
 627                 dir_bh = sysv_file_bread(old_inode, 0, 0);
 628                 if (!dir_bh)
 629                         goto end_rename;
 630                 if (PARENT_INO(dir_bh->b_data) != old_dir->i_ino)
 631                         goto end_rename;
 632                 retval = -EMLINK;
 633                 if (!new_inode && new_dir->i_nlink >= new_dir->i_sb->sv_link_max)
 634                         goto end_rename;
 635         }
 636         if (!new_bh) {
 637                 retval = sysv_add_entry(new_dir, new_dentry->d_name.name,
 638                                         new_dentry->d_name.len, &new_bh, &new_de);
 639                 if (retval)
 640                         goto end_rename;
 641         }
 642 /* sanity checking before doing the rename - avoid races */
 643         if (new_inode && (new_de->inode != new_inode->i_ino))
 644                 goto try_again;
 645         if (new_de->inode && !new_inode)
 646                 goto try_again;
 647         if (old_de->inode != old_inode->i_ino)
 648                 goto try_again;
 649 /* ok, that's it */
 650         old_de->inode = 0;
 651         new_de->inode = old_inode->i_ino;
 652         old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
 653         mark_inode_dirty(old_dir);
 654         new_dir->i_ctime = new_dir->i_mtime = CURRENT_TIME;
 655         mark_inode_dirty(new_dir);
 656         if (new_inode) {
 657                 new_inode->i_nlink--;
 658                 new_inode->i_ctime = CURRENT_TIME;
 659                 mark_inode_dirty(new_inode);
 660         }
 661         mark_buffer_dirty(old_bh, 1);
 662         mark_buffer_dirty(new_bh, 1);
 663         if (dir_bh) {
 664                 PARENT_INO(dir_bh->b_data) = new_dir->i_ino;
 665                 mark_buffer_dirty(dir_bh, 1);
 666                 old_dir->i_nlink--;
 667                 mark_inode_dirty(old_dir);
 668                 if (new_inode) {
 669                         new_inode->i_nlink--;
 670                         mark_inode_dirty(new_inode);
 671                 } else {
 672                         new_dir->i_nlink++;
 673                         mark_inode_dirty(new_dir);
 674                 }
 675         }
 676         retval = 0;
 677 end_rename:
 678         brelse(dir_bh);
 679         brelse(old_bh);
 680         brelse(new_bh);
 681         return retval;
 682 }