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