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