fs/hpfs/namei.c

   1 /*
   2  *  linux/fs/hpfs/namei.c
   3  *
   4  *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
   5  *
   6  *  adding & removing files & directories
   7  */
   8 #include <linux/sched.h>
   9 #include "hpfs_fn.h"
  10
  11 static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
  12 {
  13         const unsigned char *name = dentry->d_name.name;
  14         unsigned len = dentry->d_name.len;
  15         struct quad_buffer_head qbh0;
  16         struct buffer_head *bh;
  17         struct hpfs_dirent *de;
  18         struct fnode *fnode;
  19         struct dnode *dnode;
  20         struct inode *result;
  21         fnode_secno fno;
  22         dnode_secno dno;
  23         int r;
  24         struct hpfs_dirent dee;
  25         int err;
  26         if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
  27         hpfs_lock(dir->i_sb);
  28         err = -ENOSPC;
  29         fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
  30         if (!fnode)
  31                 goto bail;
  32         dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1);
  33         if (!dnode)
  34                 goto bail1;
  35         memset(&dee, 0, sizeof dee);
  36         dee.directory = 1;
  37         if (!(mode & 0222)) dee.read_only = 1;
  38         /*dee.archive = 0;*/
  39         dee.hidden = name[0] == '.';
  40         dee.fnode = fno;
  41         dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
  42         result = new_inode(dir->i_sb);
  43         if (!result)
  44                 goto bail2;
  45         hpfs_init_inode(result);
  46         result->i_ino = fno;
  47         hpfs_i(result)->i_parent_dir = dir->i_ino;
  48         hpfs_i(result)->i_dno = dno;
  49         result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
  50         result->i_ctime.tv_nsec = 0;
  51         result->i_mtime.tv_nsec = 0;
  52         result->i_atime.tv_nsec = 0;
  53         hpfs_i(result)->i_ea_size = 0;
  54         result->i_mode |= S_IFDIR;
  55         result->i_op = &hpfs_dir_iops;
  56         result->i_fop = &hpfs_dir_ops;
  57         result->i_blocks = 4;
  58         result->i_size = 2048;
  59         result->i_nlink = 2;
  60         if (dee.read_only)
  61                 result->i_mode &= ~0222;
  62
  63         mutex_lock(&hpfs_i(dir)->i_mutex);
  64         r = hpfs_add_dirent(dir, name, len, &dee, 0);
  65         if (r == 1)
  66                 goto bail3;
  67         if (r == -1) {
  68                 err = -EEXIST;
  69                 goto bail3;
  70         }
  71         fnode->len = len;
  72         memcpy(fnode->name, name, len > 15 ? 15 : len);
  73         fnode->up = dir->i_ino;
  74         fnode->dirflag = 1;
  75         fnode->btree.n_free_nodes = 7;
  76         fnode->btree.n_used_nodes = 1;
  77         fnode->btree.first_free = 0x14;
  78         fnode->u.external[0].disk_secno = dno;
  79         fnode->u.external[0].file_secno = -1;
  80         dnode->root_dnode = 1;
  81         dnode->up = fno;
  82         de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
  83         de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, get_seconds());
  84         if (!(mode & 0222)) de->read_only = 1;
  85         de->first = de->directory = 1;
  86         /*de->hidden = de->system = 0;*/
  87         de->fnode = fno;
  88         mark_buffer_dirty(bh);
  89         brelse(bh);
  90         hpfs_mark_4buffers_dirty(&qbh0);
  91         hpfs_brelse4(&qbh0);
  92         inc_nlink(dir);
  93         insert_inode_hash(result);
  94
  95         if (result->i_uid != current_fsuid() ||
  96             result->i_gid != current_fsgid() ||
  97             result->i_mode != (mode | S_IFDIR)) {
  98                 result->i_uid = current_fsuid();
  99                 result->i_gid = current_fsgid();
 100                 result->i_mode = mode | S_IFDIR;
 101                 hpfs_write_inode_nolock(result);
 102         }
 103         d_instantiate(dentry, result);
 104         mutex_unlock(&hpfs_i(dir)->i_mutex);
 105         hpfs_unlock(dir->i_sb);
 106         return 0;
 107 bail3:
 108         mutex_unlock(&hpfs_i(dir)->i_mutex);
 109         iput(result);
 110 bail2:
 111         hpfs_brelse4(&qbh0);
 112         hpfs_free_dnode(dir->i_sb, dno);
 113 bail1:
 114         brelse(bh);
 115         hpfs_free_sectors(dir->i_sb, fno, 1);
 116 bail:
 117         hpfs_unlock(dir->i_sb);
 118         return err;
 119 }
 120
 121 static int hpfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
 122 {
 123         const unsigned char *name = dentry->d_name.name;
 124         unsigned len = dentry->d_name.len;
 125         struct inode *result = NULL;
 126         struct buffer_head *bh;
 127         struct fnode *fnode;
 128         fnode_secno fno;
 129         int r;
 130         struct hpfs_dirent dee;
 131         int err;
 132         if ((err = hpfs_chk_name(name, &len)))
 133                 return err==-ENOENT ? -EINVAL : err;
 134         hpfs_lock(dir->i_sb);
 135         err = -ENOSPC;
 136         fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
 137         if (!fnode)
 138                 goto bail;
 139         memset(&dee, 0, sizeof dee);
 140         if (!(mode & 0222)) dee.read_only = 1;
 141         dee.archive = 1;
 142         dee.hidden = name[0] == '.';
 143         dee.fnode = fno;
 144         dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
 145
 146         result = new_inode(dir->i_sb);
 147         if (!result)
 148                 goto bail1;
 149
 150         hpfs_init_inode(result);
 151         result->i_ino = fno;
 152         result->i_mode |= S_IFREG;
 153         result->i_mode &= ~0111;
 154         result->i_op = &hpfs_file_iops;
 155         result->i_fop = &hpfs_file_ops;
 156         result->i_nlink = 1;
 157         hpfs_decide_conv(result, name, len);
 158         hpfs_i(result)->i_parent_dir = dir->i_ino;
 159         result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
 160         result->i_ctime.tv_nsec = 0;
 161         result->i_mtime.tv_nsec = 0;
 162         result->i_atime.tv_nsec = 0;
 163         hpfs_i(result)->i_ea_size = 0;
 164         if (dee.read_only)
 165                 result->i_mode &= ~0222;
 166         result->i_blocks = 1;
 167         result->i_size = 0;
 168         result->i_data.a_ops = &hpfs_aops;
 169         hpfs_i(result)->mmu_private = 0;
 170
 171         mutex_lock(&hpfs_i(dir)->i_mutex);
 172         r = hpfs_add_dirent(dir, name, len, &dee, 0);
 173         if (r == 1)
 174                 goto bail2;
 175         if (r == -1) {
 176                 err = -EEXIST;
 177                 goto bail2;
 178         }
 179         fnode->len = len;
 180         memcpy(fnode->name, name, len > 15 ? 15 : len);
 181         fnode->up = dir->i_ino;
 182         mark_buffer_dirty(bh);
 183         brelse(bh);
 184
 185         insert_inode_hash(result);
 186
 187         if (result->i_uid != current_fsuid() ||
 188             result->i_gid != current_fsgid() ||
 189             result->i_mode != (mode | S_IFREG)) {
 190                 result->i_uid = current_fsuid();
 191                 result->i_gid = current_fsgid();
 192                 result->i_mode = mode | S_IFREG;
 193                 hpfs_write_inode_nolock(result);
 194         }
 195         d_instantiate(dentry, result);
 196         mutex_unlock(&hpfs_i(dir)->i_mutex);
 197         hpfs_unlock(dir->i_sb);
 198         return 0;
 199
 200 bail2:
 201         mutex_unlock(&hpfs_i(dir)->i_mutex);
 202         iput(result);
 203 bail1:
 204         brelse(bh);
 205         hpfs_free_sectors(dir->i_sb, fno, 1);
 206 bail:
 207         hpfs_unlock(dir->i_sb);
 208         return err;
 209 }
 210
 211 static int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
 212 {
 213         const unsigned char *name = dentry->d_name.name;
 214         unsigned len = dentry->d_name.len;
 215         struct buffer_head *bh;
 216         struct fnode *fnode;
 217         fnode_secno fno;
 218         int r;
 219         struct hpfs_dirent dee;
 220         struct inode *result = NULL;
 221         int err;
 222         if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
 223         if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM;
 224         if (!new_valid_dev(rdev))
 225                 return -EINVAL;
 226         hpfs_lock(dir->i_sb);
 227         err = -ENOSPC;
 228         fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
 229         if (!fnode)
 230                 goto bail;
 231         memset(&dee, 0, sizeof dee);
 232         if (!(mode & 0222)) dee.read_only = 1;
 233         dee.archive = 1;
 234         dee.hidden = name[0] == '.';
 235         dee.fnode = fno;
 236         dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
 237
 238         result = new_inode(dir->i_sb);
 239         if (!result)
 240                 goto bail1;
 241
 242         hpfs_init_inode(result);
 243         result->i_ino = fno;
 244         hpfs_i(result)->i_parent_dir = dir->i_ino;
 245         result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
 246         result->i_ctime.tv_nsec = 0;
 247         result->i_mtime.tv_nsec = 0;
 248         result->i_atime.tv_nsec = 0;
 249         hpfs_i(result)->i_ea_size = 0;
 250         result->i_uid = current_fsuid();
 251         result->i_gid = current_fsgid();
 252         result->i_nlink = 1;
 253         result->i_size = 0;
 254         result->i_blocks = 1;
 255         init_special_inode(result, mode, rdev);
 256
 257         mutex_lock(&hpfs_i(dir)->i_mutex);
 258         r = hpfs_add_dirent(dir, name, len, &dee, 0);
 259         if (r == 1)
 260                 goto bail2;
 261         if (r == -1) {
 262                 err = -EEXIST;
 263                 goto bail2;
 264         }
 265         fnode->len = len;
 266         memcpy(fnode->name, name, len > 15 ? 15 : len);
 267         fnode->up = dir->i_ino;
 268         mark_buffer_dirty(bh);
 269
 270         insert_inode_hash(result);
 271
 272         hpfs_write_inode_nolock(result);
 273         d_instantiate(dentry, result);
 274         mutex_unlock(&hpfs_i(dir)->i_mutex);
 275         brelse(bh);
 276         hpfs_unlock(dir->i_sb);
 277         return 0;
 278 bail2:
 279         mutex_unlock(&hpfs_i(dir)->i_mutex);
 280         iput(result);
 281 bail1:
 282         brelse(bh);
 283         hpfs_free_sectors(dir->i_sb, fno, 1);
 284 bail:
 285         hpfs_unlock(dir->i_sb);
 286         return err;
 287 }
 288
 289 static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
 290 {
 291         const unsigned char *name = dentry->d_name.name;
 292         unsigned len = dentry->d_name.len;
 293         struct buffer_head *bh;
 294         struct fnode *fnode;
 295         fnode_secno fno;
 296         int r;
 297         struct hpfs_dirent dee;
 298         struct inode *result;
 299         int err;
 300         if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
 301         hpfs_lock(dir->i_sb);
 302         if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
 303                 hpfs_unlock(dir->i_sb);
 304                 return -EPERM;
 305         }
 306         err = -ENOSPC;
 307         fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
 308         if (!fnode)
 309                 goto bail;
 310         memset(&dee, 0, sizeof dee);
 311         dee.archive = 1;
 312         dee.hidden = name[0] == '.';
 313         dee.fnode = fno;
 314         dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
 315
 316         result = new_inode(dir->i_sb);
 317         if (!result)
 318                 goto bail1;
 319         result->i_ino = fno;
 320         hpfs_init_inode(result);
 321         hpfs_i(result)->i_parent_dir = dir->i_ino;
 322         result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
 323         result->i_ctime.tv_nsec = 0;
 324         result->i_mtime.tv_nsec = 0;
 325         result->i_atime.tv_nsec = 0;
 326         hpfs_i(result)->i_ea_size = 0;
 327         result->i_mode = S_IFLNK | 0777;
 328         result->i_uid = current_fsuid();
 329         result->i_gid = current_fsgid();
 330         result->i_blocks = 1;
 331         result->i_nlink = 1;
 332         result->i_size = strlen(symlink);
 333         result->i_op = &page_symlink_inode_operations;
 334         result->i_data.a_ops = &hpfs_symlink_aops;
 335
 336         mutex_lock(&hpfs_i(dir)->i_mutex);
 337         r = hpfs_add_dirent(dir, name, len, &dee, 0);
 338         if (r == 1)
 339                 goto bail2;
 340         if (r == -1) {
 341                 err = -EEXIST;
 342                 goto bail2;
 343         }
 344         fnode->len = len;
 345         memcpy(fnode->name, name, len > 15 ? 15 : len);
 346         fnode->up = dir->i_ino;
 347         hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
 348         mark_buffer_dirty(bh);
 349         brelse(bh);
 350
 351         insert_inode_hash(result);
 352
 353         hpfs_write_inode_nolock(result);
 354         d_instantiate(dentry, result);
 355         mutex_unlock(&hpfs_i(dir)->i_mutex);
 356         hpfs_unlock(dir->i_sb);
 357         return 0;
 358 bail2:
 359         mutex_unlock(&hpfs_i(dir)->i_mutex);
 360         iput(result);
 361 bail1:
 362         brelse(bh);
 363         hpfs_free_sectors(dir->i_sb, fno, 1);
 364 bail:
 365         hpfs_unlock(dir->i_sb);
 366         return err;
 367 }
 368
 369 static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
 370 {
 371         const unsigned char *name = dentry->d_name.name;
 372         unsigned len = dentry->d_name.len;
 373         struct quad_buffer_head qbh;
 374         struct hpfs_dirent *de;
 375         struct inode *inode = dentry->d_inode;
 376         dnode_secno dno;
 377         fnode_secno fno;
 378         int r;
 379         int rep = 0;
 380         int err;
 381
 382         hpfs_lock(dir->i_sb);
 383         hpfs_adjust_length(name, &len);
 384 again:
 385         mutex_lock(&hpfs_i(inode)->i_parent_mutex);
 386         mutex_lock(&hpfs_i(dir)->i_mutex);
 387         err = -ENOENT;
 388         de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
 389         if (!de)
 390                 goto out;
 391
 392         err = -EPERM;
 393         if (de->first)
 394                 goto out1;
 395
 396         err = -EISDIR;
 397         if (de->directory)
 398                 goto out1;
 399
 400         fno = de->fnode;
 401         r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
 402         switch (r) {
 403         case 1:
 404                 hpfs_error(dir->i_sb, "there was error when removing dirent");
 405                 err = -EFSERROR;
 406                 break;
 407         case 2:         /* no space for deleting, try to truncate file */
 408
 409                 err = -ENOSPC;
 410                 if (rep++)
 411                         break;
 412
 413                 mutex_unlock(&hpfs_i(dir)->i_mutex);
 414                 mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
 415                 dentry_unhash(dentry);
 416                 if (!d_unhashed(dentry)) {
 417                         hpfs_unlock(dir->i_sb);
 418                         return -ENOSPC;
 419                 }
 420                 if (generic_permission(inode, MAY_WRITE, 0, NULL) ||
 421                     !S_ISREG(inode->i_mode) ||
 422                     get_write_access(inode)) {
 423                         d_rehash(dentry);
 424                 } else {
 425                         struct iattr newattrs;
 426                         /*printk("HPFS: truncating file before delete.\n");*/
 427                         newattrs.ia_size = 0;
 428                         newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
 429                         err = notify_change(dentry, &newattrs);
 430                         put_write_access(inode);
 431                         if (!err)
 432                                 goto again;
 433                 }
 434                 hpfs_unlock(dir->i_sb);
 435                 return -ENOSPC;
 436         default:
 437                 drop_nlink(inode);
 438                 err = 0;
 439         }
 440         goto out;
 441
 442 out1:
 443         hpfs_brelse4(&qbh);
 444 out:
 445         mutex_unlock(&hpfs_i(dir)->i_mutex);
 446         mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
 447         hpfs_unlock(dir->i_sb);
 448         return err;
 449 }
 450
 451 static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
 452 {
 453         const unsigned char *name = dentry->d_name.name;
 454         unsigned len = dentry->d_name.len;
 455         struct quad_buffer_head qbh;
 456         struct hpfs_dirent *de;
 457         struct inode *inode = dentry->d_inode;
 458         dnode_secno dno;
 459         fnode_secno fno;
 460         int n_items = 0;
 461         int err;
 462         int r;
 463
 464         dentry_unhash(dentry);
 465
 466         hpfs_adjust_length(name, &len);
 467         hpfs_lock(dir->i_sb);
 468         mutex_lock(&hpfs_i(inode)->i_parent_mutex);
 469         mutex_lock(&hpfs_i(dir)->i_mutex);
 470         err = -ENOENT;
 471         de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
 472         if (!de)
 473                 goto out;
 474
 475         err = -EPERM;
 476         if (de->first)
 477                 goto out1;
 478
 479         err = -ENOTDIR;
 480         if (!de->directory)
 481                 goto out1;
 482
 483         hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items);
 484         err = -ENOTEMPTY;
 485         if (n_items)
 486                 goto out1;
 487
 488         fno = de->fnode;
 489         r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
 490         switch (r) {
 491         case 1:
 492                 hpfs_error(dir->i_sb, "there was error when removing dirent");
 493                 err = -EFSERROR;
 494                 break;
 495         case 2:
 496                 err = -ENOSPC;
 497                 break;
 498         default:
 499                 drop_nlink(dir);
 500                 clear_nlink(inode);
 501                 err = 0;
 502         }
 503         goto out;
 504 out1:
 505         hpfs_brelse4(&qbh);
 506 out:
 507         mutex_unlock(&hpfs_i(dir)->i_mutex);
 508         mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
 509         hpfs_unlock(dir->i_sb);
 510         return err;
 511 }
 512
 513 static int hpfs_symlink_readpage(struct file *file, struct page *page)
 514 {
 515         char *link = kmap(page);
 516         struct inode *i = page->mapping->host;
 517         struct fnode *fnode;
 518         struct buffer_head *bh;
 519         int err;
 520
 521         err = -EIO;
 522         hpfs_lock(i->i_sb);
 523         if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
 524                 goto fail;
 525         err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
 526         brelse(bh);
 527         if (err)
 528                 goto fail;
 529         hpfs_unlock(i->i_sb);
 530         SetPageUptodate(page);
 531         kunmap(page);
 532         unlock_page(page);
 533         return 0;
 534
 535 fail:
 536         hpfs_unlock(i->i_sb);
 537         SetPageError(page);
 538         kunmap(page);
 539         unlock_page(page);
 540         return err;
 541 }
 542
 543 const struct address_space_operations hpfs_symlink_aops = {
 544         .readpage       = hpfs_symlink_readpage
 545 };
 546
 547 static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 548                 struct inode *new_dir, struct dentry *new_dentry)
 549 {
 550         const unsigned char *old_name = old_dentry->d_name.name;
 551         unsigned old_len = old_dentry->d_name.len;
 552         const unsigned char *new_name = new_dentry->d_name.name;
 553         unsigned new_len = new_dentry->d_name.len;
 554         struct inode *i = old_dentry->d_inode;
 555         struct inode *new_inode = new_dentry->d_inode;
 556         struct quad_buffer_head qbh, qbh1;
 557         struct hpfs_dirent *dep, *nde;
 558         struct hpfs_dirent de;
 559         dnode_secno dno;
 560         int r;
 561         struct buffer_head *bh;
 562         struct fnode *fnode;
 563         int err;
 564         if ((err = hpfs_chk_name(new_name, &new_len))) return err;
 565         err = 0;
 566         hpfs_adjust_length(old_name, &old_len);
 567
 568         hpfs_lock(i->i_sb);
 569         /* order doesn't matter, due to VFS exclusion */
 570         mutex_lock(&hpfs_i(i)->i_parent_mutex);
 571         if (new_inode)
 572                 mutex_lock(&hpfs_i(new_inode)->i_parent_mutex);
 573         mutex_lock(&hpfs_i(old_dir)->i_mutex);
 574         if (new_dir != old_dir)
 575                 mutex_lock(&hpfs_i(new_dir)->i_mutex);
 576
 577         /* Erm? Moving over the empty non-busy directory is perfectly legal */
 578         if (new_inode && S_ISDIR(new_inode->i_mode)) {
 579                 err = -EINVAL;
 580                 goto end1;
 581         }
 582
 583         if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
 584                 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
 585                 err = -ENOENT;
 586                 goto end1;
 587         }
 588         copy_de(&de, dep);
 589         de.hidden = new_name[0] == '.';
 590
 591         if (new_inode) {
 592                 int r;
 593                 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
 594                         if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) {
 595                                 clear_nlink(new_inode);
 596                                 copy_de(nde, &de);
 597                                 memcpy(nde->name, new_name, new_len);
 598                                 hpfs_mark_4buffers_dirty(&qbh1);
 599                                 hpfs_brelse4(&qbh1);
 600                                 goto end;
 601                         }
 602                         hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
 603                         err = -EFSERROR;
 604                         goto end1;
 605                 }
 606                 err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
 607                 goto end1;
 608         }
 609
 610         if (new_dir == old_dir) hpfs_brelse4(&qbh);
 611
 612         hpfs_lock_creation(i->i_sb);
 613         if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
 614                 hpfs_unlock_creation(i->i_sb);
 615                 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
 616                 err = r == 1 ? -ENOSPC : -EFSERROR;
 617                 if (new_dir != old_dir) hpfs_brelse4(&qbh);
 618                 goto end1;
 619         }
 620
 621         if (new_dir == old_dir)
 622                 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
 623                         hpfs_unlock_creation(i->i_sb);
 624                         hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
 625                         err = -ENOENT;
 626                         goto end1;
 627                 }
 628
 629         if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
 630                 hpfs_unlock_creation(i->i_sb);
 631                 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
 632                 err = r == 2 ? -ENOSPC : -EFSERROR;
 633                 goto end1;
 634         }
 635         hpfs_unlock_creation(i->i_sb);
 636
 637         end:
 638         hpfs_i(i)->i_parent_dir = new_dir->i_ino;
 639         if (S_ISDIR(i->i_mode)) {
 640                 inc_nlink(new_dir);
 641                 drop_nlink(old_dir);
 642         }
 643         if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
 644                 fnode->up = new_dir->i_ino;
 645                 fnode->len = new_len;
 646                 memcpy(fnode->name, new_name, new_len>15?15:new_len);
 647                 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
 648                 mark_buffer_dirty(bh);
 649                 brelse(bh);
 650         }
 651         hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv;
 652         hpfs_decide_conv(i, new_name, new_len);
 653 end1:
 654         if (old_dir != new_dir)
 655                 mutex_unlock(&hpfs_i(new_dir)->i_mutex);
 656         mutex_unlock(&hpfs_i(old_dir)->i_mutex);
 657         mutex_unlock(&hpfs_i(i)->i_parent_mutex);
 658         if (new_inode)
 659                 mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex);
 660         hpfs_unlock(i->i_sb);
 661         return err;
 662 }
 663
 664 const struct inode_operations hpfs_dir_iops =
 665 {
 666         .create         = hpfs_create,
 667         .lookup         = hpfs_lookup,
 668         .unlink         = hpfs_unlink,
 669         .symlink        = hpfs_symlink,
 670         .mkdir          = hpfs_mkdir,
 671         .rmdir          = hpfs_rmdir,
 672         .mknod          = hpfs_mknod,
 673         .rename         = hpfs_rename,
 674         .setattr        = hpfs_setattr,
 675 };