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