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