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