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 565 if (new_inode && S_ISDIR(new_inode->i_mode)) 566 dentry_unhash(new_dentry); 567 568 if ((err = hpfs_chk_name(new_name, &new_len))) return err; 569 err = 0; 570 hpfs_adjust_length(old_name, &old_len); 571 572 hpfs_lock(i->i_sb); 573 /* order doesn't matter, due to VFS exclusion */ 574 mutex_lock(&hpfs_i(i)->i_parent_mutex); 575 if (new_inode) 576 mutex_lock(&hpfs_i(new_inode)->i_parent_mutex); 577 mutex_lock(&hpfs_i(old_dir)->i_mutex); 578 if (new_dir != old_dir) 579 mutex_lock(&hpfs_i(new_dir)->i_mutex); 580 581 /* Erm? Moving over the empty non-busy directory is perfectly legal */ 582 if (new_inode && S_ISDIR(new_inode->i_mode)) { 583 err = -EINVAL; 584 goto end1; 585 } 586 587 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) { 588 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed"); 589 err = -ENOENT; 590 goto end1; 591 } 592 copy_de(&de, dep); 593 de.hidden = new_name[0] == '.'; 594 595 if (new_inode) { 596 int r; 597 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) { 598 if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) { 599 clear_nlink(new_inode); 600 copy_de(nde, &de); 601 memcpy(nde->name, new_name, new_len); 602 hpfs_mark_4buffers_dirty(&qbh1); 603 hpfs_brelse4(&qbh1); 604 goto end; 605 } 606 hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent"); 607 err = -EFSERROR; 608 goto end1; 609 } 610 err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0; 611 goto end1; 612 } 613 614 if (new_dir == old_dir) hpfs_brelse4(&qbh); 615 616 hpfs_lock_creation(i->i_sb); 617 if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) { 618 hpfs_unlock_creation(i->i_sb); 619 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!"); 620 err = r == 1 ? -ENOSPC : -EFSERROR; 621 if (new_dir != old_dir) hpfs_brelse4(&qbh); 622 goto end1; 623 } 624 625 if (new_dir == old_dir) 626 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) { 627 hpfs_unlock_creation(i->i_sb); 628 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2"); 629 err = -ENOENT; 630 goto end1; 631 } 632 633 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) { 634 hpfs_unlock_creation(i->i_sb); 635 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent"); 636 err = r == 2 ? -ENOSPC : -EFSERROR; 637 goto end1; 638 } 639 hpfs_unlock_creation(i->i_sb); 640 641 end: 642 hpfs_i(i)->i_parent_dir = new_dir->i_ino; 643 if (S_ISDIR(i->i_mode)) { 644 inc_nlink(new_dir); 645 drop_nlink(old_dir); 646 } 647 if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) { 648 fnode->up = new_dir->i_ino; 649 fnode->len = new_len; 650 memcpy(fnode->name, new_name, new_len>15?15:new_len); 651 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len); 652 mark_buffer_dirty(bh); 653 brelse(bh); 654 } 655 hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv; 656 hpfs_decide_conv(i, new_name, new_len); 657 end1: 658 if (old_dir != new_dir) 659 mutex_unlock(&hpfs_i(new_dir)->i_mutex); 660 mutex_unlock(&hpfs_i(old_dir)->i_mutex); 661 mutex_unlock(&hpfs_i(i)->i_parent_mutex); 662 if (new_inode) 663 mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex); 664 hpfs_unlock(i->i_sb); 665 return err; 666 } 667 668 const struct inode_operations hpfs_dir_iops = 669 { 670 .create = hpfs_create, 671 .lookup = hpfs_lookup, 672 .unlink = hpfs_unlink, 673 .symlink = hpfs_symlink, 674 .mkdir = hpfs_mkdir, 675 .rmdir = hpfs_rmdir, 676 .mknod = hpfs_mknod, 677 .rename = hpfs_rename, 678 .setattr = hpfs_setattr, 679 }; 680