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