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