1/* 2 * Copyright 2000-2002 by Hans Reiser, licensing governed by reiserfs/README 3 */ 4 5#include <linux/config.h> 6#include <linux/sched.h> 7#include <linux/bitops.h> 8#include <linux/reiserfs_fs.h> 9#include <linux/smp_lock.h> 10 11#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; } 12#define DEC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) i->i_nlink--; 13 14// directory item contains array of entry headers. This performs 15// binary search through that array 16static int bin_search_in_dir_item (struct reiserfs_dir_entry * de, loff_t off) 17{ 18 struct item_head * ih = de->de_ih; 19 struct reiserfs_de_head * deh = de->de_deh; 20 int rbound, lbound, j; 21 22 lbound = 0; 23 rbound = I_ENTRY_COUNT (ih) - 1; 24 25 for (j = (rbound + lbound) / 2; lbound <= rbound; j = (rbound + lbound) / 2) { 26 if (off < deh_offset (deh + j)) { 27 rbound = j - 1; 28 continue; 29 } 30 if (off > deh_offset (deh + j)) { 31 lbound = j + 1; 32 continue; 33 } 34 // this is not name found, but matched third key component 35 de->de_entry_num = j; 36 return NAME_FOUND; 37 } 38 39 de->de_entry_num = lbound; 40 return NAME_NOT_FOUND; 41} 42 43 44// comment? maybe something like set de to point to what the path points to? 45static inline void set_de_item_location (struct reiserfs_dir_entry * de, struct path * path) 46{ 47 de->de_bh = get_last_bh (path); 48 de->de_ih = get_ih (path); 49 de->de_deh = B_I_DEH (de->de_bh, de->de_ih); 50 de->de_item_num = PATH_LAST_POSITION (path); 51} 52 53 54// de_bh, de_ih, de_deh (points to first element of array), de_item_num is set 55inline void set_de_name_and_namelen (struct reiserfs_dir_entry * de) 56{ 57 struct reiserfs_de_head * deh = de->de_deh + de->de_entry_num; 58 59 if (de->de_entry_num >= ih_entry_count (de->de_ih)) 60 BUG (); 61 62 de->de_entrylen = entry_length (de->de_bh, de->de_ih, de->de_entry_num); 63 de->de_namelen = de->de_entrylen - (de_with_sd (deh) ? SD_SIZE : 0); 64 de->de_name = B_I_PITEM (de->de_bh, de->de_ih) + deh_location(deh); 65 if (de->de_name[de->de_namelen - 1] == 0) 66 de->de_namelen = strlen (de->de_name); 67} 68 69 70// what entry points to 71static inline void set_de_object_key (struct reiserfs_dir_entry * de) 72{ 73 if (de->de_entry_num >= ih_entry_count (de->de_ih)) 74 BUG (); 75 de->de_dir_id = deh_dir_id( &(de->de_deh[de->de_entry_num])); 76 de->de_objectid = deh_objectid( &(de->de_deh[de->de_entry_num])); 77} 78 79 80static inline void store_de_entry_key (struct reiserfs_dir_entry * de) 81{ 82 struct reiserfs_de_head * deh = de->de_deh + de->de_entry_num; 83 84 if (de->de_entry_num >= ih_entry_count (de->de_ih)) 85 BUG (); 86 87 /* store key of the found entry */ 88 de->de_entry_key.version = KEY_FORMAT_3_5; 89 de->de_entry_key.on_disk_key.k_dir_id = le32_to_cpu (de->de_ih->ih_key.k_dir_id); 90 de->de_entry_key.on_disk_key.k_objectid = le32_to_cpu (de->de_ih->ih_key.k_objectid); 91 set_cpu_key_k_offset (&(de->de_entry_key), deh_offset (deh)); 92 set_cpu_key_k_type (&(de->de_entry_key), TYPE_DIRENTRY); 93} 94 95 96/* We assign a key to each directory item, and place multiple entries 97in a single directory item. A directory item has a key equal to the 98key of the first directory entry in it. 99 100This function first calls search_by_key, then, if item whose first 101entry matches is not found it looks for the entry inside directory 102item found by search_by_key. Fills the path to the entry, and to the 103entry position in the item 104 105*/ 106 107/* The function is NOT SCHEDULE-SAFE! */ 108int search_by_entry_key (struct super_block * sb, const struct cpu_key * key, 109 struct path * path, struct reiserfs_dir_entry * de) 110{ 111 int retval; 112 113 retval = search_item (sb, key, path); 114 switch (retval) { 115 case ITEM_NOT_FOUND: 116 if (!PATH_LAST_POSITION (path)) { 117 reiserfs_warning ("vs-7000: search_by_entry_key: search_by_key returned item position == 0"); 118 pathrelse(path) ; 119 return IO_ERROR ; 120 } 121 PATH_LAST_POSITION (path) --; 122 123 case ITEM_FOUND: 124 break; 125 126 case IO_ERROR: 127 return retval; 128 129 default: 130 pathrelse (path); 131 reiserfs_warning ("vs-7002: search_by_entry_key: no path to here"); 132 return IO_ERROR; 133 } 134 135 set_de_item_location (de, path); 136 137#ifdef CONFIG_REISERFS_CHECK 138 if (!is_direntry_le_ih (de->de_ih) || 139 COMP_SHORT_KEYS (&(de->de_ih->ih_key), key)) { 140 print_block (de->de_bh, 0, -1, -1); 141 reiserfs_panic (sb, "vs-7005: search_by_entry_key: found item %h is not directory item or " 142 "does not belong to the same directory as key %K", de->de_ih, key); 143 } 144#endif /* CONFIG_REISERFS_CHECK */ 145 146 /* binary search in directory item by third componen t of the 147 key. sets de->de_entry_num of de */ 148 retval = bin_search_in_dir_item (de, cpu_key_k_offset (key)); 149 path->pos_in_item = de->de_entry_num; 150 if (retval != NAME_NOT_FOUND) { 151 // ugly, but rename needs de_bh, de_deh, de_name, de_namelen, de_objectid set 152 set_de_name_and_namelen (de); 153 set_de_object_key (de); 154 } 155 return retval; 156} 157 158 159 160/* Keyed 32-bit hash function using TEA in a Davis-Meyer function */ 161 162/* The third component is hashed, and you can choose from more than 163 one hash function. Per directory hashes are not yet implemented 164 but are thought about. This function should be moved to hashes.c 165 Jedi, please do so. -Hans */ 166 167static __u32 get_third_component (struct super_block * s, 168 const char * name, int len) 169{ 170 __u32 res; 171 172 if (!len || (len == 1 && name[0] == '.')) 173 return DOT_OFFSET; 174 if (len == 2 && name[0] == '.' && name[1] == '.') 175 return DOT_DOT_OFFSET; 176 177 res = s->u.reiserfs_sb.s_hash_function (name, len); 178 179 // take bits from 7-th to 30-th including both bounds 180 res = GET_HASH_VALUE(res); 181 if (res == 0) 182 // needed to have no names before "." and ".." those have hash 183 // value == 0 and generation conters 1 and 2 accordingly 184 res = 128; 185 return res + MAX_GENERATION_NUMBER; 186} 187 188 189static int reiserfs_match (struct reiserfs_dir_entry * de, 190 const char * name, int namelen) 191{ 192 int retval = NAME_NOT_FOUND; 193 194 if ((namelen == de->de_namelen) && 195 !memcmp(de->de_name, name, de->de_namelen)) 196 retval = (de_visible (de->de_deh + de->de_entry_num) ? NAME_FOUND : NAME_FOUND_INVISIBLE); 197 198 return retval; 199} 200 201 202/* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already */ 203 204 /* used when hash collisions exist */ 205 206 207static int linear_search_in_dir_item (struct cpu_key * key, struct reiserfs_dir_entry * de, 208 const char * name, int namelen) 209{ 210 struct reiserfs_de_head * deh = de->de_deh; 211 int retval; 212 int i; 213 214 i = de->de_entry_num; 215 216 if (i == I_ENTRY_COUNT (de->de_ih) || 217 GET_HASH_VALUE (deh_offset (deh + i)) != GET_HASH_VALUE (cpu_key_k_offset (key))) { 218 i --; 219 } 220 221 RFALSE( de->de_deh != B_I_DEH (de->de_bh, de->de_ih), 222 "vs-7010: array of entry headers not found"); 223 224 deh += i; 225 226 for (; i >= 0; i --, deh --) { 227 if (GET_HASH_VALUE (deh_offset (deh)) != 228 GET_HASH_VALUE (cpu_key_k_offset (key))) { 229 // hash value does not match, no need to check whole name 230 return NAME_NOT_FOUND; 231 } 232 233 /* mark, that this generation number is used */ 234 if (de->de_gen_number_bit_string) 235 set_bit (GET_GENERATION_NUMBER (deh_offset (deh)), (unsigned long *)de->de_gen_number_bit_string); 236 237 // calculate pointer to name and namelen 238 de->de_entry_num = i; 239 set_de_name_and_namelen (de); 240 241 if ((retval = reiserfs_match (de, name, namelen)) != NAME_NOT_FOUND) { 242 // de's de_name, de_namelen, de_recordlen are set. Fill the rest: 243 244 // key of pointed object 245 set_de_object_key (de); 246 247 store_de_entry_key (de); 248 249 // retval can be NAME_FOUND or NAME_FOUND_INVISIBLE 250 return retval; 251 } 252 } 253 254 if (GET_GENERATION_NUMBER (le_ih_k_offset (de->de_ih)) == 0) 255 /* we have reached left most entry in the node. In common we 256 have to go to the left neighbor, but if generation counter 257 is 0 already, we know for sure, that there is no name with 258 the same hash value */ 259 // FIXME: this work correctly only because hash value can not 260 // be 0. Btw, in case of Yura's hash it is probably possible, 261 // so, this is a bug 262 return NAME_NOT_FOUND; 263 264 RFALSE( de->de_item_num, 265 "vs-7015: two diritems of the same directory in one node?"); 266 267 return GOTO_PREVIOUS_ITEM; 268} 269 270 271// may return NAME_FOUND, NAME_FOUND_INVISIBLE, NAME_NOT_FOUND 272// FIXME: should add something like IOERROR 273static int reiserfs_find_entry (struct inode * dir, const char * name, int namelen, 274 struct path * path_to_entry, struct reiserfs_dir_entry * de) 275{ 276 struct cpu_key key_to_search; 277 int retval; 278 279 280 if (namelen > REISERFS_MAX_NAME (dir->i_sb->s_blocksize)) 281 return NAME_NOT_FOUND; 282 283 /* we will search for this key in the tree */ 284 make_cpu_key (&key_to_search, dir, 285 get_third_component (dir->i_sb, name, namelen), TYPE_DIRENTRY, 3); 286 287 while (1) { 288 retval = search_by_entry_key (dir->i_sb, &key_to_search, path_to_entry, de); 289 if (retval == IO_ERROR) { 290 reiserfs_warning ("zam-7001: io error in %s\n", __FUNCTION__); 291 return IO_ERROR; 292 } 293 294 /* compare names for all entries having given hash value */ 295 retval = linear_search_in_dir_item (&key_to_search, de, name, namelen); 296 if (retval != GOTO_PREVIOUS_ITEM) { 297 /* there is no need to scan directory anymore. Given entry found or does not exist */ 298 path_to_entry->pos_in_item = de->de_entry_num; 299 return retval; 300 } 301 302 /* there is left neighboring item of this directory and given entry can be there */ 303 set_cpu_key_k_offset (&key_to_search, le_ih_k_offset (de->de_ih) - 1); 304 pathrelse (path_to_entry); 305 306 } /* while (1) */ 307} 308 309 310static struct dentry * reiserfs_lookup (struct inode * dir, struct dentry * dentry) 311{ 312 int retval; 313 struct inode * inode = NULL; 314 struct reiserfs_dir_entry de; 315 INITIALIZE_PATH (path_to_entry); 316 317 reiserfs_check_lock_depth("lookup") ; 318 319 if (REISERFS_MAX_NAME (dir->i_sb->s_blocksize) < dentry->d_name.len) 320 return ERR_PTR(-ENAMETOOLONG); 321 322 de.de_gen_number_bit_string = 0; 323 retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path_to_entry, &de); 324 pathrelse (&path_to_entry); 325 if (retval == NAME_FOUND) { 326 inode = reiserfs_iget (dir->i_sb, (struct cpu_key *)&(de.de_dir_id)); 327 if (!inode || IS_ERR(inode)) { 328 return ERR_PTR(-EACCES); 329 } 330 } 331 if ( retval == IO_ERROR ) { 332 return ERR_PTR(-EIO); 333 } 334 335 d_add(dentry, inode); 336 return NULL; 337} 338 339/* add entry to the directory (entry can be hidden). 340 341insert definition of when hidden directories are used here -Hans 342 343 Does not mark dir inode dirty, do it after successesfull call to it */ 344 345static int reiserfs_add_entry (struct reiserfs_transaction_handle *th, struct inode * dir, 346 const char * name, int namelen, struct inode * inode, 347 int visible) 348{ 349 struct cpu_key entry_key; 350 struct reiserfs_de_head * deh; 351 INITIALIZE_PATH (path); 352 struct reiserfs_dir_entry de; 353 int bit_string [MAX_GENERATION_NUMBER / (sizeof(int) * 8) + 1]; 354 int gen_number; 355 char small_buf[32+DEH_SIZE] ; /* 48 bytes now and we avoid kmalloc 356 if we create file with short name */ 357 char * buffer; 358 int buflen, paste_size; 359 int retval; 360 361 362 /* cannot allow items to be added into a busy deleted directory */ 363 if (!namelen) 364 return -EINVAL; 365 366 if (namelen > REISERFS_MAX_NAME (dir->i_sb->s_blocksize)) 367 return -ENAMETOOLONG; 368 369 /* each entry has unique key. compose it */ 370 make_cpu_key (&entry_key, dir, 371 get_third_component (dir->i_sb, name, namelen), TYPE_DIRENTRY, 3); 372 373 /* get memory for composing the entry */ 374 buflen = DEH_SIZE + ROUND_UP (namelen); 375 if (buflen > sizeof (small_buf)) { 376 buffer = reiserfs_kmalloc (buflen, GFP_NOFS, dir->i_sb); 377 if (buffer == 0) 378 return -ENOMEM; 379 } else 380 buffer = small_buf; 381 382 paste_size = (get_inode_sd_version (dir) == STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen; 383 384 /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */ 385 deh = (struct reiserfs_de_head *)buffer; 386 deh->deh_location = 0; /* JDM Endian safe if 0 */ 387 put_deh_offset( deh, cpu_key_k_offset( &entry_key ) ); 388 deh->deh_state = 0; /* JDM Endian safe if 0 */ 389 /* put key (ino analog) to de */ 390 deh->deh_dir_id = INODE_PKEY (inode)->k_dir_id; /* safe: k_dir_id is le */ 391 deh->deh_objectid = INODE_PKEY (inode)->k_objectid; /* safe: k_objectid is le */ 392 393 /* copy name */ 394 memcpy ((char *)(deh + 1), name, namelen); 395 /* padd by 0s to the 4 byte boundary */ 396 padd_item ((char *)(deh + 1), ROUND_UP (namelen), namelen); 397 398 /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */ 399 mark_de_without_sd (deh); 400 visible ? mark_de_visible (deh) : mark_de_hidden (deh); 401 402 /* find the proper place for the new entry */ 403 memset (bit_string, 0, sizeof (bit_string)); 404 de.de_gen_number_bit_string = (char *)bit_string; 405 retval = reiserfs_find_entry (dir, name, namelen, &path, &de); 406 if( retval != NAME_NOT_FOUND ) { 407 if (buffer != small_buf) 408 reiserfs_kfree (buffer, buflen, dir->i_sb); 409 pathrelse (&path); 410 411 if ( retval == IO_ERROR ) { 412 return -EIO; 413 } 414 415 if (retval != NAME_FOUND) { 416 reiserfs_warning ("zam-7002:%s: \"reiserfs_find_entry\" has returned" 417 " unexpected value (%d)\n", __FUNCTION__, retval); 418 } 419 420 return -EEXIST; 421 } 422 423 gen_number = find_first_zero_bit ((unsigned long *)bit_string, MAX_GENERATION_NUMBER + 1); 424 if (gen_number > MAX_GENERATION_NUMBER) { 425 /* there is no free generation number */ 426 reiserfs_warning ("reiserfs_add_entry: Congratulations! we have got hash function screwed up\n"); 427 if (buffer != small_buf) 428 reiserfs_kfree (buffer, buflen, dir->i_sb); 429 pathrelse (&path); 430/* 431 * Trivial changes by Alan Cox to remove EHASHCOLLISION for compatibility 432 * 433 * Trivial Changes: 434 * Rights granted to Hans Reiser to redistribute under other terms providing 435 * he accepts all liability including but not limited to patent, fitness 436 * for purpose, and direct or indirect claims arising from failure to perform. 437 * 438 * NO WARRANTY 439 * This is one of two lines that this fix consist of. 440 */ 441 return -EBUSY; 442 /* I think it was better to have an error code with a name that says 443 what it means, but I choose not to fight over it. Persons porting to 444 other operating systems should consider keeping it as it was 445 (return -EHASHCOLLISION;). -Hans */ 446 } 447 /* adjust offset of directory enrty */ 448 put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number)); 449 set_cpu_key_k_offset (&entry_key, deh_offset(deh)); 450 451 /* update max-hash-collisions counter in reiserfs_sb_info */ 452 PROC_INFO_MAX( th -> t_super, max_hash_collisions, gen_number ); 453 454 if (gen_number != 0) { /* we need to re-search for the insertion point */ 455 if (search_by_entry_key (dir->i_sb, &entry_key, &path, &de) != NAME_NOT_FOUND) { 456 reiserfs_warning ("vs-7032: reiserfs_add_entry: " 457 "entry with this key (%K) already exists\n", &entry_key); 458 459 if (buffer != small_buf) 460 reiserfs_kfree (buffer, buflen, dir->i_sb); 461 pathrelse (&path); 462 /* Following line is 2nd line touched by Alan Cox' trivial fix */ 463 return -EBUSY; 464 /* I think it was better to have an error code with a name that says 465 what it means, but I choose not to fight over it. Persons porting to 466 other operating systems should consider keeping it as it was 467 (return -EHASHCOLLISION;). -Hans */ 468 } 469 } 470 471 /* perform the insertion of the entry that we have prepared */ 472 retval = reiserfs_paste_into_item (th, &path, &entry_key, buffer, paste_size); 473 if (buffer != small_buf) 474 reiserfs_kfree (buffer, buflen, dir->i_sb); 475 if (retval) { 476 reiserfs_check_path(&path) ; 477 return retval; 478 } 479 480 dir->i_size += paste_size; 481 dir->i_blocks = ((dir->i_size + 511) >> 9); 482 dir->i_mtime = dir->i_ctime = CURRENT_TIME; 483 if (!S_ISDIR (inode->i_mode) && visible) 484 // reiserfs_mkdir or reiserfs_rename will do that by itself 485 reiserfs_update_sd (th, dir); 486 487 reiserfs_check_path(&path) ; 488 return 0; 489} 490 491 492static int reiserfs_create (struct inode * dir, struct dentry *dentry, int mode) 493{ 494 int retval; 495 struct inode * inode; 496 int windex ; 497 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 ; 498 struct reiserfs_transaction_handle th ; 499 500 501 if (!(inode = new_inode(dir->i_sb))) { 502 return -ENOMEM ; 503 } 504 journal_begin(&th, dir->i_sb, jbegin_count) ; 505 th.t_caller = "create" ; 506 windex = push_journal_writer("reiserfs_create") ; 507 inode = reiserfs_new_inode (&th, dir, mode, 0, 0/*i_size*/, dentry, inode, &retval); 508 if (!inode) { 509 pop_journal_writer(windex) ; 510 journal_end(&th, dir->i_sb, jbegin_count) ; 511 return retval; 512 } 513 514 inode->i_op = &reiserfs_file_inode_operations; 515 inode->i_fop = &reiserfs_file_operations; 516 inode->i_mapping->a_ops = &reiserfs_address_space_operations ; 517 518 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, 519 inode, 1/*visible*/); 520 if (retval) { 521 inode->i_nlink--; 522 reiserfs_update_sd (&th, inode); 523 pop_journal_writer(windex) ; 524 // FIXME: should we put iput here and have stat data deleted 525 // in the same transactioin 526 journal_end(&th, dir->i_sb, jbegin_count) ; 527 iput (inode); 528 return retval; 529 } 530 reiserfs_update_inode_transaction(inode) ; 531 reiserfs_update_inode_transaction(dir) ; 532 533 d_instantiate(dentry, inode); 534 pop_journal_writer(windex) ; 535 journal_end(&th, dir->i_sb, jbegin_count) ; 536 return 0; 537} 538 539 540static int reiserfs_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev) 541{ 542 int retval; 543 struct inode * inode; 544 int windex ; 545 struct reiserfs_transaction_handle th ; 546 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3; 547 548 if (!(inode = new_inode(dir->i_sb))) { 549 return -ENOMEM ; 550 } 551 journal_begin(&th, dir->i_sb, jbegin_count) ; 552 windex = push_journal_writer("reiserfs_mknod") ; 553 554 inode = reiserfs_new_inode (&th, dir, mode, 0, 0/*i_size*/, dentry, inode, &retval); 555 if (!inode) { 556 pop_journal_writer(windex) ; 557 journal_end(&th, dir->i_sb, jbegin_count) ; 558 return retval; 559 } 560 561 init_special_inode(inode, mode, rdev) ; 562 563 //FIXME: needed for block and char devices only 564 reiserfs_update_sd (&th, inode); 565 566 reiserfs_update_inode_transaction(inode) ; 567 reiserfs_update_inode_transaction(dir) ; 568 569 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, 570 inode, 1/*visible*/); 571 if (retval) { 572 inode->i_nlink--; 573 reiserfs_update_sd (&th, inode); 574 pop_journal_writer(windex) ; 575 journal_end(&th, dir->i_sb, jbegin_count) ; 576 iput (inode); 577 return retval; 578 } 579 580 d_instantiate(dentry, inode); 581 pop_journal_writer(windex) ; 582 journal_end(&th, dir->i_sb, jbegin_count) ; 583 return 0; 584} 585 586 587static int reiserfs_mkdir (struct inode * dir, struct dentry *dentry, int mode) 588{ 589 int retval; 590 struct inode * inode; 591 int windex ; 592 struct reiserfs_transaction_handle th ; 593 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3; 594 595 if (!(inode = new_inode(dir->i_sb))) { 596 return -ENOMEM ; 597 } 598 journal_begin(&th, dir->i_sb, jbegin_count) ; 599 windex = push_journal_writer("reiserfs_mkdir") ; 600 601 /* inc the link count now, so another writer doesn't overflow it while 602 ** we sleep later on. 603 */ 604 INC_DIR_INODE_NLINK(dir) 605 606#ifdef DISPLACE_NEW_PACKING_LOCALITIES 607 /* set flag that new packing locality created and new blocks for the content * of that directory are not displaced yet */ 608 dir->u.reiserfs_i.new_packing_locality = 1; 609#endif 610 mode = S_IFDIR | mode; 611 inode = reiserfs_new_inode (&th, dir, mode, 0/*symlink*/, 612 old_format_only (dir->i_sb) ? EMPTY_DIR_SIZE_V1 : EMPTY_DIR_SIZE, 613 dentry, inode, &retval); 614 if (!inode) { 615 pop_journal_writer(windex) ; 616 dir->i_nlink-- ; 617 journal_end(&th, dir->i_sb, jbegin_count) ; 618 return retval; 619 } 620 reiserfs_update_inode_transaction(inode) ; 621 reiserfs_update_inode_transaction(dir) ; 622 623 inode->i_op = &reiserfs_dir_inode_operations; 624 inode->i_fop = &reiserfs_dir_operations; 625 626 // note, _this_ add_entry will not update dir's stat data 627 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, 628 inode, 1/*visible*/); 629 if (retval) { 630 inode->i_nlink = 0; 631 DEC_DIR_INODE_NLINK(dir); 632 reiserfs_update_sd (&th, inode); 633 pop_journal_writer(windex) ; 634 journal_end(&th, dir->i_sb, jbegin_count) ; 635 iput (inode); 636 return retval; 637 } 638 639 // the above add_entry did not update dir's stat data 640 reiserfs_update_sd (&th, dir); 641 642 d_instantiate(dentry, inode); 643 pop_journal_writer(windex) ; 644 journal_end(&th, dir->i_sb, jbegin_count) ; 645 return 0; 646} 647 648static inline int reiserfs_empty_dir(struct inode *inode) { 649 /* we can cheat because an old format dir cannot have 650 ** EMPTY_DIR_SIZE, and a new format dir cannot have 651 ** EMPTY_DIR_SIZE_V1. So, if the inode is either size, 652 ** regardless of disk format version, the directory is empty. 653 */ 654 if (inode->i_size != EMPTY_DIR_SIZE && 655 inode->i_size != EMPTY_DIR_SIZE_V1) { 656 return 0 ; 657 } 658 return 1 ; 659} 660 661 662static int reiserfs_rmdir (struct inode * dir, struct dentry *dentry) 663{ 664 int retval; 665 struct inode * inode; 666 int windex ; 667 struct reiserfs_transaction_handle th ; 668 int jbegin_count; 669 INITIALIZE_PATH (path); 670 struct reiserfs_dir_entry de; 671 672 673 /* we will be doing 2 balancings and update 2 stat data */ 674 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2; 675 676 journal_begin(&th, dir->i_sb, jbegin_count) ; 677 windex = push_journal_writer("reiserfs_rmdir") ; 678 679 de.de_gen_number_bit_string = 0; 680 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) { 681 retval = -ENOENT; 682 goto end_rmdir; 683 } else if ( retval == IO_ERROR) { 684 retval = -EIO; 685 goto end_rmdir; 686 } 687 688 inode = dentry->d_inode; 689 690 reiserfs_update_inode_transaction(inode) ; 691 reiserfs_update_inode_transaction(dir) ; 692 693 if (de.de_objectid != inode->i_ino) { 694 // FIXME: compare key of an object and a key found in the 695 // entry 696 retval = -EIO; 697 goto end_rmdir; 698 } 699 if (!reiserfs_empty_dir(inode)) { 700 retval = -ENOTEMPTY; 701 goto end_rmdir; 702 } 703 704 /* cut entry from dir directory */ 705 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir, 706 NULL, /* page */ 707 0/*new file size - not used here*/); 708 if (retval < 0) 709 goto end_rmdir; 710 711 if ( inode->i_nlink != 2 && inode->i_nlink != 1 ) 712 printk ("reiserfs_rmdir: empty directory has nlink != 2 (%d)\n", inode->i_nlink); 713 714 inode->i_nlink = 0; 715 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 716 reiserfs_update_sd (&th, inode); 717 718 DEC_DIR_INODE_NLINK(dir) 719 dir->i_size -= (DEH_SIZE + de.de_entrylen); 720 dir->i_blocks = ((dir->i_size + 511) >> 9); 721 reiserfs_update_sd (&th, dir); 722 723 /* prevent empty directory from getting lost */ 724 add_save_link (&th, inode, 0/* not truncate */); 725 726 pop_journal_writer(windex) ; 727 journal_end(&th, dir->i_sb, jbegin_count) ; 728 reiserfs_check_path(&path) ; 729 return 0; 730 731 end_rmdir: 732 /* we must release path, because we did not call 733 reiserfs_cut_from_item, or reiserfs_cut_from_item does not 734 release path if operation was not complete */ 735 pathrelse (&path); 736 pop_journal_writer(windex) ; 737 journal_end(&th, dir->i_sb, jbegin_count) ; 738 return retval; 739} 740 741 742static int reiserfs_unlink (struct inode * dir, struct dentry *dentry) 743{ 744 int retval; 745 struct inode * inode; 746 struct reiserfs_dir_entry de; 747 INITIALIZE_PATH (path); 748 int windex ; 749 struct reiserfs_transaction_handle th ; 750 int jbegin_count; 751 752 inode = dentry->d_inode; 753 754 /* in this transaction we can be doing at max two balancings and update 755 two stat datas */ 756 jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 + 2; 757 758 journal_begin(&th, dir->i_sb, jbegin_count) ; 759 windex = push_journal_writer("reiserfs_unlink") ; 760 761 de.de_gen_number_bit_string = 0; 762 if ( (retval = reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de)) == NAME_NOT_FOUND) { 763 retval = -ENOENT; 764 goto end_unlink; 765 } else if (retval == IO_ERROR) { 766 retval = -EIO; 767 goto end_unlink; 768 } 769 770 reiserfs_update_inode_transaction(inode) ; 771 reiserfs_update_inode_transaction(dir) ; 772 773 if (de.de_objectid != inode->i_ino) { 774 // FIXME: compare key of an object and a key found in the 775 // entry 776 retval = -EIO; 777 goto end_unlink; 778 } 779 780 if (!inode->i_nlink) { 781 printk("reiserfs_unlink: deleting nonexistent file (%s:%lu), %d\n", 782 kdevname(inode->i_dev), inode->i_ino, inode->i_nlink); 783 inode->i_nlink = 1; 784 } 785 786 retval = reiserfs_cut_from_item (&th, &path, &(de.de_entry_key), dir, NULL, 0); 787 if (retval < 0) 788 goto end_unlink; 789 790 inode->i_nlink--; 791 inode->i_ctime = CURRENT_TIME; 792 reiserfs_update_sd (&th, inode); 793 794 dir->i_size -= (de.de_entrylen + DEH_SIZE); 795 dir->i_blocks = ((dir->i_size + 511) >> 9); 796 dir->i_ctime = dir->i_mtime = CURRENT_TIME; 797 reiserfs_update_sd (&th, dir); 798 799 if (!inode->i_nlink) 800 /* prevent file from getting lost */ 801 add_save_link (&th, inode, 0/* not truncate */); 802 803 pop_journal_writer(windex) ; 804 journal_end(&th, dir->i_sb, jbegin_count) ; 805 reiserfs_check_path(&path) ; 806 return 0; 807 808 end_unlink: 809 pathrelse (&path); 810 pop_journal_writer(windex) ; 811 journal_end(&th, dir->i_sb, jbegin_count) ; 812 reiserfs_check_path(&path) ; 813 return retval; 814} 815 816 817static int reiserfs_symlink (struct inode * parent_dir, struct dentry * dentry, const char * symname) 818{ 819 int retval; 820 struct inode * inode; 821 char * name; 822 int item_len; 823 int windex ; 824 struct reiserfs_transaction_handle th ; 825 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3; 826 827 828 if (!(inode = new_inode(parent_dir->i_sb))) { 829 return -ENOMEM ; 830 } 831 832 item_len = ROUND_UP (strlen (symname)); 833 if (item_len > MAX_DIRECT_ITEM_LEN (parent_dir->i_sb->s_blocksize)) { 834 iput(inode) ; 835 return -ENAMETOOLONG; 836 } 837 838 name = reiserfs_kmalloc (item_len, GFP_NOFS, parent_dir->i_sb); 839 if (!name) { 840 iput(inode) ; 841 return -ENOMEM; 842 } 843 memcpy (name, symname, strlen (symname)); 844 padd_item (name, item_len, strlen (symname)); 845 846 journal_begin(&th, parent_dir->i_sb, jbegin_count) ; 847 windex = push_journal_writer("reiserfs_symlink") ; 848 849 inode = reiserfs_new_inode (&th, parent_dir, S_IFLNK | S_IRWXUGO, name, strlen (symname), dentry, 850 inode, &retval); 851 reiserfs_kfree (name, item_len, parent_dir->i_sb); 852 if (inode == 0) { /* reiserfs_new_inode iputs for us */ 853 pop_journal_writer(windex) ; 854 journal_end(&th, parent_dir->i_sb, jbegin_count) ; 855 return retval; 856 } 857 858 reiserfs_update_inode_transaction(inode) ; 859 reiserfs_update_inode_transaction(parent_dir) ; 860 861 inode->i_op = &page_symlink_inode_operations; 862 inode->i_mapping->a_ops = &reiserfs_address_space_operations; 863 864 // must be sure this inode is written with this transaction 865 // 866 //reiserfs_update_sd (&th, inode, READ_BLOCKS); 867 868 retval = reiserfs_add_entry (&th, parent_dir, dentry->d_name.name, dentry->d_name.len, 869 inode, 1/*visible*/); 870 if (retval) { 871 inode->i_nlink--; 872 reiserfs_update_sd (&th, inode); 873 pop_journal_writer(windex) ; 874 journal_end(&th, parent_dir->i_sb, jbegin_count) ; 875 iput (inode); 876 return retval; 877 } 878 879 d_instantiate(dentry, inode); 880 pop_journal_writer(windex) ; 881 journal_end(&th, parent_dir->i_sb, jbegin_count) ; 882 return 0; 883} 884 885 886static int reiserfs_link (struct dentry * old_dentry, struct inode * dir, struct dentry * dentry) 887{ 888 int retval; 889 struct inode *inode = old_dentry->d_inode; 890 int windex ; 891 struct reiserfs_transaction_handle th ; 892 int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3; 893 time_t ctime; 894 895 896 if (S_ISDIR(inode->i_mode)) 897 return -EPERM; 898 899 if (inode->i_nlink >= REISERFS_LINK_MAX) { 900 //FIXME: sd_nlink is 32 bit for new files 901 return -EMLINK; 902 } 903 904 journal_begin(&th, dir->i_sb, jbegin_count) ; 905 windex = push_journal_writer("reiserfs_link") ; 906 907 /* create new entry */ 908 retval = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, 909 inode, 1/*visible*/); 910 911 reiserfs_update_inode_transaction(inode) ; 912 reiserfs_update_inode_transaction(dir) ; 913 914 if (retval) { 915 pop_journal_writer(windex) ; 916 journal_end(&th, dir->i_sb, jbegin_count) ; 917 return retval; 918 } 919 920 inode->i_nlink++; 921 ctime = CURRENT_TIME; 922 inode->i_ctime = ctime; 923 reiserfs_update_sd (&th, inode); 924 925 atomic_inc(&inode->i_count) ; 926 d_instantiate(dentry, inode); 927 pop_journal_writer(windex) ; 928 journal_end(&th, dir->i_sb, jbegin_count) ; 929 return 0; 930} 931 932 933// de contains information pointing to an entry which 934static int de_still_valid (const char * name, int len, struct reiserfs_dir_entry * de) 935{ 936 struct reiserfs_dir_entry tmp = *de; 937 938 // recalculate pointer to name and name length 939 set_de_name_and_namelen (&tmp); 940 // FIXME: could check more 941 if (tmp.de_namelen != len || memcmp (name, de->de_name, len)) 942 return 0; 943 return 1; 944} 945 946 947static int entry_points_to_object (const char * name, int len, struct reiserfs_dir_entry * de, struct inode * inode) 948{ 949 if (!de_still_valid (name, len, de)) 950 return 0; 951 952 if (inode) { 953 if (!de_visible (de->de_deh + de->de_entry_num)) 954 reiserfs_panic (0, "vs-7042: entry_points_to_object: entry must be visible"); 955 return (de->de_objectid == inode->i_ino) ? 1 : 0; 956 } 957 958 /* this must be added hidden entry */ 959 if (de_visible (de->de_deh + de->de_entry_num)) 960 reiserfs_panic (0, "vs-7043: entry_points_to_object: entry must be visible"); 961 962 return 1; 963} 964 965 966/* sets key of objectid the entry has to point to */ 967static void set_ino_in_dir_entry (struct reiserfs_dir_entry * de, struct key * key) 968{ 969 /* JDM These operations are endian safe - both are le */ 970 de->de_deh[de->de_entry_num].deh_dir_id = key->k_dir_id; 971 de->de_deh[de->de_entry_num].deh_objectid = key->k_objectid; 972} 973 974 975/* 976 * process, that is going to call fix_nodes/do_balance must hold only 977 * one path. If it holds 2 or more, it can get into endless waiting in 978 * get_empty_nodes or its clones 979 */ 980static int reiserfs_rename (struct inode * old_dir, struct dentry *old_dentry, 981 struct inode * new_dir, struct dentry *new_dentry) 982{ 983 int retval; 984 INITIALIZE_PATH (old_entry_path); 985 INITIALIZE_PATH (new_entry_path); 986 INITIALIZE_PATH (dot_dot_entry_path); 987 struct item_head new_entry_ih, old_entry_ih, dot_dot_ih ; 988 struct reiserfs_dir_entry old_de, new_de, dot_dot_de; 989 struct inode * old_inode, * new_dentry_inode; 990 int windex ; 991 struct reiserfs_transaction_handle th ; 992 int jbegin_count ; 993 umode_t old_inode_mode; 994 time_t ctime; 995 996 997 /* two balancings: old name removal, new name insertion or "save" link, 998 stat data updates: old directory and new directory and maybe block 999 containing ".." of renamed directory */ 1000 jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 3; 1001 1002 old_inode = old_dentry->d_inode; 1003 new_dentry_inode = new_dentry->d_inode; 1004 1005 // make sure, that oldname still exists and points to an object we 1006 // are going to rename 1007 old_de.de_gen_number_bit_string = 0; 1008 retval = reiserfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len, 1009 &old_entry_path, &old_de); 1010 pathrelse (&old_entry_path); 1011 if (retval == IO_ERROR) 1012 return -EIO; 1013 1014 if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) { 1015 return -ENOENT; 1016 } 1017 1018 old_inode_mode = old_inode->i_mode; 1019 if (S_ISDIR(old_inode_mode)) { 1020 // make sure, that directory being renamed has correct ".." 1021 // and that its new parent directory has not too many links 1022 // already 1023 1024 if (new_dentry_inode) { 1025 if (!reiserfs_empty_dir(new_dentry_inode)) { 1026 return -ENOTEMPTY; 1027 } 1028 } 1029 1030 /* directory is renamed, its parent directory will be changed, 1031 ** so find ".." entry 1032 */ 1033 dot_dot_de.de_gen_number_bit_string = 0; 1034 retval = reiserfs_find_entry (old_inode, "..", 2, &dot_dot_entry_path, &dot_dot_de); 1035 pathrelse (&dot_dot_entry_path); 1036 if (retval != NAME_FOUND) 1037 return -EIO; 1038 1039 /* inode number of .. must equal old_dir->i_ino */ 1040 if (dot_dot_de.de_objectid != old_dir->i_ino) 1041 return -EIO; 1042 } 1043 1044 journal_begin(&th, old_dir->i_sb, jbegin_count) ; 1045 windex = push_journal_writer("reiserfs_rename") ; 1046 1047 /* add new entry (or find the existing one) */ 1048 retval = reiserfs_add_entry (&th, new_dir, new_dentry->d_name.name, new_dentry->d_name.len, 1049 old_inode, 0); 1050 if (retval == -EEXIST) { 1051 if (!new_dentry_inode) { 1052 reiserfs_panic (old_dir->i_sb, 1053 "vs-7050: new entry is found, new inode == 0\n"); 1054 } 1055 } else if (retval) { 1056 pop_journal_writer(windex) ; 1057 journal_end(&th, old_dir->i_sb, jbegin_count) ; 1058 return retval; 1059 } 1060 1061 reiserfs_update_inode_transaction(old_dir) ; 1062 reiserfs_update_inode_transaction(new_dir) ; 1063 1064 /* this makes it so an fsync on an open fd for the old name will 1065 ** commit the rename operation 1066 */ 1067 reiserfs_update_inode_transaction(old_inode) ; 1068 1069 if (new_dentry_inode) 1070 reiserfs_update_inode_transaction(new_dentry_inode) ; 1071 1072 while (1) { 1073 // look for old name using corresponding entry key (found by reiserfs_find_entry) 1074 if (search_by_entry_key (new_dir->i_sb, &old_de.de_entry_key, &old_entry_path, &old_de) != NAME_FOUND) 1075 BUG (); 1076 1077 copy_item_head(&old_entry_ih, get_ih(&old_entry_path)) ; 1078 1079 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1) ; 1080 1081 // look for new name by reiserfs_find_entry 1082 new_de.de_gen_number_bit_string = 0; 1083 retval = reiserfs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len, 1084 &new_entry_path, &new_de); 1085 // reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from 1086 // reiserfs_add_entry above, and we'll catch any i/o errors before we get here. 1087 if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) 1088 BUG (); 1089 1090 copy_item_head(&new_entry_ih, get_ih(&new_entry_path)) ; 1091 1092 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1) ; 1093 1094 if (S_ISDIR(old_inode->i_mode)) { 1095 if (search_by_entry_key (new_dir->i_sb, &dot_dot_de.de_entry_key, &dot_dot_entry_path, &dot_dot_de) != NAME_FOUND) 1096 BUG (); 1097 copy_item_head(&dot_dot_ih, get_ih(&dot_dot_entry_path)) ; 1098 // node containing ".." gets into transaction 1099 reiserfs_prepare_for_journal(old_inode->i_sb, dot_dot_de.de_bh, 1) ; 1100 } 1101 /* we should check seals here, not do 1102 this stuff, yes? Then, having 1103 gathered everything into RAM we 1104 should lock the buffers, yes? -Hans */ 1105 /* probably. our rename needs to hold more 1106 ** than one path at once. The seals would 1107 ** have to be written to deal with multi-path 1108 ** issues -chris 1109 */ 1110 /* sanity checking before doing the rename - avoid races many 1111 ** of the above checks could have scheduled. We have to be 1112 ** sure our items haven't been shifted by another process. 1113 */ 1114 if (item_moved(&new_entry_ih, &new_entry_path) || 1115 !entry_points_to_object(new_dentry->d_name.name, 1116 new_dentry->d_name.len, 1117 &new_de, new_dentry_inode) || 1118 item_moved(&old_entry_ih, &old_entry_path) || 1119 !entry_points_to_object (old_dentry->d_name.name, 1120 old_dentry->d_name.len, 1121 &old_de, old_inode)) { 1122 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh); 1123 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh); 1124 if (S_ISDIR(old_inode_mode)) 1125 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh); 1126 continue; 1127 } 1128 if (S_ISDIR(old_inode_mode)) { 1129 if ( item_moved(&dot_dot_ih, &dot_dot_entry_path) || 1130 !entry_points_to_object ( "..", 2, &dot_dot_de, old_dir) ) { 1131 reiserfs_restore_prepared_buffer (old_inode->i_sb, old_de.de_bh); 1132 reiserfs_restore_prepared_buffer (old_inode->i_sb, new_de.de_bh); 1133 reiserfs_restore_prepared_buffer (old_inode->i_sb, dot_dot_de.de_bh); 1134 continue; 1135 } 1136 } 1137 1138 1139 RFALSE( S_ISDIR(old_inode_mode) && 1140 !reiserfs_buffer_prepared(dot_dot_de.de_bh), "" ); 1141 1142 break; 1143 } 1144 1145 /* ok, all the changes can be done in one fell swoop when we 1146 have claimed all the buffers needed.*/ 1147 1148 mark_de_visible (new_de.de_deh + new_de.de_entry_num); 1149 set_ino_in_dir_entry (&new_de, INODE_PKEY (old_inode)); 1150 journal_mark_dirty (&th, old_dir->i_sb, new_de.de_bh); 1151 1152 mark_de_hidden (old_de.de_deh + old_de.de_entry_num); 1153 journal_mark_dirty (&th, old_dir->i_sb, old_de.de_bh); 1154 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME; 1155 new_dir->i_ctime = new_dir->i_mtime = CURRENT_TIME; 1156 1157 if (new_dentry_inode) { 1158 // adjust link number of the victim 1159 if (S_ISDIR(new_dentry_inode->i_mode)) { 1160 new_dentry_inode->i_nlink = 0; 1161 } else { 1162 new_dentry_inode->i_nlink--; 1163 } 1164 ctime = CURRENT_TIME; 1165 new_dentry_inode->i_ctime = ctime; 1166 } 1167 1168 if (S_ISDIR(old_inode_mode)) { 1169 // adjust ".." of renamed directory 1170 set_ino_in_dir_entry (&dot_dot_de, INODE_PKEY (new_dir)); 1171 journal_mark_dirty (&th, new_dir->i_sb, dot_dot_de.de_bh); 1172 1173 if (!new_dentry_inode) 1174 /* there (in new_dir) was no directory, so it got new link 1175 (".." of renamed directory) */ 1176 INC_DIR_INODE_NLINK(new_dir); 1177 1178 /* old directory lost one link - ".. " of renamed directory */ 1179 DEC_DIR_INODE_NLINK(old_dir); 1180 } 1181 1182 // looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse 1183 pathrelse (&new_entry_path); 1184 pathrelse (&dot_dot_entry_path); 1185 1186 // FIXME: this reiserfs_cut_from_item's return value may screw up 1187 // anybody, but it will panic if will not be able to find the 1188 // entry. This needs one more clean up 1189 if (reiserfs_cut_from_item (&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL, 0) < 0) 1190 reiserfs_warning ("vs-7060: reiserfs_rename: couldn't not cut old name. Fsck later?\n"); 1191 1192 old_dir->i_size -= DEH_SIZE + old_de.de_entrylen; 1193 old_dir->i_blocks = ((old_dir->i_size + 511) >> 9); 1194 1195 reiserfs_update_sd (&th, old_dir); 1196 reiserfs_update_sd (&th, new_dir); 1197 1198 if (new_dentry_inode) { 1199 if (new_dentry_inode->i_nlink == 0) 1200 add_save_link (&th, new_dentry_inode, 0/* not truncate */); 1201 reiserfs_update_sd (&th, new_dentry_inode); 1202 } 1203 1204 pop_journal_writer(windex) ; 1205 journal_end(&th, old_dir->i_sb, jbegin_count) ; 1206 return 0; 1207} 1208 1209 1210 1211/* 1212 * directories can handle most operations... 1213 */ 1214struct inode_operations reiserfs_dir_inode_operations = { 1215 //&reiserfs_dir_operations, /* default_file_ops */ 1216 create: reiserfs_create, 1217 lookup: reiserfs_lookup, 1218 link: reiserfs_link, 1219 unlink: reiserfs_unlink, 1220 symlink: reiserfs_symlink, 1221 mkdir: reiserfs_mkdir, 1222 rmdir: reiserfs_rmdir, 1223 mknod: reiserfs_mknod, 1224 rename: reiserfs_rename, 1225}; 1226 1227