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