1 /* 2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README 3 * 4 * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility 5 * 6 * Trivial Changes: 7 * Rights granted to Hans Reiser to redistribute under other terms providing 8 * he accepts all liability including but not limited to patent, fitness 9 * for purpose, and direct or indirect claims arising from failure to perform. 10 * 11 * NO WARRANTY 12 */ 13 14 #include <linux/time.h> 15 #include <linux/bitops.h> 16 #include <linux/slab.h> 17 #include "reiserfs.h" 18 #include "acl.h" 19 #include "xattr.h" 20 #include <linux/quotaops.h> 21 22 #define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) set_nlink(i, 1); } 23 #define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) drop_nlink(i); 24 25 /* 26 * directory item contains array of entry headers. This performs 27 * binary search through that array 28 */ 29 static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off) 30 { 31 struct item_head *ih = de->de_ih; 32 struct reiserfs_de_head *deh = de->de_deh; 33 int rbound, lbound, j; 34 35 lbound = 0; 36 rbound = ih_entry_count(ih) - 1; 37 38 for (j = (rbound + lbound) / 2; lbound <= rbound; 39 j = (rbound + lbound) / 2) { 40 if (off < deh_offset(deh + j)) { 41 rbound = j - 1; 42 continue; 43 } 44 if (off > deh_offset(deh + j)) { 45 lbound = j + 1; 46 continue; 47 } 48 /* this is not name found, but matched third key component */ 49 de->de_entry_num = j; 50 return NAME_FOUND; 51 } 52 53 de->de_entry_num = lbound; 54 return NAME_NOT_FOUND; 55 } 56 57 /* 58 * comment? maybe something like set de to point to what the path points to? 59 */ 60 static inline void set_de_item_location(struct reiserfs_dir_entry *de, 61 struct treepath *path) 62 { 63 de->de_bh = get_last_bh(path); 64 de->de_ih = tp_item_head(path); 65 de->de_deh = B_I_DEH(de->de_bh, de->de_ih); 66 de->de_item_num = PATH_LAST_POSITION(path); 67 } 68 69 /* 70 * de_bh, de_ih, de_deh (points to first element of array), de_item_num is set 71 */ 72 inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de) 73 { 74 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num; 75 76 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih)); 77 78 de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num); 79 de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0); 80 de->de_name = ih_item_body(de->de_bh, de->de_ih) + deh_location(deh); 81 if (de->de_name[de->de_namelen - 1] == 0) 82 de->de_namelen = strlen(de->de_name); 83 } 84 85 /* what entry points to */ 86 static inline void set_de_object_key(struct reiserfs_dir_entry *de) 87 { 88 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih)); 89 de->de_dir_id = deh_dir_id(&de->de_deh[de->de_entry_num]); 90 de->de_objectid = deh_objectid(&de->de_deh[de->de_entry_num]); 91 } 92 93 static inline void store_de_entry_key(struct reiserfs_dir_entry *de) 94 { 95 struct reiserfs_de_head *deh = de->de_deh + de->de_entry_num; 96 97 BUG_ON(de->de_entry_num >= ih_entry_count(de->de_ih)); 98 99 /* store key of the found entry */ 100 de->de_entry_key.version = KEY_FORMAT_3_5; 101 de->de_entry_key.on_disk_key.k_dir_id = 102 le32_to_cpu(de->de_ih->ih_key.k_dir_id); 103 de->de_entry_key.on_disk_key.k_objectid = 104 le32_to_cpu(de->de_ih->ih_key.k_objectid); 105 set_cpu_key_k_offset(&de->de_entry_key, deh_offset(deh)); 106 set_cpu_key_k_type(&de->de_entry_key, TYPE_DIRENTRY); 107 } 108 109 /* 110 * We assign a key to each directory item, and place multiple entries in a 111 * single directory item. A directory item has a key equal to the key of 112 * the first directory entry in it. 113 114 * This function first calls search_by_key, then, if item whose first entry 115 * matches is not found it looks for the entry inside directory item found 116 * by search_by_key. Fills the path to the entry, and to the entry position 117 * in the item 118 */ 119 /* The function is NOT SCHEDULE-SAFE! */ 120 int search_by_entry_key(struct super_block *sb, const struct cpu_key *key, 121 struct treepath *path, struct reiserfs_dir_entry *de) 122 { 123 int retval; 124 125 retval = search_item(sb, key, path); 126 switch (retval) { 127 case ITEM_NOT_FOUND: 128 if (!PATH_LAST_POSITION(path)) { 129 reiserfs_error(sb, "vs-7000", "search_by_key " 130 "returned item position == 0"); 131 pathrelse(path); 132 return IO_ERROR; 133 } 134 PATH_LAST_POSITION(path)--; 135 break; 136 137 case ITEM_FOUND: 138 break; 139 140 case IO_ERROR: 141 return retval; 142 143 default: 144 pathrelse(path); 145 reiserfs_error(sb, "vs-7002", "no path to here"); 146 return IO_ERROR; 147 } 148 149 set_de_item_location(de, path); 150 151 #ifdef CONFIG_REISERFS_CHECK 152 if (!is_direntry_le_ih(de->de_ih) || 153 COMP_SHORT_KEYS(&de->de_ih->ih_key, key)) { 154 print_block(de->de_bh, 0, -1, -1); 155 reiserfs_panic(sb, "vs-7005", "found item %h is not directory " 156 "item or does not belong to the same directory " 157 "as key %K", de->de_ih, key); 158 } 159 #endif /* CONFIG_REISERFS_CHECK */ 160 161 /* 162 * binary search in directory item by third component of the 163 * key. sets de->de_entry_num of de 164 */ 165 retval = bin_search_in_dir_item(de, cpu_key_k_offset(key)); 166 path->pos_in_item = de->de_entry_num; 167 if (retval != NAME_NOT_FOUND) { 168 /* 169 * ugly, but rename needs de_bh, de_deh, de_name, 170 * de_namelen, de_objectid set 171 */ 172 set_de_name_and_namelen(de); 173 set_de_object_key(de); 174 } 175 return retval; 176 } 177 178 /* Keyed 32-bit hash function using TEA in a Davis-Meyer function */ 179 180 /* 181 * The third component is hashed, and you can choose from more than 182 * one hash function. Per directory hashes are not yet implemented 183 * but are thought about. This function should be moved to hashes.c 184 * Jedi, please do so. -Hans 185 */ 186 static __u32 get_third_component(struct super_block *s, 187 const char *name, int len) 188 { 189 __u32 res; 190 191 if (!len || (len == 1 && name[0] == '.')) 192 return DOT_OFFSET; 193 if (len == 2 && name[0] == '.' && name[1] == '.') 194 return DOT_DOT_OFFSET; 195 196 res = REISERFS_SB(s)->s_hash_function(name, len); 197 198 /* take bits from 7-th to 30-th including both bounds */ 199 res = GET_HASH_VALUE(res); 200 if (res == 0) 201 /* 202 * needed to have no names before "." and ".." those have hash 203 * value == 0 and generation conters 1 and 2 accordingly 204 */ 205 res = 128; 206 return res + MAX_GENERATION_NUMBER; 207 } 208 209 static int reiserfs_match(struct reiserfs_dir_entry *de, 210 const char *name, int namelen) 211 { 212 int retval = NAME_NOT_FOUND; 213 214 if ((namelen == de->de_namelen) && 215 !memcmp(de->de_name, name, de->de_namelen)) 216 retval = 217 (de_visible(de->de_deh + de->de_entry_num) ? NAME_FOUND : 218 NAME_FOUND_INVISIBLE); 219 220 return retval; 221 } 222 223 /* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */ 224 225 /* used when hash collisions exist */ 226 227 static int linear_search_in_dir_item(struct cpu_key *key, 228 struct reiserfs_dir_entry *de, 229 const char *name, int namelen) 230 { 231 struct reiserfs_de_head *deh = de->de_deh; 232 int retval; 233 int i; 234 235 i = de->de_entry_num; 236 237 if (i == ih_entry_count(de->de_ih) || 238 GET_HASH_VALUE(deh_offset(deh + i)) != 239 GET_HASH_VALUE(cpu_key_k_offset(key))) { 240 i--; 241 } 242 243 RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih), 244 "vs-7010: array of entry headers not found"); 245 246 deh += i; 247 248 for (; i >= 0; i--, deh--) { 249 /* hash value does not match, no need to check whole name */ 250 if (GET_HASH_VALUE(deh_offset(deh)) != 251 GET_HASH_VALUE(cpu_key_k_offset(key))) { 252 return NAME_NOT_FOUND; 253 } 254 255 /* mark that this generation number is used */ 256 if (de->de_gen_number_bit_string) 257 set_bit(GET_GENERATION_NUMBER(deh_offset(deh)), 258 de->de_gen_number_bit_string); 259 260 /* calculate pointer to name and namelen */ 261 de->de_entry_num = i; 262 set_de_name_and_namelen(de); 263 264 /* 265 * de's de_name, de_namelen, de_recordlen are set. 266 * Fill the rest. 267 */ 268 if ((retval = 269 reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) { 270 271 /* key of pointed object */ 272 set_de_object_key(de); 273 274 store_de_entry_key(de); 275 276 /* retval can be NAME_FOUND or NAME_FOUND_INVISIBLE */ 277 return retval; 278 } 279 } 280 281 if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0) 282 /* 283 * we have reached left most entry in the node. In common we 284 * have to go to the left neighbor, but if generation counter 285 * is 0 already, we know for sure, that there is no name with 286 * the same hash value 287 */ 288 /* 289 * FIXME: this work correctly only because hash value can not 290 * be 0. Btw, in case of Yura's hash it is probably possible, 291 * so, this is a bug 292 */ 293 return NAME_NOT_FOUND; 294 295 RFALSE(de->de_item_num, 296 "vs-7015: two diritems of the same directory in one node?"); 297 298 return GOTO_PREVIOUS_ITEM; 299 } 300 301 /* 302 * may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND 303 * FIXME: should add something like IOERROR 304 */ 305 static int reiserfs_find_entry(struct inode *dir, const char *name, int namelen, 306 struct treepath *path_to_entry, 307 struct reiserfs_dir_entry *de) 308 { 309 struct cpu_key key_to_search; 310 int retval; 311 312 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize)) 313 return NAME_NOT_FOUND; 314 315 /* we will search for this key in the tree */ 316 make_cpu_key(&key_to_search, dir, 317 get_third_component(dir->i_sb, name, namelen), 318 TYPE_DIRENTRY, 3); 319 320 while (1) { 321 retval = 322 search_by_entry_key(dir->i_sb, &key_to_search, 323 path_to_entry, de); 324 if (retval == IO_ERROR) { 325 reiserfs_error(dir->i_sb, "zam-7001", "io error"); 326 return IO_ERROR; 327 } 328 329 /* compare names for all entries having given hash value */ 330 retval = 331 linear_search_in_dir_item(&key_to_search, de, name, 332 namelen); 333 /* 334 * there is no need to scan directory anymore. 335 * Given entry found or does not exist 336 */ 337 if (retval != GOTO_PREVIOUS_ITEM) { 338 path_to_entry->pos_in_item = de->de_entry_num; 339 return retval; 340 } 341 342 /* 343 * there is left neighboring item of this directory 344 * and given entry can be there 345 */ 346 set_cpu_key_k_offset(&key_to_search, 347 le_ih_k_offset(de->de_ih) - 1); 348 pathrelse(path_to_entry); 349 350 } /* while (1) */ 351 } 352 353 static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry, 354 unsigned int flags) 355 { 356 int retval; 357 struct inode *inode = NULL; 358 struct reiserfs_dir_entry de; 359 INITIALIZE_PATH(path_to_entry); 360 361 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len) 362 return ERR_PTR(-ENAMETOOLONG); 363 364 reiserfs_write_lock(dir->i_sb); 365 366 de.de_gen_number_bit_string = NULL; 367 retval = 368 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, 369 &path_to_entry, &de); 370 pathrelse(&path_to_entry); 371 if (retval == NAME_FOUND) { 372 inode = reiserfs_iget(dir->i_sb, 373 (struct cpu_key *)&de.de_dir_id); 374 if (!inode || IS_ERR(inode)) { 375 reiserfs_write_unlock(dir->i_sb); 376 return ERR_PTR(-EACCES); 377 } 378 379 /* 380 * Propagate the private flag so we know we're 381 * in the priv tree. Also clear xattr support 382 * since we don't have xattrs on xattr files. 383 */ 384 if (IS_PRIVATE(dir)) 385 reiserfs_init_priv_inode(inode); 386 } 387 reiserfs_write_unlock(dir->i_sb); 388 if (retval == IO_ERROR) { 389 return ERR_PTR(-EIO); 390 } 391 392 return d_splice_alias(inode, dentry); 393 } 394 395 /* 396 * looks up the dentry of the parent directory for child. 397 * taken from ext2_get_parent 398 */ 399 struct dentry *reiserfs_get_parent(struct dentry *child) 400 { 401 int retval; 402 struct inode *inode = NULL; 403 struct reiserfs_dir_entry de; 404 INITIALIZE_PATH(path_to_entry); 405 struct inode *dir = d_inode(child); 406 407 if (dir->i_nlink == 0) { 408 return ERR_PTR(-ENOENT); 409 } 410 de.de_gen_number_bit_string = NULL; 411 412 reiserfs_write_lock(dir->i_sb); 413 retval = reiserfs_find_entry(dir, "..", 2, &path_to_entry, &de); 414 pathrelse(&path_to_entry); 415 if (retval != NAME_FOUND) { 416 reiserfs_write_unlock(dir->i_sb); 417 return ERR_PTR(-ENOENT); 418 } 419 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&de.de_dir_id); 420 reiserfs_write_unlock(dir->i_sb); 421 422 return d_obtain_alias(inode); 423 } 424 425 /* add entry to the directory (entry can be hidden). 426 427 insert definition of when hidden directories are used here -Hans 428 429 Does not mark dir inode dirty, do it after successesfull call to it */ 430 431 static int reiserfs_add_entry(struct reiserfs_transaction_handle *th, 432 struct inode *dir, const char *name, int namelen, 433 struct inode *inode, int visible) 434 { 435 struct cpu_key entry_key; 436 struct reiserfs_de_head *deh; 437 INITIALIZE_PATH(path); 438 struct reiserfs_dir_entry de; 439 DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1); 440 int gen_number; 441 442 /* 443 * 48 bytes now and we avoid kmalloc if we 444 * create file with short name 445 */ 446 char small_buf[32 + DEH_SIZE]; 447 448 char *buffer; 449 int buflen, paste_size; 450 int retval; 451 452 BUG_ON(!th->t_trans_id); 453 454 /* cannot allow items to be added into a busy deleted directory */ 455 if (!namelen) 456 return -EINVAL; 457 458 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize)) 459 return -ENAMETOOLONG; 460 461 /* each entry has unique key. compose it */ 462 make_cpu_key(&entry_key, dir, 463 get_third_component(dir->i_sb, name, namelen), 464 TYPE_DIRENTRY, 3); 465 466 /* get memory for composing the entry */ 467 buflen = DEH_SIZE + ROUND_UP(namelen); 468 if (buflen > sizeof(small_buf)) { 469 buffer = kmalloc(buflen, GFP_NOFS); 470 if (!buffer) 471 return -ENOMEM; 472 } else 473 buffer = small_buf; 474 475 paste_size = 476 (get_inode_sd_version(dir) == 477 STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen; 478 479 /* 480 * fill buffer : directory entry head, name[, dir objectid | , 481 * stat data | ,stat data, dir objectid ] 482 */ 483 deh = (struct reiserfs_de_head *)buffer; 484 deh->deh_location = 0; /* JDM Endian safe if 0 */ 485 put_deh_offset(deh, cpu_key_k_offset(&entry_key)); 486 deh->deh_state = 0; /* JDM Endian safe if 0 */ 487 /* put key (ino analog) to de */ 488 489 /* safe: k_dir_id is le */ 490 deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; 491 /* safe: k_objectid is le */ 492 deh->deh_objectid = INODE_PKEY(inode)->k_objectid; 493 494 /* copy name */ 495 memcpy((char *)(deh + 1), name, namelen); 496 /* padd by 0s to the 4 byte boundary */ 497 padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen); 498 499 /* 500 * entry is ready to be pasted into tree, set 'visibility' 501 * and 'stat data in entry' attributes 502 */ 503 mark_de_without_sd(deh); 504 visible ? mark_de_visible(deh) : mark_de_hidden(deh); 505 506 /* find the proper place for the new entry */ 507 memset(bit_string, 0, sizeof(bit_string)); 508 de.de_gen_number_bit_string = bit_string; 509 retval = reiserfs_find_entry(dir, name, namelen, &path, &de); 510 if (retval != NAME_NOT_FOUND) { 511 if (buffer != small_buf) 512 kfree(buffer); 513 pathrelse(&path); 514 515 if (retval == IO_ERROR) { 516 return -EIO; 517 } 518 519 if (retval != NAME_FOUND) { 520 reiserfs_error(dir->i_sb, "zam-7002", 521 "reiserfs_find_entry() returned " 522 "unexpected value (%d)", retval); 523 } 524 525 return -EEXIST; 526 } 527 528 gen_number = 529 find_first_zero_bit(bit_string, 530 MAX_GENERATION_NUMBER + 1); 531 if (gen_number > MAX_GENERATION_NUMBER) { 532 /* there is no free generation number */ 533 reiserfs_warning(dir->i_sb, "reiserfs-7010", 534 "Congratulations! we have got hash function " 535 "screwed up"); 536 if (buffer != small_buf) 537 kfree(buffer); 538 pathrelse(&path); 539 return -EBUSY; 540 } 541 /* adjust offset of directory enrty */ 542 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number)); 543 set_cpu_key_k_offset(&entry_key, deh_offset(deh)); 544 545 /* update max-hash-collisions counter in reiserfs_sb_info */ 546 PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number); 547 548 /* we need to re-search for the insertion point */ 549 if (gen_number != 0) { 550 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) != 551 NAME_NOT_FOUND) { 552 reiserfs_warning(dir->i_sb, "vs-7032", 553 "entry with this key (%K) already " 554 "exists", &entry_key); 555 556 if (buffer != small_buf) 557 kfree(buffer); 558 pathrelse(&path); 559 return -EBUSY; 560 } 561 } 562 563 /* perform the insertion of the entry that we have prepared */ 564 retval = 565 reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer, 566 paste_size); 567 if (buffer != small_buf) 568 kfree(buffer); 569 if (retval) { 570 reiserfs_check_path(&path); 571 return retval; 572 } 573 574 dir->i_size += paste_size; 575 dir->i_mtime = dir->i_ctime = current_time(dir); 576 if (!S_ISDIR(inode->i_mode) && visible) 577 /* reiserfs_mkdir or reiserfs_rename will do that by itself */ 578 reiserfs_update_sd(th, dir); 579 580 reiserfs_check_path(&path); 581 return 0; 582 } 583 584 /* 585 * quota utility function, call if you've had to abort after calling 586 * new_inode_init, and have not called reiserfs_new_inode yet. 587 * This should only be called on inodes that do not have stat data 588 * inserted into the tree yet. 589 */ 590 static int drop_new_inode(struct inode *inode) 591 { 592 dquot_drop(inode); 593 make_bad_inode(inode); 594 inode->i_flags |= S_NOQUOTA; 595 iput(inode); 596 return 0; 597 } 598 599 /* 600 * utility function that does setup for reiserfs_new_inode. 601 * dquot_initialize needs lots of credits so it's better to have it 602 * outside of a transaction, so we had to pull some bits of 603 * reiserfs_new_inode out into this func. 604 */ 605 static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode) 606 { 607 /* 608 * Make inode invalid - just in case we are going to drop it before 609 * the initialization happens 610 */ 611 INODE_PKEY(inode)->k_objectid = 0; 612 613 /* 614 * the quota init calls have to know who to charge the quota to, so 615 * we have to set uid and gid here 616 */ 617 inode_init_owner(&nop_mnt_idmap, inode, dir, mode); 618 return dquot_initialize(inode); 619 } 620 621 static int reiserfs_create(struct mnt_idmap *idmap, struct inode *dir, 622 struct dentry *dentry, umode_t mode, bool excl) 623 { 624 int retval; 625 struct inode *inode; 626 /* 627 * We need blocks for transaction + (user+group)*(quotas 628 * for new inode + update of quota for directory owner) 629 */ 630 int jbegin_count = 631 JOURNAL_PER_BALANCE_CNT * 2 + 632 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) + 633 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb)); 634 struct reiserfs_transaction_handle th; 635 struct reiserfs_security_handle security; 636 637 retval = dquot_initialize(dir); 638 if (retval) 639 return retval; 640 641 if (!(inode = new_inode(dir->i_sb))) { 642 return -ENOMEM; 643 } 644 retval = new_inode_init(inode, dir, mode); 645 if (retval) { 646 drop_new_inode(inode); 647 return retval; 648 } 649 650 jbegin_count += reiserfs_cache_default_acl(dir); 651 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security); 652 if (retval < 0) { 653 drop_new_inode(inode); 654 return retval; 655 } 656 jbegin_count += retval; 657 reiserfs_write_lock(dir->i_sb); 658 659 retval = journal_begin(&th, dir->i_sb, jbegin_count); 660 if (retval) { 661 drop_new_inode(inode); 662 goto out_failed; 663 } 664 665 retval = 666 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry, 667 inode, &security); 668 if (retval) 669 goto out_failed; 670 671 inode->i_op = &reiserfs_file_inode_operations; 672 inode->i_fop = &reiserfs_file_operations; 673 inode->i_mapping->a_ops = &reiserfs_address_space_operations; 674 675 retval = 676 reiserfs_add_entry(&th, dir, dentry->d_name.name, 677 dentry->d_name.len, inode, 1 /*visible */ ); 678 if (retval) { 679 int err; 680 drop_nlink(inode); 681 reiserfs_update_sd(&th, inode); 682 err = journal_end(&th); 683 if (err) 684 retval = err; 685 unlock_new_inode(inode); 686 iput(inode); 687 goto out_failed; 688 } 689 reiserfs_update_inode_transaction(inode); 690 reiserfs_update_inode_transaction(dir); 691 692 d_instantiate_new(dentry, inode); 693 retval = journal_end(&th); 694 695 out_failed: 696 reiserfs_write_unlock(dir->i_sb); 697 reiserfs_security_free(&security); 698 return retval; 699 } 700 701 static int reiserfs_mknod(struct mnt_idmap *idmap, struct inode *dir, 702 struct dentry *dentry, umode_t mode, dev_t rdev) 703 { 704 int retval; 705 struct inode *inode; 706 struct reiserfs_transaction_handle th; 707 struct reiserfs_security_handle security; 708 /* 709 * We need blocks for transaction + (user+group)*(quotas 710 * for new inode + update of quota for directory owner) 711 */ 712 int jbegin_count = 713 JOURNAL_PER_BALANCE_CNT * 3 + 714 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) + 715 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb)); 716 717 retval = dquot_initialize(dir); 718 if (retval) 719 return retval; 720 721 if (!(inode = new_inode(dir->i_sb))) { 722 return -ENOMEM; 723 } 724 retval = new_inode_init(inode, dir, mode); 725 if (retval) { 726 drop_new_inode(inode); 727 return retval; 728 } 729 730 jbegin_count += reiserfs_cache_default_acl(dir); 731 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security); 732 if (retval < 0) { 733 drop_new_inode(inode); 734 return retval; 735 } 736 jbegin_count += retval; 737 reiserfs_write_lock(dir->i_sb); 738 739 retval = journal_begin(&th, dir->i_sb, jbegin_count); 740 if (retval) { 741 drop_new_inode(inode); 742 goto out_failed; 743 } 744 745 retval = 746 reiserfs_new_inode(&th, dir, mode, NULL, 0 /*i_size */ , dentry, 747 inode, &security); 748 if (retval) { 749 goto out_failed; 750 } 751 752 inode->i_op = &reiserfs_special_inode_operations; 753 init_special_inode(inode, inode->i_mode, rdev); 754 755 /* FIXME: needed for block and char devices only */ 756 reiserfs_update_sd(&th, inode); 757 758 reiserfs_update_inode_transaction(inode); 759 reiserfs_update_inode_transaction(dir); 760 761 retval = 762 reiserfs_add_entry(&th, dir, dentry->d_name.name, 763 dentry->d_name.len, inode, 1 /*visible */ ); 764 if (retval) { 765 int err; 766 drop_nlink(inode); 767 reiserfs_update_sd(&th, inode); 768 err = journal_end(&th); 769 if (err) 770 retval = err; 771 unlock_new_inode(inode); 772 iput(inode); 773 goto out_failed; 774 } 775 776 d_instantiate_new(dentry, inode); 777 retval = journal_end(&th); 778 779 out_failed: 780 reiserfs_write_unlock(dir->i_sb); 781 reiserfs_security_free(&security); 782 return retval; 783 } 784 785 static int reiserfs_mkdir(struct mnt_idmap *idmap, struct inode *dir, 786 struct dentry *dentry, umode_t mode) 787 { 788 int retval; 789 struct inode *inode; 790 struct reiserfs_transaction_handle th; 791 struct reiserfs_security_handle security; 792 /* 793 * We need blocks for transaction + (user+group)*(quotas 794 * for new inode + update of quota for directory owner) 795 */ 796 int jbegin_count = 797 JOURNAL_PER_BALANCE_CNT * 3 + 798 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) + 799 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb)); 800 801 retval = dquot_initialize(dir); 802 if (retval) 803 return retval; 804 805 #ifdef DISPLACE_NEW_PACKING_LOCALITIES 806 /* 807 * set flag that new packing locality created and new blocks 808 * for the content of that directory are not displaced yet 809 */ 810 REISERFS_I(dir)->new_packing_locality = 1; 811 #endif 812 mode = S_IFDIR | mode; 813 if (!(inode = new_inode(dir->i_sb))) { 814 return -ENOMEM; 815 } 816 retval = new_inode_init(inode, dir, mode); 817 if (retval) { 818 drop_new_inode(inode); 819 return retval; 820 } 821 822 jbegin_count += reiserfs_cache_default_acl(dir); 823 retval = reiserfs_security_init(dir, inode, &dentry->d_name, &security); 824 if (retval < 0) { 825 drop_new_inode(inode); 826 return retval; 827 } 828 jbegin_count += retval; 829 reiserfs_write_lock(dir->i_sb); 830 831 retval = journal_begin(&th, dir->i_sb, jbegin_count); 832 if (retval) { 833 drop_new_inode(inode); 834 goto out_failed; 835 } 836 837 /* 838 * inc the link count now, so another writer doesn't overflow 839 * it while we sleep later on. 840 */ 841 INC_DIR_INODE_NLINK(dir) 842 843 retval = reiserfs_new_inode(&th, dir, mode, NULL /*symlink */, 844 old_format_only(dir->i_sb) ? 845 EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE, 846 dentry, inode, &security); 847 if (retval) { 848 DEC_DIR_INODE_NLINK(dir) 849 goto out_failed; 850 } 851 852 reiserfs_update_inode_transaction(inode); 853 reiserfs_update_inode_transaction(dir); 854 855 inode->i_op = &reiserfs_dir_inode_operations; 856 inode->i_fop = &reiserfs_dir_operations; 857 858 /* note, _this_ add_entry will not update dir's stat data */ 859 retval = 860 reiserfs_add_entry(&th, dir, dentry->d_name.name, 861 dentry->d_name.len, inode, 1 /*visible */ ); 862 if (retval) { 863 int err; 864 clear_nlink(inode); 865 DEC_DIR_INODE_NLINK(dir); 866 reiserfs_update_sd(&th, inode); 867 err = journal_end(&th); 868 if (err) 869 retval = err; 870 unlock_new_inode(inode); 871 iput(inode); 872 goto out_failed; 873 } 874 /* the above add_entry did not update dir's stat data */ 875 reiserfs_update_sd(&th, dir); 876 877 d_instantiate_new(dentry, inode); 878 retval = journal_end(&th); 879 out_failed: 880 reiserfs_write_unlock(dir->i_sb); 881 reiserfs_security_free(&security); 882 return retval; 883 } 884 885 static inline int reiserfs_empty_dir(struct inode *inode) 886 { 887 /* 888 * we can cheat because an old format dir cannot have 889 * EMPTY_DIR_SIZE, and a new format dir cannot have 890 * EMPTY_DIR_SIZE_V1. So, if the inode is either size, 891 * regardless of disk format version, the directory is empty. 892 */ 893 if (inode->i_size != EMPTY_DIR_SIZE && 894 inode->i_size != EMPTY_DIR_SIZE_V1) { 895 return 0; 896 } 897 return 1; 898 } 899 900 static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry) 901 { 902 int retval, err; 903 struct inode *inode; 904 struct reiserfs_transaction_handle th; 905 int jbegin_count; 906 INITIALIZE_PATH(path); 907 struct reiserfs_dir_entry de; 908 909 /* 910 * we will be doing 2 balancings and update 2 stat data, we 911 * change quotas of the owner of the directory and of the owner 912 * of the parent directory. The quota structure is possibly 913 * deleted only on last iput => outside of this transaction 914 */ 915 jbegin_count = 916 JOURNAL_PER_BALANCE_CNT * 2 + 2 + 917 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb); 918 919 retval = dquot_initialize(dir); 920 if (retval) 921 return retval; 922 923 reiserfs_write_lock(dir->i_sb); 924 retval = journal_begin(&th, dir->i_sb, jbegin_count); 925 if (retval) 926 goto out_rmdir; 927 928 de.de_gen_number_bit_string = NULL; 929 if ((retval = 930 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, 931 &path, &de)) == NAME_NOT_FOUND) { 932 retval = -ENOENT; 933 goto end_rmdir; 934 } else if (retval == IO_ERROR) { 935 retval = -EIO; 936 goto end_rmdir; 937 } 938 939 inode = d_inode(dentry); 940 941 reiserfs_update_inode_transaction(inode); 942 reiserfs_update_inode_transaction(dir); 943 944 if (de.de_objectid != inode->i_ino) { 945 /* 946 * FIXME: compare key of an object and a key found in the entry 947 */ 948 retval = -EIO; 949 goto end_rmdir; 950 } 951 if (!reiserfs_empty_dir(inode)) { 952 retval = -ENOTEMPTY; 953 goto end_rmdir; 954 } 955 956 /* cut entry from dir directory */ 957 retval = reiserfs_cut_from_item(&th, &path, &de.de_entry_key, 958 dir, NULL, /* page */ 959 0 /*new file size - not used here */ ); 960 if (retval < 0) 961 goto end_rmdir; 962 963 if (inode->i_nlink != 2 && inode->i_nlink != 1) 964 reiserfs_error(inode->i_sb, "reiserfs-7040", 965 "empty directory has nlink != 2 (%d)", 966 inode->i_nlink); 967 968 clear_nlink(inode); 969 inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(dir); 970 reiserfs_update_sd(&th, inode); 971 972 DEC_DIR_INODE_NLINK(dir) 973 dir->i_size -= (DEH_SIZE + de.de_entrylen); 974 reiserfs_update_sd(&th, dir); 975 976 /* prevent empty directory from getting lost */ 977 add_save_link(&th, inode, 0 /* not truncate */ ); 978 979 retval = journal_end(&th); 980 reiserfs_check_path(&path); 981 out_rmdir: 982 reiserfs_write_unlock(dir->i_sb); 983 return retval; 984 985 end_rmdir: 986 /* 987 * we must release path, because we did not call 988 * reiserfs_cut_from_item, or reiserfs_cut_from_item does not 989 * release path if operation was not complete 990 */ 991 pathrelse(&path); 992 err = journal_end(&th); 993 reiserfs_write_unlock(dir->i_sb); 994 return err ? err : retval; 995 } 996 997 static int reiserfs_unlink(struct inode *dir, struct dentry *dentry) 998 { 999 int retval, err; 1000 struct inode *inode; 1001 struct reiserfs_dir_entry de; 1002 INITIALIZE_PATH(path); 1003 struct reiserfs_transaction_handle th; 1004 int jbegin_count; 1005 unsigned long savelink; 1006 1007 retval = dquot_initialize(dir); 1008 if (retval) 1009 return retval; 1010 1011 inode = d_inode(dentry); 1012 1013 /* 1014 * in this transaction we can be doing at max two balancings and 1015 * update two stat datas, we change quotas of the owner of the 1016 * directory and of the owner of the parent directory. The quota 1017 * structure is possibly deleted only on iput => outside of 1018 * this transaction 1019 */ 1020 jbegin_count = 1021 JOURNAL_PER_BALANCE_CNT * 2 + 2 + 1022 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb); 1023 1024 reiserfs_write_lock(dir->i_sb); 1025 retval = journal_begin(&th, dir->i_sb, jbegin_count); 1026 if (retval) 1027 goto out_unlink; 1028 1029 de.de_gen_number_bit_string = NULL; 1030 if ((retval = 1031 reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len, 1032 &path, &de)) == NAME_NOT_FOUND) { 1033 retval = -ENOENT; 1034 goto end_unlink; 1035 } else if (retval == IO_ERROR) { 1036 retval = -EIO; 1037 goto end_unlink; 1038 } 1039 1040 reiserfs_update_inode_transaction(inode); 1041 reiserfs_update_inode_transaction(dir); 1042 1043 if (de.de_objectid != inode->i_ino) { 1044 /* 1045 * FIXME: compare key of an object and a key found in the entry 1046 */ 1047 retval = -EIO; 1048 goto end_unlink; 1049 } 1050 1051 if (!inode->i_nlink) { 1052 reiserfs_warning(inode->i_sb, "reiserfs-7042", 1053 "deleting nonexistent file (%lu), %d", 1054 inode->i_ino, inode->i_nlink); 1055 set_nlink(inode, 1); 1056 } 1057 1058 drop_nlink(inode); 1059 1060 /* 1061 * we schedule before doing the add_save_link call, save the link 1062 * count so we don't race 1063 */ 1064 savelink = inode->i_nlink; 1065 1066 retval = 1067 reiserfs_cut_from_item(&th, &path, &de.de_entry_key, dir, NULL, 1068 0); 1069 if (retval < 0) { 1070 inc_nlink(inode); 1071 goto end_unlink; 1072 } 1073 inode->i_ctime = current_time(inode); 1074 reiserfs_update_sd(&th, inode); 1075 1076 dir->i_size -= (de.de_entrylen + DEH_SIZE); 1077 dir->i_ctime = dir->i_mtime = current_time(dir); 1078 reiserfs_update_sd(&th, dir); 1079 1080 if (!savelink) 1081 /* prevent file from getting lost */ 1082 add_save_link(&th, inode, 0 /* not truncate */ ); 1083 1084 retval = journal_end(&th); 1085 reiserfs_check_path(&path); 1086 reiserfs_write_unlock(dir->i_sb); 1087 return retval; 1088 1089 end_unlink: 1090 pathrelse(&path); 1091 err = journal_end(&th); 1092 reiserfs_check_path(&path); 1093 if (err) 1094 retval = err; 1095 out_unlink: 1096 reiserfs_write_unlock(dir->i_sb); 1097 return retval; 1098 } 1099 1100 static int reiserfs_symlink(struct mnt_idmap *idmap, 1101 struct inode *parent_dir, struct dentry *dentry, 1102 const char *symname) 1103 { 1104 int retval; 1105 struct inode *inode; 1106 char *name; 1107 int item_len; 1108 struct reiserfs_transaction_handle th; 1109 struct reiserfs_security_handle security; 1110 int mode = S_IFLNK | S_IRWXUGO; 1111 /* 1112 * We need blocks for transaction + (user+group)*(quotas for 1113 * new inode + update of quota for directory owner) 1114 */ 1115 int jbegin_count = 1116 JOURNAL_PER_BALANCE_CNT * 3 + 1117 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) + 1118 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb)); 1119 1120 retval = dquot_initialize(parent_dir); 1121 if (retval) 1122 return retval; 1123 1124 if (!(inode = new_inode(parent_dir->i_sb))) { 1125 return -ENOMEM; 1126 } 1127 retval = new_inode_init(inode, parent_dir, mode); 1128 if (retval) { 1129 drop_new_inode(inode); 1130 return retval; 1131 } 1132 1133 retval = reiserfs_security_init(parent_dir, inode, &dentry->d_name, 1134 &security); 1135 if (retval < 0) { 1136 drop_new_inode(inode); 1137 return retval; 1138 } 1139 jbegin_count += retval; 1140 1141 reiserfs_write_lock(parent_dir->i_sb); 1142 item_len = ROUND_UP(strlen(symname)); 1143 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) { 1144 retval = -ENAMETOOLONG; 1145 drop_new_inode(inode); 1146 goto out_failed; 1147 } 1148 1149 name = kmalloc(item_len, GFP_NOFS); 1150 if (!name) { 1151 drop_new_inode(inode); 1152 retval = -ENOMEM; 1153 goto out_failed; 1154 } 1155 memcpy(name, symname, strlen(symname)); 1156 padd_item(name, item_len, strlen(symname)); 1157 1158 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count); 1159 if (retval) { 1160 drop_new_inode(inode); 1161 kfree(name); 1162 goto out_failed; 1163 } 1164 1165 retval = 1166 reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname), 1167 dentry, inode, &security); 1168 kfree(name); 1169 if (retval) { /* reiserfs_new_inode iputs for us */ 1170 goto out_failed; 1171 } 1172 1173 reiserfs_update_inode_transaction(inode); 1174 reiserfs_update_inode_transaction(parent_dir); 1175 1176 inode->i_op = &reiserfs_symlink_inode_operations; 1177 inode_nohighmem(inode); 1178 inode->i_mapping->a_ops = &reiserfs_address_space_operations; 1179 1180 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name, 1181 dentry->d_name.len, inode, 1 /*visible */ ); 1182 if (retval) { 1183 int err; 1184 drop_nlink(inode); 1185 reiserfs_update_sd(&th, inode); 1186 err = journal_end(&th); 1187 if (err) 1188 retval = err; 1189 unlock_new_inode(inode); 1190 iput(inode); 1191 goto out_failed; 1192 } 1193 1194 d_instantiate_new(dentry, inode); 1195 retval = journal_end(&th); 1196 out_failed: 1197 reiserfs_write_unlock(parent_dir->i_sb); 1198 reiserfs_security_free(&security); 1199 return retval; 1200 } 1201 1202 static int reiserfs_link(struct dentry *old_dentry, struct inode *dir, 1203 struct dentry *dentry) 1204 { 1205 int retval; 1206 struct inode *inode = d_inode(old_dentry); 1207 struct reiserfs_transaction_handle th; 1208 /* 1209 * We need blocks for transaction + update of quotas for 1210 * the owners of the directory 1211 */ 1212 int jbegin_count = 1213 JOURNAL_PER_BALANCE_CNT * 3 + 1214 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb); 1215 1216 retval = dquot_initialize(dir); 1217 if (retval) 1218 return retval; 1219 1220 reiserfs_write_lock(dir->i_sb); 1221 if (inode->i_nlink >= REISERFS_LINK_MAX) { 1222 /* FIXME: sd_nlink is 32 bit for new files */ 1223 reiserfs_write_unlock(dir->i_sb); 1224 return -EMLINK; 1225 } 1226 1227 /* inc before scheduling so reiserfs_unlink knows we are here */ 1228 inc_nlink(inode); 1229 1230 retval = journal_begin(&th, dir->i_sb, jbegin_count); 1231 if (retval) { 1232 drop_nlink(inode); 1233 reiserfs_write_unlock(dir->i_sb); 1234 return retval; 1235 } 1236 1237 /* create new entry */ 1238 retval = 1239 reiserfs_add_entry(&th, dir, dentry->d_name.name, 1240 dentry->d_name.len, inode, 1 /*visible */ ); 1241 1242 reiserfs_update_inode_transaction(inode); 1243 reiserfs_update_inode_transaction(dir); 1244 1245 if (retval) { 1246 int err; 1247 drop_nlink(inode); 1248 err = journal_end(&th); 1249 reiserfs_write_unlock(dir->i_sb); 1250 return err ? err : retval; 1251 } 1252 1253 inode->i_ctime = current_time(inode); 1254 reiserfs_update_sd(&th, inode); 1255 1256 ihold(inode); 1257 d_instantiate(dentry, inode); 1258 retval = journal_end(&th); 1259 reiserfs_write_unlock(dir->i_sb); 1260 return retval; 1261 } 1262 1263 /* de contains information pointing to an entry which */ 1264 static int de_still_valid(const char *name, int len, 1265 struct reiserfs_dir_entry *de) 1266 { 1267 struct reiserfs_dir_entry tmp = *de; 1268 1269 /* recalculate pointer to name and name length */ 1270 set_de_name_and_namelen(&tmp); 1271 /* FIXME: could check more */ 1272 if (tmp.de_namelen != len || memcmp(name, de->de_name, len)) 1273 return 0; 1274 return 1; 1275 } 1276 1277 static int entry_points_to_object(const char *name, int len, 1278 struct reiserfs_dir_entry *de, 1279 struct inode *inode) 1280 { 1281 if (!de_still_valid(name, len, de)) 1282 return 0; 1283 1284 if (inode) { 1285 if (!de_visible(de->de_deh + de->de_entry_num)) 1286 reiserfs_panic(inode->i_sb, "vs-7042", 1287 "entry must be visible"); 1288 return (de->de_objectid == inode->i_ino) ? 1 : 0; 1289 } 1290 1291 /* this must be added hidden entry */ 1292 if (de_visible(de->de_deh + de->de_entry_num)) 1293 reiserfs_panic(NULL, "vs-7043", "entry must be visible"); 1294 1295 return 1; 1296 } 1297 1298 /* sets key of objectid the entry has to point to */ 1299 static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de, 1300 struct reiserfs_key *key) 1301 { 1302 /* JDM These operations are endian safe - both are le */ 1303 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id; 1304 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid; 1305 } 1306 1307 /* 1308 * process, that is going to call fix_nodes/do_balance must hold only 1309 * one path. If it holds 2 or more, it can get into endless waiting in 1310 * get_empty_nodes or its clones 1311 */ 1312 static int reiserfs_rename(struct mnt_idmap *idmap, 1313 struct inode *old_dir, struct dentry *old_dentry, 1314 struct inode *new_dir, struct dentry *new_dentry, 1315 unsigned int flags) 1316 { 1317 int retval; 1318 INITIALIZE_PATH(old_entry_path); 1319 INITIALIZE_PATH(new_entry_path); 1320 INITIALIZE_PATH(dot_dot_entry_path); 1321 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih; 1322 struct reiserfs_dir_entry old_de, new_de, dot_dot_de; 1323 struct inode *old_inode, *new_dentry_inode; 1324 struct reiserfs_transaction_handle th; 1325 int jbegin_count; 1326 umode_t old_inode_mode; 1327 unsigned long savelink = 1; 1328 1329 if (flags & ~RENAME_NOREPLACE) 1330 return -EINVAL; 1331 1332 /* 1333 * three balancings: (1) old name removal, (2) new name insertion 1334 * and (3) maybe "save" link insertion 1335 * stat data updates: (1) old directory, 1336 * (2) new directory and (3) maybe old object stat data (when it is 1337 * directory) and (4) maybe stat data of object to which new entry 1338 * pointed initially and (5) maybe block containing ".." of 1339 * renamed directory 1340 * quota updates: two parent directories 1341 */ 1342 jbegin_count = 1343 JOURNAL_PER_BALANCE_CNT * 3 + 5 + 1344 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb); 1345 1346 retval = dquot_initialize(old_dir); 1347 if (retval) 1348 return retval; 1349 retval = dquot_initialize(new_dir); 1350 if (retval) 1351 return retval; 1352 1353 old_inode = d_inode(old_dentry); 1354 new_dentry_inode = d_inode(new_dentry); 1355 1356 /* 1357 * make sure that oldname still exists and points to an object we 1358 * are going to rename 1359 */ 1360 old_de.de_gen_number_bit_string = NULL; 1361 reiserfs_write_lock(old_dir->i_sb); 1362 retval = 1363 reiserfs_find_entry(old_dir, old_dentry->d_name.name, 1364 old_dentry->d_name.len, &old_entry_path, 1365 &old_de); 1366 pathrelse(&old_entry_path); 1367 if (retval == IO_ERROR) { 1368 reiserfs_write_unlock(old_dir->i_sb); 1369 return -EIO; 1370 } 1371 1372 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) { 1373 reiserfs_write_unlock(old_dir->i_sb); 1374 return -ENOENT; 1375 } 1376 1377 old_inode_mode = old_inode->i_mode; 1378 if (S_ISDIR(old_inode_mode)) { 1379 /* 1380 * make sure that directory being renamed has correct ".." 1381 * and that its new parent directory has not too many links 1382 * already 1383 */ 1384 if (new_dentry_inode) { 1385 if (!reiserfs_empty_dir(new_dentry_inode)) { 1386 reiserfs_write_unlock(old_dir->i_sb); 1387 return -ENOTEMPTY; 1388 } 1389 } 1390 1391 /* 1392 * directory is renamed, its parent directory will be changed, 1393 * so find ".." entry 1394 */ 1395 dot_dot_de.de_gen_number_bit_string = NULL; 1396 retval = 1397 reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path, 1398 &dot_dot_de); 1399 pathrelse(&dot_dot_entry_path); 1400 if (retval != NAME_FOUND) { 1401 reiserfs_write_unlock(old_dir->i_sb); 1402 return -EIO; 1403 } 1404 1405 /* inode number of .. must equal old_dir->i_ino */ 1406 if (dot_dot_de.de_objectid != old_dir->i_ino) { 1407 reiserfs_write_unlock(old_dir->i_sb); 1408 return -EIO; 1409 } 1410 } 1411 1412 retval = journal_begin(&th, old_dir->i_sb, jbegin_count); 1413 if (retval) { 1414 reiserfs_write_unlock(old_dir->i_sb); 1415 return retval; 1416 } 1417 1418 /* add new entry (or find the existing one) */ 1419 retval = 1420 reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name, 1421 new_dentry->d_name.len, old_inode, 0); 1422 if (retval == -EEXIST) { 1423 if (!new_dentry_inode) { 1424 reiserfs_panic(old_dir->i_sb, "vs-7050", 1425 "new entry is found, new inode == 0"); 1426 } 1427 } else if (retval) { 1428 int err = journal_end(&th); 1429 reiserfs_write_unlock(old_dir->i_sb); 1430 return err ? err : retval; 1431 } 1432 1433 reiserfs_update_inode_transaction(old_dir); 1434 reiserfs_update_inode_transaction(new_dir); 1435 1436 /* 1437 * this makes it so an fsync on an open fd for the old name will 1438 * commit the rename operation 1439 */ 1440 reiserfs_update_inode_transaction(old_inode); 1441 1442 if (new_dentry_inode) 1443 reiserfs_update_inode_transaction(new_dentry_inode); 1444 1445 while (1) { 1446 /* 1447 * look for old name using corresponding entry key 1448 * (found by reiserfs_find_entry) 1449 */ 1450 if ((retval = 1451 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key, 1452 &old_entry_path, 1453 &old_de)) != NAME_FOUND) { 1454 pathrelse(&old_entry_path); 1455 journal_end(&th); 1456 reiserfs_write_unlock(old_dir->i_sb); 1457 return -EIO; 1458 } 1459 1460 copy_item_head(&old_entry_ih, tp_item_head(&old_entry_path)); 1461 1462 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1); 1463 1464 /* look for new name by reiserfs_find_entry */ 1465 new_de.de_gen_number_bit_string = NULL; 1466 retval = 1467 reiserfs_find_entry(new_dir, new_dentry->d_name.name, 1468 new_dentry->d_name.len, &new_entry_path, 1469 &new_de); 1470 /* 1471 * reiserfs_add_entry should not return IO_ERROR, 1472 * because it is called with essentially same parameters from 1473 * reiserfs_add_entry above, and we'll catch any i/o errors 1474 * before we get here. 1475 */ 1476 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) { 1477 pathrelse(&new_entry_path); 1478 pathrelse(&old_entry_path); 1479 journal_end(&th); 1480 reiserfs_write_unlock(old_dir->i_sb); 1481 return -EIO; 1482 } 1483 1484 copy_item_head(&new_entry_ih, tp_item_head(&new_entry_path)); 1485 1486 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1); 1487 1488 if (S_ISDIR(old_inode->i_mode)) { 1489 if ((retval = 1490 search_by_entry_key(new_dir->i_sb, 1491 &dot_dot_de.de_entry_key, 1492 &dot_dot_entry_path, 1493 &dot_dot_de)) != NAME_FOUND) { 1494 pathrelse(&dot_dot_entry_path); 1495 pathrelse(&new_entry_path); 1496 pathrelse(&old_entry_path); 1497 journal_end(&th); 1498 reiserfs_write_unlock(old_dir->i_sb); 1499 return -EIO; 1500 } 1501 copy_item_head(&dot_dot_ih, 1502 tp_item_head(&dot_dot_entry_path)); 1503 /* node containing ".." gets into transaction */ 1504 reiserfs_prepare_for_journal(old_inode->i_sb, 1505 dot_dot_de.de_bh, 1); 1506 } 1507 /* 1508 * we should check seals here, not do 1509 * this stuff, yes? Then, having 1510 * gathered everything into RAM we 1511 * should lock the buffers, yes? -Hans 1512 */ 1513 /* 1514 * probably. our rename needs to hold more 1515 * than one path at once. The seals would 1516 * have to be written to deal with multi-path 1517 * issues -chris 1518 */ 1519 /* 1520 * sanity checking before doing the rename - avoid races many 1521 * of the above checks could have scheduled. We have to be 1522 * sure our items haven't been shifted by another process. 1523 */ 1524 if (item_moved(&new_entry_ih, &new_entry_path) || 1525 !entry_points_to_object(new_dentry->d_name.name, 1526 new_dentry->d_name.len, 1527 &new_de, new_dentry_inode) || 1528 item_moved(&old_entry_ih, &old_entry_path) || 1529 !entry_points_to_object(old_dentry->d_name.name, 1530 old_dentry->d_name.len, 1531 &old_de, old_inode)) { 1532 reiserfs_restore_prepared_buffer(old_inode->i_sb, 1533 new_de.de_bh); 1534 reiserfs_restore_prepared_buffer(old_inode->i_sb, 1535 old_de.de_bh); 1536 if (S_ISDIR(old_inode_mode)) 1537 reiserfs_restore_prepared_buffer(old_inode-> 1538 i_sb, 1539 dot_dot_de. 1540 de_bh); 1541 continue; 1542 } 1543 if (S_ISDIR(old_inode_mode)) { 1544 if (item_moved(&dot_dot_ih, &dot_dot_entry_path) || 1545 !entry_points_to_object("..", 2, &dot_dot_de, 1546 old_dir)) { 1547 reiserfs_restore_prepared_buffer(old_inode-> 1548 i_sb, 1549 old_de.de_bh); 1550 reiserfs_restore_prepared_buffer(old_inode-> 1551 i_sb, 1552 new_de.de_bh); 1553 reiserfs_restore_prepared_buffer(old_inode-> 1554 i_sb, 1555 dot_dot_de. 1556 de_bh); 1557 continue; 1558 } 1559 } 1560 1561 RFALSE(S_ISDIR(old_inode_mode) && 1562 !buffer_journal_prepared(dot_dot_de.de_bh), ""); 1563 1564 break; 1565 } 1566 1567 /* 1568 * ok, all the changes can be done in one fell swoop when we 1569 * have claimed all the buffers needed. 1570 */ 1571 1572 mark_de_visible(new_de.de_deh + new_de.de_entry_num); 1573 set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode)); 1574 journal_mark_dirty(&th, new_de.de_bh); 1575 1576 mark_de_hidden(old_de.de_deh + old_de.de_entry_num); 1577 journal_mark_dirty(&th, old_de.de_bh); 1578 /* 1579 * thanks to Alex Adriaanse <alex_a@caltech.edu> for patch 1580 * which adds ctime update of renamed object 1581 */ 1582 simple_rename_timestamp(old_dir, old_dentry, new_dir, new_dentry); 1583 1584 if (new_dentry_inode) { 1585 /* adjust link number of the victim */ 1586 if (S_ISDIR(new_dentry_inode->i_mode)) { 1587 clear_nlink(new_dentry_inode); 1588 } else { 1589 drop_nlink(new_dentry_inode); 1590 } 1591 savelink = new_dentry_inode->i_nlink; 1592 } 1593 1594 if (S_ISDIR(old_inode_mode)) { 1595 /* adjust ".." of renamed directory */ 1596 set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir)); 1597 journal_mark_dirty(&th, dot_dot_de.de_bh); 1598 1599 /* 1600 * there (in new_dir) was no directory, so it got new link 1601 * (".." of renamed directory) 1602 */ 1603 if (!new_dentry_inode) 1604 INC_DIR_INODE_NLINK(new_dir); 1605 1606 /* old directory lost one link - ".. " of renamed directory */ 1607 DEC_DIR_INODE_NLINK(old_dir); 1608 } 1609 /* 1610 * looks like in 2.3.99pre3 brelse is atomic. 1611 * so we can use pathrelse 1612 */ 1613 pathrelse(&new_entry_path); 1614 pathrelse(&dot_dot_entry_path); 1615 1616 /* 1617 * FIXME: this reiserfs_cut_from_item's return value may screw up 1618 * anybody, but it will panic if will not be able to find the 1619 * entry. This needs one more clean up 1620 */ 1621 if (reiserfs_cut_from_item 1622 (&th, &old_entry_path, &old_de.de_entry_key, old_dir, NULL, 1623 0) < 0) 1624 reiserfs_error(old_dir->i_sb, "vs-7060", 1625 "couldn't not cut old name. Fsck later?"); 1626 1627 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen; 1628 1629 reiserfs_update_sd(&th, old_dir); 1630 reiserfs_update_sd(&th, new_dir); 1631 reiserfs_update_sd(&th, old_inode); 1632 1633 if (new_dentry_inode) { 1634 if (savelink == 0) 1635 add_save_link(&th, new_dentry_inode, 1636 0 /* not truncate */ ); 1637 reiserfs_update_sd(&th, new_dentry_inode); 1638 } 1639 1640 retval = journal_end(&th); 1641 reiserfs_write_unlock(old_dir->i_sb); 1642 return retval; 1643 } 1644 1645 static const struct inode_operations reiserfs_priv_dir_inode_operations = { 1646 .create = reiserfs_create, 1647 .lookup = reiserfs_lookup, 1648 .link = reiserfs_link, 1649 .unlink = reiserfs_unlink, 1650 .symlink = reiserfs_symlink, 1651 .mkdir = reiserfs_mkdir, 1652 .rmdir = reiserfs_rmdir, 1653 .mknod = reiserfs_mknod, 1654 .rename = reiserfs_rename, 1655 .setattr = reiserfs_setattr, 1656 .permission = reiserfs_permission, 1657 .fileattr_get = reiserfs_fileattr_get, 1658 .fileattr_set = reiserfs_fileattr_set, 1659 }; 1660 1661 static const struct inode_operations reiserfs_priv_symlink_inode_operations = { 1662 .get_link = page_get_link, 1663 .setattr = reiserfs_setattr, 1664 .permission = reiserfs_permission, 1665 }; 1666 1667 static const struct inode_operations reiserfs_priv_special_inode_operations = { 1668 .setattr = reiserfs_setattr, 1669 .permission = reiserfs_permission, 1670 }; 1671 1672 void reiserfs_init_priv_inode(struct inode *inode) 1673 { 1674 inode->i_flags |= S_PRIVATE; 1675 inode->i_opflags &= ~IOP_XATTR; 1676 1677 if (S_ISREG(inode->i_mode)) 1678 inode->i_op = &reiserfs_priv_file_inode_operations; 1679 else if (S_ISDIR(inode->i_mode)) 1680 inode->i_op = &reiserfs_priv_dir_inode_operations; 1681 else if (S_ISLNK(inode->i_mode)) 1682 inode->i_op = &reiserfs_priv_symlink_inode_operations; 1683 else 1684 inode->i_op = &reiserfs_priv_special_inode_operations; 1685 } 1686 1687 /* directories can handle most operations... */ 1688 const struct inode_operations reiserfs_dir_inode_operations = { 1689 .create = reiserfs_create, 1690 .lookup = reiserfs_lookup, 1691 .link = reiserfs_link, 1692 .unlink = reiserfs_unlink, 1693 .symlink = reiserfs_symlink, 1694 .mkdir = reiserfs_mkdir, 1695 .rmdir = reiserfs_rmdir, 1696 .mknod = reiserfs_mknod, 1697 .rename = reiserfs_rename, 1698 .setattr = reiserfs_setattr, 1699 .listxattr = reiserfs_listxattr, 1700 .permission = reiserfs_permission, 1701 .get_inode_acl = reiserfs_get_acl, 1702 .set_acl = reiserfs_set_acl, 1703 .fileattr_get = reiserfs_fileattr_get, 1704 .fileattr_set = reiserfs_fileattr_set, 1705 }; 1706 1707 /* 1708 * symlink operations.. same as page_symlink_inode_operations, with xattr 1709 * stuff added 1710 */ 1711 const struct inode_operations reiserfs_symlink_inode_operations = { 1712 .get_link = page_get_link, 1713 .setattr = reiserfs_setattr, 1714 .listxattr = reiserfs_listxattr, 1715 .permission = reiserfs_permission, 1716 }; 1717 1718 /* 1719 * special file operations.. just xattr/acl stuff 1720 */ 1721 const struct inode_operations reiserfs_special_inode_operations = { 1722 .setattr = reiserfs_setattr, 1723 .listxattr = reiserfs_listxattr, 1724 .permission = reiserfs_permission, 1725 .get_inode_acl = reiserfs_get_acl, 1726 .set_acl = reiserfs_set_acl, 1727 }; 1728