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