1/* 2 * fs/logfs/dir.c - directory-related code 3 * 4 * As should be obvious for Linux kernel code, license is GPLv2 5 * 6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org> 7 */ 8#include "logfs.h" 9#include <linux/slab.h> 10 11/* 12 * Atomic dir operations 13 * 14 * Directory operations are by default not atomic. Dentries and Inodes are 15 * created/removed/altered in separate operations. Therefore we need to do 16 * a small amount of journaling. 17 * 18 * Create, link, mkdir, mknod and symlink all share the same function to do 19 * the work: __logfs_create. This function works in two atomic steps: 20 * 1. allocate inode (remember in journal) 21 * 2. allocate dentry (clear journal) 22 * 23 * As we can only get interrupted between the two, when the inode we just 24 * created is simply stored in the anchor. On next mount, if we were 25 * interrupted, we delete the inode. From a users point of view the 26 * operation never happened. 27 * 28 * Unlink and rmdir also share the same function: unlink. Again, this 29 * function works in two atomic steps 30 * 1. remove dentry (remember inode in journal) 31 * 2. unlink inode (clear journal) 32 * 33 * And again, on the next mount, if we were interrupted, we delete the inode. 34 * From a users point of view the operation succeeded. 35 * 36 * Rename is the real pain to deal with, harder than all the other methods 37 * combined. Depending on the circumstances we can run into three cases. 38 * A "target rename" where the target dentry already existed, a "local 39 * rename" where both parent directories are identical or a "cross-directory 40 * rename" in the remaining case. 41 * 42 * Local rename is atomic, as the old dentry is simply rewritten with a new 43 * name. 44 * 45 * Cross-directory rename works in two steps, similar to __logfs_create and 46 * logfs_unlink: 47 * 1. Write new dentry (remember old dentry in journal) 48 * 2. Remove old dentry (clear journal) 49 * 50 * Here we remember a dentry instead of an inode. On next mount, if we were 51 * interrupted, we delete the dentry. From a users point of view, the 52 * operation succeeded. 53 * 54 * Target rename works in three atomic steps: 55 * 1. Attach old inode to new dentry (remember old dentry and new inode) 56 * 2. Remove old dentry (still remember the new inode) 57 * 3. Remove victim inode 58 * 59 * Here we remember both an inode an a dentry. If we get interrupted 60 * between steps 1 and 2, we delete both the dentry and the inode. If 61 * we get interrupted between steps 2 and 3, we delete just the inode. 62 * In either case, the remaining objects are deleted on next mount. From 63 * a users point of view, the operation succeeded. 64 */ 65 66static int write_dir(struct inode *dir, struct logfs_disk_dentry *dd, 67 loff_t pos) 68{ 69 return logfs_inode_write(dir, dd, sizeof(*dd), pos, WF_LOCK, NULL); 70} 71 72static int write_inode(struct inode *inode) 73{ 74 return __logfs_write_inode(inode, WF_LOCK); 75} 76 77static s64 dir_seek_data(struct inode *inode, s64 pos) 78{ 79 s64 new_pos = logfs_seek_data(inode, pos); 80 81 return max(pos, new_pos - 1); 82} 83 84static int beyond_eof(struct inode *inode, loff_t bix) 85{ 86 loff_t pos = bix << inode->i_sb->s_blocksize_bits; 87 return pos >= i_size_read(inode); 88} 89 90/* 91 * Prime value was chosen to be roughly 256 + 26. r5 hash uses 11, 92 * so short names (len <= 9) don't even occupy the complete 32bit name 93 * space. A prime >256 ensures short names quickly spread the 32bit 94 * name space. Add about 26 for the estimated amount of information 95 * of each character and pick a prime nearby, preferrably a bit-sparse 96 * one. 97 */ 98static u32 hash_32(const char *s, int len, u32 seed) 99{ 100 u32 hash = seed; 101 int i; 102 103 for (i = 0; i < len; i++) 104 hash = hash * 293 + s[i]; 105 return hash; 106} 107 108/* 109 * We have to satisfy several conflicting requirements here. Small 110 * directories should stay fairly compact and not require too many 111 * indirect blocks. The number of possible locations for a given hash 112 * should be small to make lookup() fast. And we should try hard not 113 * to overflow the 32bit name space or nfs and 32bit host systems will 114 * be unhappy. 115 * 116 * So we use the following scheme. First we reduce the hash to 0..15 117 * and try a direct block. If that is occupied we reduce the hash to 118 * 16..255 and try an indirect block. Same for 2x and 3x indirect 119 * blocks. Lastly we reduce the hash to 0x800_0000 .. 0xffff_ffff, 120 * but use buckets containing eight entries instead of a single one. 121 * 122 * Using 16 entries should allow for a reasonable amount of hash 123 * collisions, so the 32bit name space can be packed fairly tight 124 * before overflowing. Oh and currently we don't overflow but return 125 * and error. 126 * 127 * How likely are collisions? Doing the appropriate math is beyond me 128 * and the Bronstein textbook. But running a test program to brute 129 * force collisions for a couple of days showed that on average the 130 * first collision occurs after 598M entries, with 290M being the 131 * smallest result. Obviously 21 entries could already cause a 132 * collision if all entries are carefully chosen. 133 */ 134static pgoff_t hash_index(u32 hash, int round) 135{ 136 u32 i0_blocks = I0_BLOCKS; 137 u32 i1_blocks = I1_BLOCKS; 138 u32 i2_blocks = I2_BLOCKS; 139 u32 i3_blocks = I3_BLOCKS; 140 141 switch (round) { 142 case 0: 143 return hash % i0_blocks; 144 case 1: 145 return i0_blocks + hash % (i1_blocks - i0_blocks); 146 case 2: 147 return i1_blocks + hash % (i2_blocks - i1_blocks); 148 case 3: 149 return i2_blocks + hash % (i3_blocks - i2_blocks); 150 case 4 ... 19: 151 return i3_blocks + 16 * (hash % (((1<<31) - i3_blocks) / 16)) 152 + round - 4; 153 } 154 BUG(); 155} 156 157static struct page *logfs_get_dd_page(struct inode *dir, struct dentry *dentry) 158{ 159 struct qstr *name = &dentry->d_name; 160 struct page *page; 161 struct logfs_disk_dentry *dd; 162 u32 hash = hash_32(name->name, name->len, 0); 163 pgoff_t index; 164 int round; 165 166 if (name->len > LOGFS_MAX_NAMELEN) 167 return ERR_PTR(-ENAMETOOLONG); 168 169 for (round = 0; round < 20; round++) { 170 index = hash_index(hash, round); 171 172 if (beyond_eof(dir, index)) 173 return NULL; 174 if (!logfs_exist_block(dir, index)) 175 continue; 176 page = read_cache_page(dir->i_mapping, index, 177 (filler_t *)logfs_readpage, NULL); 178 if (IS_ERR(page)) 179 return page; 180 dd = kmap_atomic(page, KM_USER0); 181 BUG_ON(dd->namelen == 0); 182 183 if (name->len != be16_to_cpu(dd->namelen) || 184 memcmp(name->name, dd->name, name->len)) { 185 kunmap_atomic(dd, KM_USER0); 186 page_cache_release(page); 187 continue; 188 } 189 190 kunmap_atomic(dd, KM_USER0); 191 return page; 192 } 193 return NULL; 194} 195 196static int logfs_remove_inode(struct inode *inode) 197{ 198 int ret; 199 200 inode->i_nlink--; 201 ret = write_inode(inode); 202 LOGFS_BUG_ON(ret, inode->i_sb); 203 return ret; 204} 205 206static void abort_transaction(struct inode *inode, struct logfs_transaction *ta) 207{ 208 if (logfs_inode(inode)->li_block) 209 logfs_inode(inode)->li_block->ta = NULL; 210 kfree(ta); 211} 212 213static int logfs_unlink(struct inode *dir, struct dentry *dentry) 214{ 215 struct logfs_super *super = logfs_super(dir->i_sb); 216 struct inode *inode = dentry->d_inode; 217 struct logfs_transaction *ta; 218 struct page *page; 219 pgoff_t index; 220 int ret; 221 222 ta = kzalloc(sizeof(*ta), GFP_KERNEL); 223 if (!ta) 224 return -ENOMEM; 225 226 ta->state = UNLINK_1; 227 ta->ino = inode->i_ino; 228 229 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 230 231 page = logfs_get_dd_page(dir, dentry); 232 if (!page) { 233 kfree(ta); 234 return -ENOENT; 235 } 236 if (IS_ERR(page)) { 237 kfree(ta); 238 return PTR_ERR(page); 239 } 240 index = page->index; 241 page_cache_release(page); 242 243 mutex_lock(&super->s_dirop_mutex); 244 logfs_add_transaction(dir, ta); 245 246 ret = logfs_delete(dir, index, NULL); 247 if (!ret) 248 ret = write_inode(dir); 249 250 if (ret) { 251 abort_transaction(dir, ta); 252 printk(KERN_ERR"LOGFS: unable to delete inode\n"); 253 goto out; 254 } 255 256 ta->state = UNLINK_2; 257 logfs_add_transaction(inode, ta); 258 ret = logfs_remove_inode(inode); 259out: 260 mutex_unlock(&super->s_dirop_mutex); 261 return ret; 262} 263 264static inline int logfs_empty_dir(struct inode *dir) 265{ 266 u64 data; 267 268 data = logfs_seek_data(dir, 0) << dir->i_sb->s_blocksize_bits; 269 return data >= i_size_read(dir); 270} 271 272static int logfs_rmdir(struct inode *dir, struct dentry *dentry) 273{ 274 struct inode *inode = dentry->d_inode; 275 276 if (!logfs_empty_dir(inode)) 277 return -ENOTEMPTY; 278 279 return logfs_unlink(dir, dentry); 280} 281 282#define IMPLICIT_NODES 2 283static int __logfs_readdir(struct file *file, void *buf, filldir_t filldir) 284{ 285 struct inode *dir = file->f_dentry->d_inode; 286 loff_t pos = file->f_pos - IMPLICIT_NODES; 287 struct page *page; 288 struct logfs_disk_dentry *dd; 289 int full; 290 291 BUG_ON(pos < 0); 292 for (;; pos++) { 293 if (beyond_eof(dir, pos)) 294 break; 295 if (!logfs_exist_block(dir, pos)) { 296 /* deleted dentry */ 297 pos = dir_seek_data(dir, pos); 298 continue; 299 } 300 page = read_cache_page(dir->i_mapping, pos, 301 (filler_t *)logfs_readpage, NULL); 302 if (IS_ERR(page)) 303 return PTR_ERR(page); 304 dd = kmap(page); 305 BUG_ON(dd->namelen == 0); 306 307 full = filldir(buf, (char *)dd->name, be16_to_cpu(dd->namelen), 308 pos, be64_to_cpu(dd->ino), dd->type); 309 kunmap(page); 310 page_cache_release(page); 311 if (full) 312 break; 313 } 314 315 file->f_pos = pos + IMPLICIT_NODES; 316 return 0; 317} 318 319static int logfs_readdir(struct file *file, void *buf, filldir_t filldir) 320{ 321 struct inode *inode = file->f_dentry->d_inode; 322 ino_t pino = parent_ino(file->f_dentry); 323 int err; 324 325 if (file->f_pos < 0) 326 return -EINVAL; 327 328 if (file->f_pos == 0) { 329 if (filldir(buf, ".", 1, 1, inode->i_ino, DT_DIR) < 0) 330 return 0; 331 file->f_pos++; 332 } 333 if (file->f_pos == 1) { 334 if (filldir(buf, "..", 2, 2, pino, DT_DIR) < 0) 335 return 0; 336 file->f_pos++; 337 } 338 339 err = __logfs_readdir(file, buf, filldir); 340 return err; 341} 342 343static void logfs_set_name(struct logfs_disk_dentry *dd, struct qstr *name) 344{ 345 dd->namelen = cpu_to_be16(name->len); 346 memcpy(dd->name, name->name, name->len); 347} 348 349static struct dentry *logfs_lookup(struct inode *dir, struct dentry *dentry, 350 struct nameidata *nd) 351{ 352 struct page *page; 353 struct logfs_disk_dentry *dd; 354 pgoff_t index; 355 u64 ino = 0; 356 struct inode *inode; 357 358 page = logfs_get_dd_page(dir, dentry); 359 if (IS_ERR(page)) 360 return ERR_CAST(page); 361 if (!page) { 362 d_add(dentry, NULL); 363 return NULL; 364 } 365 index = page->index; 366 dd = kmap_atomic(page, KM_USER0); 367 ino = be64_to_cpu(dd->ino); 368 kunmap_atomic(dd, KM_USER0); 369 page_cache_release(page); 370 371 inode = logfs_iget(dir->i_sb, ino); 372 if (IS_ERR(inode)) { 373 printk(KERN_ERR"LogFS: Cannot read inode #%llx for dentry (%lx, %lx)n", 374 ino, dir->i_ino, index); 375 return ERR_CAST(inode); 376 } 377 return d_splice_alias(inode, dentry); 378} 379 380static void grow_dir(struct inode *dir, loff_t index) 381{ 382 index = (index + 1) << dir->i_sb->s_blocksize_bits; 383 if (i_size_read(dir) < index) 384 i_size_write(dir, index); 385} 386 387static int logfs_write_dir(struct inode *dir, struct dentry *dentry, 388 struct inode *inode) 389{ 390 struct page *page; 391 struct logfs_disk_dentry *dd; 392 u32 hash = hash_32(dentry->d_name.name, dentry->d_name.len, 0); 393 pgoff_t index; 394 int round, err; 395 396 for (round = 0; round < 20; round++) { 397 index = hash_index(hash, round); 398 399 if (logfs_exist_block(dir, index)) 400 continue; 401 page = find_or_create_page(dir->i_mapping, index, GFP_KERNEL); 402 if (!page) 403 return -ENOMEM; 404 405 dd = kmap_atomic(page, KM_USER0); 406 memset(dd, 0, sizeof(*dd)); 407 dd->ino = cpu_to_be64(inode->i_ino); 408 dd->type = logfs_type(inode); 409 logfs_set_name(dd, &dentry->d_name); 410 kunmap_atomic(dd, KM_USER0); 411 412 err = logfs_write_buf(dir, page, WF_LOCK); 413 unlock_page(page); 414 page_cache_release(page); 415 if (!err) 416 grow_dir(dir, index); 417 return err; 418 } 419 return -ENOSPC; 420} 421 422static int __logfs_create(struct inode *dir, struct dentry *dentry, 423 struct inode *inode, const char *dest, long destlen) 424{ 425 struct logfs_super *super = logfs_super(dir->i_sb); 426 struct logfs_inode *li = logfs_inode(inode); 427 struct logfs_transaction *ta; 428 int ret; 429 430 ta = kzalloc(sizeof(*ta), GFP_KERNEL); 431 if (!ta) { 432 inode->i_nlink--; 433 iput(inode); 434 return -ENOMEM; 435 } 436 437 ta->state = CREATE_1; 438 ta->ino = inode->i_ino; 439 mutex_lock(&super->s_dirop_mutex); 440 logfs_add_transaction(inode, ta); 441 442 if (dest) { 443 /* symlink */ 444 ret = logfs_inode_write(inode, dest, destlen, 0, WF_LOCK, NULL); 445 if (!ret) 446 ret = write_inode(inode); 447 } else { 448 /* creat/mkdir/mknod */ 449 ret = write_inode(inode); 450 } 451 if (ret) { 452 abort_transaction(inode, ta); 453 li->li_flags |= LOGFS_IF_STILLBORN; 454 inode->i_nlink--; 455 iput(inode); 456 goto out; 457 } 458 459 ta->state = CREATE_2; 460 logfs_add_transaction(dir, ta); 461 ret = logfs_write_dir(dir, dentry, inode); 462 /* sync directory */ 463 if (!ret) 464 ret = write_inode(dir); 465 466 if (ret) { 467 logfs_del_transaction(dir, ta); 468 ta->state = CREATE_2; 469 logfs_add_transaction(inode, ta); 470 logfs_remove_inode(inode); 471 iput(inode); 472 goto out; 473 } 474 d_instantiate(dentry, inode); 475out: 476 mutex_unlock(&super->s_dirop_mutex); 477 return ret; 478} 479 480static int logfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) 481{ 482 struct inode *inode; 483 484 inode = logfs_new_inode(dir, S_IFDIR | mode); 485 if (IS_ERR(inode)) 486 return PTR_ERR(inode); 487 488 inode->i_op = &logfs_dir_iops; 489 inode->i_fop = &logfs_dir_fops; 490 491 return __logfs_create(dir, dentry, inode, NULL, 0); 492} 493 494static int logfs_create(struct inode *dir, struct dentry *dentry, int mode, 495 struct nameidata *nd) 496{ 497 struct inode *inode; 498 499 inode = logfs_new_inode(dir, mode); 500 if (IS_ERR(inode)) 501 return PTR_ERR(inode); 502 503 inode->i_op = &logfs_reg_iops; 504 inode->i_fop = &logfs_reg_fops; 505 inode->i_mapping->a_ops = &logfs_reg_aops; 506 507 return __logfs_create(dir, dentry, inode, NULL, 0); 508} 509 510static int logfs_mknod(struct inode *dir, struct dentry *dentry, int mode, 511 dev_t rdev) 512{ 513 struct inode *inode; 514 515 if (dentry->d_name.len > LOGFS_MAX_NAMELEN) 516 return -ENAMETOOLONG; 517 518 inode = logfs_new_inode(dir, mode); 519 if (IS_ERR(inode)) 520 return PTR_ERR(inode); 521 522 init_special_inode(inode, mode, rdev); 523 524 return __logfs_create(dir, dentry, inode, NULL, 0); 525} 526 527static int logfs_symlink(struct inode *dir, struct dentry *dentry, 528 const char *target) 529{ 530 struct inode *inode; 531 size_t destlen = strlen(target) + 1; 532 533 if (destlen > dir->i_sb->s_blocksize) 534 return -ENAMETOOLONG; 535 536 inode = logfs_new_inode(dir, S_IFLNK | 0777); 537 if (IS_ERR(inode)) 538 return PTR_ERR(inode); 539 540 inode->i_op = &logfs_symlink_iops; 541 inode->i_mapping->a_ops = &logfs_reg_aops; 542 543 return __logfs_create(dir, dentry, inode, target, destlen); 544} 545 546static int logfs_permission(struct inode *inode, int mask) 547{ 548 return generic_permission(inode, mask, NULL); 549} 550 551static int logfs_link(struct dentry *old_dentry, struct inode *dir, 552 struct dentry *dentry) 553{ 554 struct inode *inode = old_dentry->d_inode; 555 556 if (inode->i_nlink >= LOGFS_LINK_MAX) 557 return -EMLINK; 558 559 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 560 atomic_inc(&inode->i_count); 561 inode->i_nlink++; 562 mark_inode_dirty_sync(inode); 563 564 return __logfs_create(dir, dentry, inode, NULL, 0); 565} 566 567static int logfs_get_dd(struct inode *dir, struct dentry *dentry, 568 struct logfs_disk_dentry *dd, loff_t *pos) 569{ 570 struct page *page; 571 void *map; 572 573 page = logfs_get_dd_page(dir, dentry); 574 if (IS_ERR(page)) 575 return PTR_ERR(page); 576 *pos = page->index; 577 map = kmap_atomic(page, KM_USER0); 578 memcpy(dd, map, sizeof(*dd)); 579 kunmap_atomic(map, KM_USER0); 580 page_cache_release(page); 581 return 0; 582} 583 584static int logfs_delete_dd(struct inode *dir, loff_t pos) 585{ 586 /* 587 * Getting called with pos somewhere beyond eof is either a goofup 588 * within this file or means someone maliciously edited the 589 * (crc-protected) journal. 590 */ 591 BUG_ON(beyond_eof(dir, pos)); 592 dir->i_ctime = dir->i_mtime = CURRENT_TIME; 593 log_dir(" Delete dentry (%lx, %llx)\n", dir->i_ino, pos); 594 return logfs_delete(dir, pos, NULL); 595} 596 597/* 598 * Cross-directory rename, target does not exist. Just a little nasty. 599 * Create a new dentry in the target dir, then remove the old dentry, 600 * all the while taking care to remember our operation in the journal. 601 */ 602static int logfs_rename_cross(struct inode *old_dir, struct dentry *old_dentry, 603 struct inode *new_dir, struct dentry *new_dentry) 604{ 605 struct logfs_super *super = logfs_super(old_dir->i_sb); 606 struct logfs_disk_dentry dd; 607 struct logfs_transaction *ta; 608 loff_t pos; 609 int err; 610 611 /* 1. locate source dd */ 612 err = logfs_get_dd(old_dir, old_dentry, &dd, &pos); 613 if (err) 614 return err; 615 616 ta = kzalloc(sizeof(*ta), GFP_KERNEL); 617 if (!ta) 618 return -ENOMEM; 619 620 ta->state = CROSS_RENAME_1; 621 ta->dir = old_dir->i_ino; 622 ta->pos = pos; 623 624 /* 2. write target dd */ 625 mutex_lock(&super->s_dirop_mutex); 626 logfs_add_transaction(new_dir, ta); 627 err = logfs_write_dir(new_dir, new_dentry, old_dentry->d_inode); 628 if (!err) 629 err = write_inode(new_dir); 630 631 if (err) { 632 super->s_rename_dir = 0; 633 super->s_rename_pos = 0; 634 abort_transaction(new_dir, ta); 635 goto out; 636 } 637 638 /* 3. remove source dd */ 639 ta->state = CROSS_RENAME_2; 640 logfs_add_transaction(old_dir, ta); 641 err = logfs_delete_dd(old_dir, pos); 642 if (!err) 643 err = write_inode(old_dir); 644 LOGFS_BUG_ON(err, old_dir->i_sb); 645out: 646 mutex_unlock(&super->s_dirop_mutex); 647 return err; 648} 649 650static int logfs_replace_inode(struct inode *dir, struct dentry *dentry, 651 struct logfs_disk_dentry *dd, struct inode *inode) 652{ 653 loff_t pos; 654 int err; 655 656 err = logfs_get_dd(dir, dentry, dd, &pos); 657 if (err) 658 return err; 659 dd->ino = cpu_to_be64(inode->i_ino); 660 dd->type = logfs_type(inode); 661 662 err = write_dir(dir, dd, pos); 663 if (err) 664 return err; 665 log_dir("Replace dentry (%lx, %llx) %s -> %llx\n", dir->i_ino, pos, 666 dd->name, be64_to_cpu(dd->ino)); 667 return write_inode(dir); 668} 669 670/* Target dentry exists - the worst case. We need to attach the source 671 * inode to the target dentry, then remove the orphaned target inode and 672 * source dentry. 673 */ 674static int logfs_rename_target(struct inode *old_dir, struct dentry *old_dentry, 675 struct inode *new_dir, struct dentry *new_dentry) 676{ 677 struct logfs_super *super = logfs_super(old_dir->i_sb); 678 struct inode *old_inode = old_dentry->d_inode; 679 struct inode *new_inode = new_dentry->d_inode; 680 int isdir = S_ISDIR(old_inode->i_mode); 681 struct logfs_disk_dentry dd; 682 struct logfs_transaction *ta; 683 loff_t pos; 684 int err; 685 686 BUG_ON(isdir != S_ISDIR(new_inode->i_mode)); 687 if (isdir) { 688 if (!logfs_empty_dir(new_inode)) 689 return -ENOTEMPTY; 690 } 691 692 /* 1. locate source dd */ 693 err = logfs_get_dd(old_dir, old_dentry, &dd, &pos); 694 if (err) 695 return err; 696 697 ta = kzalloc(sizeof(*ta), GFP_KERNEL); 698 if (!ta) 699 return -ENOMEM; 700 701 ta->state = TARGET_RENAME_1; 702 ta->dir = old_dir->i_ino; 703 ta->pos = pos; 704 ta->ino = new_inode->i_ino; 705 706 /* 2. attach source inode to target dd */ 707 mutex_lock(&super->s_dirop_mutex); 708 logfs_add_transaction(new_dir, ta); 709 err = logfs_replace_inode(new_dir, new_dentry, &dd, old_inode); 710 if (err) { 711 super->s_rename_dir = 0; 712 super->s_rename_pos = 0; 713 super->s_victim_ino = 0; 714 abort_transaction(new_dir, ta); 715 goto out; 716 } 717 718 /* 3. remove source dd */ 719 ta->state = TARGET_RENAME_2; 720 logfs_add_transaction(old_dir, ta); 721 err = logfs_delete_dd(old_dir, pos); 722 if (!err) 723 err = write_inode(old_dir); 724 LOGFS_BUG_ON(err, old_dir->i_sb); 725 726 /* 4. remove target inode */ 727 ta->state = TARGET_RENAME_3; 728 logfs_add_transaction(new_inode, ta); 729 err = logfs_remove_inode(new_inode); 730 731out: 732 mutex_unlock(&super->s_dirop_mutex); 733 return err; 734} 735 736static int logfs_rename(struct inode *old_dir, struct dentry *old_dentry, 737 struct inode *new_dir, struct dentry *new_dentry) 738{ 739 if (new_dentry->d_inode) 740 return logfs_rename_target(old_dir, old_dentry, 741 new_dir, new_dentry); 742 return logfs_rename_cross(old_dir, old_dentry, new_dir, new_dentry); 743} 744 745/* No locking done here, as this is called before .get_sb() returns. */ 746int logfs_replay_journal(struct super_block *sb) 747{ 748 struct logfs_super *super = logfs_super(sb); 749 struct inode *inode; 750 u64 ino, pos; 751 int err; 752 753 if (super->s_victim_ino) { 754 /* delete victim inode */ 755 ino = super->s_victim_ino; 756 printk(KERN_INFO"LogFS: delete unmapped inode #%llx\n", ino); 757 inode = logfs_iget(sb, ino); 758 if (IS_ERR(inode)) 759 goto fail; 760 761 LOGFS_BUG_ON(i_size_read(inode) > 0, sb); 762 super->s_victim_ino = 0; 763 err = logfs_remove_inode(inode); 764 iput(inode); 765 if (err) { 766 super->s_victim_ino = ino; 767 goto fail; 768 } 769 } 770 if (super->s_rename_dir) { 771 /* delete old dd from rename */ 772 ino = super->s_rename_dir; 773 pos = super->s_rename_pos; 774 printk(KERN_INFO"LogFS: delete unbacked dentry (%llx, %llx)\n", 775 ino, pos); 776 inode = logfs_iget(sb, ino); 777 if (IS_ERR(inode)) 778 goto fail; 779 780 super->s_rename_dir = 0; 781 super->s_rename_pos = 0; 782 err = logfs_delete_dd(inode, pos); 783 iput(inode); 784 if (err) { 785 super->s_rename_dir = ino; 786 super->s_rename_pos = pos; 787 goto fail; 788 } 789 } 790 return 0; 791fail: 792 LOGFS_BUG(sb); 793 return -EIO; 794} 795 796const struct inode_operations logfs_symlink_iops = { 797 .readlink = generic_readlink, 798 .follow_link = page_follow_link_light, 799}; 800 801const struct inode_operations logfs_dir_iops = { 802 .create = logfs_create, 803 .link = logfs_link, 804 .lookup = logfs_lookup, 805 .mkdir = logfs_mkdir, 806 .mknod = logfs_mknod, 807 .rename = logfs_rename, 808 .rmdir = logfs_rmdir, 809 .permission = logfs_permission, 810 .symlink = logfs_symlink, 811 .unlink = logfs_unlink, 812}; 813const struct file_operations logfs_dir_fops = { 814 .fsync = logfs_fsync, 815 .unlocked_ioctl = logfs_ioctl, 816 .readdir = logfs_readdir, 817 .read = generic_read_dir, 818}; 819