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 dput(dentry); 418 hpfs_unlock(dir->i_sb); 419 return -ENOSPC; 420 } 421 if (generic_permission(inode, MAY_WRITE, 0, NULL) || 422 !S_ISREG(inode->i_mode) || 423 get_write_access(inode)) { 424 d_rehash(dentry); 425 dput(dentry); 426 } else { 427 struct iattr newattrs; 428 /*printk("HPFS: truncating file before delete.\n");*/ 429 newattrs.ia_size = 0; 430 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME; 431 err = notify_change(dentry, &newattrs); 432 put_write_access(inode); 433 dput(dentry); 434 if (!err) 435 goto again; 436 } 437 hpfs_unlock(dir->i_sb); 438 return -ENOSPC; 439 default: 440 drop_nlink(inode); 441 err = 0; 442 } 443 goto out; 444 445 out1: 446 hpfs_brelse4(&qbh); 447 out: 448 mutex_unlock(&hpfs_i(dir)->i_mutex); 449 mutex_unlock(&hpfs_i(inode)->i_parent_mutex); 450 hpfs_unlock(dir->i_sb); 451 return err; 452 } 453 454 static int hpfs_rmdir(struct inode *dir, struct dentry *dentry) 455 { 456 const unsigned char *name = dentry->d_name.name; 457 unsigned len = dentry->d_name.len; 458 struct quad_buffer_head qbh; 459 struct hpfs_dirent *de; 460 struct inode *inode = dentry->d_inode; 461 dnode_secno dno; 462 fnode_secno fno; 463 int n_items = 0; 464 int err; 465 int r; 466 467 hpfs_adjust_length(name, &len); 468 hpfs_lock(dir->i_sb); 469 mutex_lock(&hpfs_i(inode)->i_parent_mutex); 470 mutex_lock(&hpfs_i(dir)->i_mutex); 471 err = -ENOENT; 472 de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh); 473 if (!de) 474 goto out; 475 476 err = -EPERM; 477 if (de->first) 478 goto out1; 479 480 err = -ENOTDIR; 481 if (!de->directory) 482 goto out1; 483 484 hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items); 485 err = -ENOTEMPTY; 486 if (n_items) 487 goto out1; 488 489 fno = de->fnode; 490 r = hpfs_remove_dirent(dir, dno, de, &qbh, 1); 491 switch (r) { 492 case 1: 493 hpfs_error(dir->i_sb, "there was error when removing dirent"); 494 err = -EFSERROR; 495 break; 496 case 2: 497 err = -ENOSPC; 498 break; 499 default: 500 drop_nlink(dir); 501 clear_nlink(inode); 502 err = 0; 503 } 504 goto out; 505 out1: 506 hpfs_brelse4(&qbh); 507 out: 508 mutex_unlock(&hpfs_i(dir)->i_mutex); 509 mutex_unlock(&hpfs_i(inode)->i_parent_mutex); 510 hpfs_unlock(dir->i_sb); 511 return err; 512 } 513 514 static int hpfs_symlink_readpage(struct file *file, struct page *page) 515 { 516 char *link = kmap(page); 517 struct inode *i = page->mapping->host; 518 struct fnode *fnode; 519 struct buffer_head *bh; 520 int err; 521 522 err = -EIO; 523 hpfs_lock(i->i_sb); 524 if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) 525 goto fail; 526 err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE); 527 brelse(bh); 528 if (err) 529 goto fail; 530 hpfs_unlock(i->i_sb); 531 SetPageUptodate(page); 532 kunmap(page); 533 unlock_page(page); 534 return 0; 535 536 fail: 537 hpfs_unlock(i->i_sb); 538 SetPageError(page); 539 kunmap(page); 540 unlock_page(page); 541 return err; 542 } 543 544 const struct address_space_operations hpfs_symlink_aops = { 545 .readpage = hpfs_symlink_readpage 546 }; 547 548 static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry, 549 struct inode *new_dir, struct dentry *new_dentry) 550 { 551 const unsigned char *old_name = old_dentry->d_name.name; 552 unsigned old_len = old_dentry->d_name.len; 553 const unsigned char *new_name = new_dentry->d_name.name; 554 unsigned new_len = new_dentry->d_name.len; 555 struct inode *i = old_dentry->d_inode; 556 struct inode *new_inode = new_dentry->d_inode; 557 struct quad_buffer_head qbh, qbh1; 558 struct hpfs_dirent *dep, *nde; 559 struct hpfs_dirent de; 560 dnode_secno dno; 561 int r; 562 struct buffer_head *bh; 563 struct fnode *fnode; 564 int err; 565 if ((err = hpfs_chk_name(new_name, &new_len))) return err; 566 err = 0; 567 hpfs_adjust_length(old_name, &old_len); 568 569 hpfs_lock(i->i_sb); 570 /* order doesn't matter, due to VFS exclusion */ 571 mutex_lock(&hpfs_i(i)->i_parent_mutex); 572 if (new_inode) 573 mutex_lock(&hpfs_i(new_inode)->i_parent_mutex); 574 mutex_lock(&hpfs_i(old_dir)->i_mutex); 575 if (new_dir != old_dir) 576 mutex_lock(&hpfs_i(new_dir)->i_mutex); 577 578 /* Erm? Moving over the empty non-busy directory is perfectly legal */ 579 if (new_inode && S_ISDIR(new_inode->i_mode)) { 580 err = -EINVAL; 581 goto end1; 582 } 583 584 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) { 585 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed"); 586 err = -ENOENT; 587 goto end1; 588 } 589 copy_de(&de, dep); 590 de.hidden = new_name[0] == '.'; 591 592 if (new_inode) { 593 int r; 594 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) { 595 if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) { 596 clear_nlink(new_inode); 597 copy_de(nde, &de); 598 memcpy(nde->name, new_name, new_len); 599 hpfs_mark_4buffers_dirty(&qbh1); 600 hpfs_brelse4(&qbh1); 601 goto end; 602 } 603 hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent"); 604 err = -EFSERROR; 605 goto end1; 606 } 607 err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0; 608 goto end1; 609 } 610 611 if (new_dir == old_dir) hpfs_brelse4(&qbh); 612 613 hpfs_lock_creation(i->i_sb); 614 if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) { 615 hpfs_unlock_creation(i->i_sb); 616 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!"); 617 err = r == 1 ? -ENOSPC : -EFSERROR; 618 if (new_dir != old_dir) hpfs_brelse4(&qbh); 619 goto end1; 620 } 621 622 if (new_dir == old_dir) 623 if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) { 624 hpfs_unlock_creation(i->i_sb); 625 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2"); 626 err = -ENOENT; 627 goto end1; 628 } 629 630 if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) { 631 hpfs_unlock_creation(i->i_sb); 632 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent"); 633 err = r == 2 ? -ENOSPC : -EFSERROR; 634 goto end1; 635 } 636 hpfs_unlock_creation(i->i_sb); 637 638 end: 639 hpfs_i(i)->i_parent_dir = new_dir->i_ino; 640 if (S_ISDIR(i->i_mode)) { 641 inc_nlink(new_dir); 642 drop_nlink(old_dir); 643 } 644 if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) { 645 fnode->up = new_dir->i_ino; 646 fnode->len = new_len; 647 memcpy(fnode->name, new_name, new_len>15?15:new_len); 648 if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len); 649 mark_buffer_dirty(bh); 650 brelse(bh); 651 } 652 hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv; 653 hpfs_decide_conv(i, new_name, new_len); 654 end1: 655 if (old_dir != new_dir) 656 mutex_unlock(&hpfs_i(new_dir)->i_mutex); 657 mutex_unlock(&hpfs_i(old_dir)->i_mutex); 658 mutex_unlock(&hpfs_i(i)->i_parent_mutex); 659 if (new_inode) 660 mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex); 661 hpfs_unlock(i->i_sb); 662 return err; 663 } 664 665 const struct inode_operations hpfs_dir_iops = 666 { 667 .create = hpfs_create, 668 .lookup = hpfs_lookup, 669 .unlink = hpfs_unlink, 670 .symlink = hpfs_symlink, 671 .mkdir = hpfs_mkdir, 672 .rmdir = hpfs_rmdir, 673 .mknod = hpfs_mknod, 674 .rename = hpfs_rename, 675 .setattr = hpfs_setattr, 676 }; 677