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