1 /* 2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README 3 * 4 * Trivial changes by Alan Cox to add the LFS fixes 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/module.h> 15 #include <linux/vmalloc.h> 16 #include <linux/time.h> 17 #include <asm/uaccess.h> 18 #include <linux/reiserfs_fs.h> 19 #include <linux/reiserfs_acl.h> 20 #include <linux/reiserfs_xattr.h> 21 #include <linux/init.h> 22 #include <linux/blkdev.h> 23 #include <linux/buffer_head.h> 24 #include <linux/vfs.h> 25 #include <linux/mnt_namespace.h> 26 #include <linux/mount.h> 27 #include <linux/namei.h> 28 #include <linux/quotaops.h> 29 30 struct file_system_type reiserfs_fs_type; 31 32 static const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING; 33 static const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING; 34 static const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING; 35 36 int is_reiserfs_3_5(struct reiserfs_super_block *rs) 37 { 38 return !strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string, 39 strlen(reiserfs_3_5_magic_string)); 40 } 41 42 int is_reiserfs_3_6(struct reiserfs_super_block *rs) 43 { 44 return !strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string, 45 strlen(reiserfs_3_6_magic_string)); 46 } 47 48 int is_reiserfs_jr(struct reiserfs_super_block *rs) 49 { 50 return !strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string, 51 strlen(reiserfs_jr_magic_string)); 52 } 53 54 static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs) 55 { 56 return (is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) || 57 is_reiserfs_jr(rs)); 58 } 59 60 static int reiserfs_remount(struct super_block *s, int *flags, char *data); 61 static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf); 62 63 static int reiserfs_sync_fs(struct super_block *s, int wait) 64 { 65 if (!(s->s_flags & MS_RDONLY)) { 66 struct reiserfs_transaction_handle th; 67 reiserfs_write_lock(s); 68 if (!journal_begin(&th, s, 1)) 69 if (!journal_end_sync(&th, s, 1)) 70 reiserfs_flush_old_commits(s); 71 s->s_dirt = 0; /* Even if it's not true. 72 * We'll loop forever in sync_supers otherwise */ 73 reiserfs_write_unlock(s); 74 } else { 75 s->s_dirt = 0; 76 } 77 return 0; 78 } 79 80 static void reiserfs_write_super(struct super_block *s) 81 { 82 reiserfs_sync_fs(s, 1); 83 } 84 85 static void reiserfs_write_super_lockfs(struct super_block *s) 86 { 87 struct reiserfs_transaction_handle th; 88 reiserfs_write_lock(s); 89 if (!(s->s_flags & MS_RDONLY)) { 90 int err = journal_begin(&th, s, 1); 91 if (err) { 92 reiserfs_block_writes(&th); 93 } else { 94 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 95 1); 96 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s)); 97 reiserfs_block_writes(&th); 98 journal_end_sync(&th, s, 1); 99 } 100 } 101 s->s_dirt = 0; 102 reiserfs_write_unlock(s); 103 } 104 105 static void reiserfs_unlockfs(struct super_block *s) 106 { 107 reiserfs_allow_writes(s); 108 } 109 110 extern const struct in_core_key MAX_IN_CORE_KEY; 111 112 /* this is used to delete "save link" when there are no items of a 113 file it points to. It can either happen if unlink is completed but 114 "save unlink" removal, or if file has both unlink and truncate 115 pending and as unlink completes first (because key of "save link" 116 protecting unlink is bigger that a key lf "save link" which 117 protects truncate), so there left no items to make truncate 118 completion on */ 119 static int remove_save_link_only(struct super_block *s, 120 struct reiserfs_key *key, int oid_free) 121 { 122 struct reiserfs_transaction_handle th; 123 int err; 124 125 /* we are going to do one balancing */ 126 err = journal_begin(&th, s, JOURNAL_PER_BALANCE_CNT); 127 if (err) 128 return err; 129 130 reiserfs_delete_solid_item(&th, NULL, key); 131 if (oid_free) 132 /* removals are protected by direct items */ 133 reiserfs_release_objectid(&th, le32_to_cpu(key->k_objectid)); 134 135 return journal_end(&th, s, JOURNAL_PER_BALANCE_CNT); 136 } 137 138 #ifdef CONFIG_QUOTA 139 static int reiserfs_quota_on_mount(struct super_block *, int); 140 #endif 141 142 /* look for uncompleted unlinks and truncates and complete them */ 143 static int finish_unfinished(struct super_block *s) 144 { 145 INITIALIZE_PATH(path); 146 struct cpu_key max_cpu_key, obj_key; 147 struct reiserfs_key save_link_key; 148 int retval = 0; 149 struct item_head *ih; 150 struct buffer_head *bh; 151 int item_pos; 152 char *item; 153 int done; 154 struct inode *inode; 155 int truncate; 156 #ifdef CONFIG_QUOTA 157 int i; 158 int ms_active_set; 159 #endif 160 161 /* compose key to look for "save" links */ 162 max_cpu_key.version = KEY_FORMAT_3_5; 163 max_cpu_key.on_disk_key.k_dir_id = ~0U; 164 max_cpu_key.on_disk_key.k_objectid = ~0U; 165 set_cpu_key_k_offset(&max_cpu_key, ~0U); 166 max_cpu_key.key_length = 3; 167 168 #ifdef CONFIG_QUOTA 169 /* Needed for iput() to work correctly and not trash data */ 170 if (s->s_flags & MS_ACTIVE) { 171 ms_active_set = 0; 172 } else { 173 ms_active_set = 1; 174 s->s_flags |= MS_ACTIVE; 175 } 176 /* Turn on quotas so that they are updated correctly */ 177 for (i = 0; i < MAXQUOTAS; i++) { 178 if (REISERFS_SB(s)->s_qf_names[i]) { 179 int ret = reiserfs_quota_on_mount(s, i); 180 if (ret < 0) 181 reiserfs_warning(s, 182 "reiserfs: cannot turn on journalled quota: error %d", 183 ret); 184 } 185 } 186 #endif 187 188 done = 0; 189 REISERFS_SB(s)->s_is_unlinked_ok = 1; 190 while (!retval) { 191 retval = search_item(s, &max_cpu_key, &path); 192 if (retval != ITEM_NOT_FOUND) { 193 reiserfs_warning(s, 194 "vs-2140: finish_unfinished: search_by_key returned %d", 195 retval); 196 break; 197 } 198 199 bh = get_last_bh(&path); 200 item_pos = get_item_pos(&path); 201 if (item_pos != B_NR_ITEMS(bh)) { 202 reiserfs_warning(s, 203 "vs-2060: finish_unfinished: wrong position found"); 204 break; 205 } 206 item_pos--; 207 ih = B_N_PITEM_HEAD(bh, item_pos); 208 209 if (le32_to_cpu(ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID) 210 /* there are no "save" links anymore */ 211 break; 212 213 save_link_key = ih->ih_key; 214 if (is_indirect_le_ih(ih)) 215 truncate = 1; 216 else 217 truncate = 0; 218 219 /* reiserfs_iget needs k_dirid and k_objectid only */ 220 item = B_I_PITEM(bh, ih); 221 obj_key.on_disk_key.k_dir_id = le32_to_cpu(*(__le32 *) item); 222 obj_key.on_disk_key.k_objectid = 223 le32_to_cpu(ih->ih_key.k_objectid); 224 obj_key.on_disk_key.k_offset = 0; 225 obj_key.on_disk_key.k_type = 0; 226 227 pathrelse(&path); 228 229 inode = reiserfs_iget(s, &obj_key); 230 if (!inode) { 231 /* the unlink almost completed, it just did not manage to remove 232 "save" link and release objectid */ 233 reiserfs_warning(s, 234 "vs-2180: finish_unfinished: iget failed for %K", 235 &obj_key); 236 retval = remove_save_link_only(s, &save_link_key, 1); 237 continue; 238 } 239 240 if (!truncate && inode->i_nlink) { 241 /* file is not unlinked */ 242 reiserfs_warning(s, 243 "vs-2185: finish_unfinished: file %K is not unlinked", 244 &obj_key); 245 retval = remove_save_link_only(s, &save_link_key, 0); 246 continue; 247 } 248 DQUOT_INIT(inode); 249 250 if (truncate && S_ISDIR(inode->i_mode)) { 251 /* We got a truncate request for a dir which is impossible. 252 The only imaginable way is to execute unfinished truncate request 253 then boot into old kernel, remove the file and create dir with 254 the same key. */ 255 reiserfs_warning(s, 256 "green-2101: impossible truncate on a directory %k. Please report", 257 INODE_PKEY(inode)); 258 retval = remove_save_link_only(s, &save_link_key, 0); 259 truncate = 0; 260 iput(inode); 261 continue; 262 } 263 264 if (truncate) { 265 REISERFS_I(inode)->i_flags |= 266 i_link_saved_truncate_mask; 267 /* not completed truncate found. New size was committed together 268 with "save" link */ 269 reiserfs_info(s, "Truncating %k to %Ld ..", 270 INODE_PKEY(inode), inode->i_size); 271 reiserfs_truncate_file(inode, 272 0 273 /*don't update modification time */ 274 ); 275 retval = remove_save_link(inode, truncate); 276 } else { 277 REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask; 278 /* not completed unlink (rmdir) found */ 279 reiserfs_info(s, "Removing %k..", INODE_PKEY(inode)); 280 /* removal gets completed in iput */ 281 retval = 0; 282 } 283 284 iput(inode); 285 printk("done\n"); 286 done++; 287 } 288 REISERFS_SB(s)->s_is_unlinked_ok = 0; 289 290 #ifdef CONFIG_QUOTA 291 /* Turn quotas off */ 292 for (i = 0; i < MAXQUOTAS; i++) { 293 if (sb_dqopt(s)->files[i]) 294 vfs_quota_off_mount(s, i); 295 } 296 if (ms_active_set) 297 /* Restore the flag back */ 298 s->s_flags &= ~MS_ACTIVE; 299 #endif 300 pathrelse(&path); 301 if (done) 302 reiserfs_info(s, "There were %d uncompleted unlinks/truncates. " 303 "Completed\n", done); 304 return retval; 305 } 306 307 /* to protect file being unlinked from getting lost we "safe" link files 308 being unlinked. This link will be deleted in the same transaction with last 309 item of file. mounting the filesytem we scan all these links and remove 310 files which almost got lost */ 311 void add_save_link(struct reiserfs_transaction_handle *th, 312 struct inode *inode, int truncate) 313 { 314 INITIALIZE_PATH(path); 315 int retval; 316 struct cpu_key key; 317 struct item_head ih; 318 __le32 link; 319 320 BUG_ON(!th->t_trans_id); 321 322 /* file can only get one "save link" of each kind */ 323 RFALSE(truncate && 324 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask), 325 "saved link already exists for truncated inode %lx", 326 (long)inode->i_ino); 327 RFALSE(!truncate && 328 (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask), 329 "saved link already exists for unlinked inode %lx", 330 (long)inode->i_ino); 331 332 /* setup key of "save" link */ 333 key.version = KEY_FORMAT_3_5; 334 key.on_disk_key.k_dir_id = MAX_KEY_OBJECTID; 335 key.on_disk_key.k_objectid = inode->i_ino; 336 if (!truncate) { 337 /* unlink, rmdir, rename */ 338 set_cpu_key_k_offset(&key, 1 + inode->i_sb->s_blocksize); 339 set_cpu_key_k_type(&key, TYPE_DIRECT); 340 341 /* item head of "safe" link */ 342 make_le_item_head(&ih, &key, key.version, 343 1 + inode->i_sb->s_blocksize, TYPE_DIRECT, 344 4 /*length */ , 0xffff /*free space */ ); 345 } else { 346 /* truncate */ 347 if (S_ISDIR(inode->i_mode)) 348 reiserfs_warning(inode->i_sb, 349 "green-2102: Adding a truncate savelink for a directory %k! Please report", 350 INODE_PKEY(inode)); 351 set_cpu_key_k_offset(&key, 1); 352 set_cpu_key_k_type(&key, TYPE_INDIRECT); 353 354 /* item head of "safe" link */ 355 make_le_item_head(&ih, &key, key.version, 1, TYPE_INDIRECT, 356 4 /*length */ , 0 /*free space */ ); 357 } 358 key.key_length = 3; 359 360 /* look for its place in the tree */ 361 retval = search_item(inode->i_sb, &key, &path); 362 if (retval != ITEM_NOT_FOUND) { 363 if (retval != -ENOSPC) 364 reiserfs_warning(inode->i_sb, "vs-2100: add_save_link:" 365 "search_by_key (%K) returned %d", &key, 366 retval); 367 pathrelse(&path); 368 return; 369 } 370 371 /* body of "save" link */ 372 link = INODE_PKEY(inode)->k_dir_id; 373 374 /* put "save" link inot tree, don't charge quota to anyone */ 375 retval = 376 reiserfs_insert_item(th, &path, &key, &ih, NULL, (char *)&link); 377 if (retval) { 378 if (retval != -ENOSPC) 379 reiserfs_warning(inode->i_sb, 380 "vs-2120: add_save_link: insert_item returned %d", 381 retval); 382 } else { 383 if (truncate) 384 REISERFS_I(inode)->i_flags |= 385 i_link_saved_truncate_mask; 386 else 387 REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask; 388 } 389 } 390 391 /* this opens transaction unlike add_save_link */ 392 int remove_save_link(struct inode *inode, int truncate) 393 { 394 struct reiserfs_transaction_handle th; 395 struct reiserfs_key key; 396 int err; 397 398 /* we are going to do one balancing only */ 399 err = journal_begin(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT); 400 if (err) 401 return err; 402 403 /* setup key of "save" link */ 404 key.k_dir_id = cpu_to_le32(MAX_KEY_OBJECTID); 405 key.k_objectid = INODE_PKEY(inode)->k_objectid; 406 if (!truncate) { 407 /* unlink, rmdir, rename */ 408 set_le_key_k_offset(KEY_FORMAT_3_5, &key, 409 1 + inode->i_sb->s_blocksize); 410 set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_DIRECT); 411 } else { 412 /* truncate */ 413 set_le_key_k_offset(KEY_FORMAT_3_5, &key, 1); 414 set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_INDIRECT); 415 } 416 417 if ((truncate && 418 (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask)) || 419 (!truncate && 420 (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask))) 421 /* don't take quota bytes from anywhere */ 422 reiserfs_delete_solid_item(&th, NULL, &key); 423 if (!truncate) { 424 reiserfs_release_objectid(&th, inode->i_ino); 425 REISERFS_I(inode)->i_flags &= ~i_link_saved_unlink_mask; 426 } else 427 REISERFS_I(inode)->i_flags &= ~i_link_saved_truncate_mask; 428 429 return journal_end(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT); 430 } 431 432 static void reiserfs_kill_sb(struct super_block *s) 433 { 434 if (REISERFS_SB(s)) { 435 #ifdef CONFIG_REISERFS_FS_XATTR 436 if (REISERFS_SB(s)->xattr_root) { 437 d_invalidate(REISERFS_SB(s)->xattr_root); 438 dput(REISERFS_SB(s)->xattr_root); 439 REISERFS_SB(s)->xattr_root = NULL; 440 } 441 #endif 442 if (REISERFS_SB(s)->priv_root) { 443 d_invalidate(REISERFS_SB(s)->priv_root); 444 dput(REISERFS_SB(s)->priv_root); 445 REISERFS_SB(s)->priv_root = NULL; 446 } 447 } 448 449 kill_block_super(s); 450 } 451 452 static void reiserfs_put_super(struct super_block *s) 453 { 454 struct reiserfs_transaction_handle th; 455 th.t_trans_id = 0; 456 457 /* change file system state to current state if it was mounted with read-write permissions */ 458 if (!(s->s_flags & MS_RDONLY)) { 459 if (!journal_begin(&th, s, 10)) { 460 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 461 1); 462 set_sb_umount_state(SB_DISK_SUPER_BLOCK(s), 463 REISERFS_SB(s)->s_mount_state); 464 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s)); 465 } 466 } 467 468 /* note, journal_release checks for readonly mount, and can decide not 469 ** to do a journal_end 470 */ 471 journal_release(&th, s); 472 473 reiserfs_free_bitmap_cache(s); 474 475 brelse(SB_BUFFER_WITH_SB(s)); 476 477 print_statistics(s); 478 479 if (REISERFS_SB(s)->reserved_blocks != 0) { 480 reiserfs_warning(s, 481 "green-2005: reiserfs_put_super: reserved blocks left %d", 482 REISERFS_SB(s)->reserved_blocks); 483 } 484 485 reiserfs_proc_info_done(s); 486 487 kfree(s->s_fs_info); 488 s->s_fs_info = NULL; 489 490 return; 491 } 492 493 static struct kmem_cache *reiserfs_inode_cachep; 494 495 static struct inode *reiserfs_alloc_inode(struct super_block *sb) 496 { 497 struct reiserfs_inode_info *ei; 498 ei = (struct reiserfs_inode_info *) 499 kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL); 500 if (!ei) 501 return NULL; 502 return &ei->vfs_inode; 503 } 504 505 static void reiserfs_destroy_inode(struct inode *inode) 506 { 507 kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode)); 508 } 509 510 static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags) 511 { 512 struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo; 513 514 INIT_LIST_HEAD(&ei->i_prealloc_list); 515 inode_init_once(&ei->vfs_inode); 516 #ifdef CONFIG_REISERFS_FS_POSIX_ACL 517 ei->i_acl_access = NULL; 518 ei->i_acl_default = NULL; 519 #endif 520 } 521 522 static int init_inodecache(void) 523 { 524 reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache", 525 sizeof(struct 526 reiserfs_inode_info), 527 0, (SLAB_RECLAIM_ACCOUNT| 528 SLAB_MEM_SPREAD), 529 init_once, NULL); 530 if (reiserfs_inode_cachep == NULL) 531 return -ENOMEM; 532 return 0; 533 } 534 535 static void destroy_inodecache(void) 536 { 537 kmem_cache_destroy(reiserfs_inode_cachep); 538 } 539 540 /* we don't mark inodes dirty, we just log them */ 541 static void reiserfs_dirty_inode(struct inode *inode) 542 { 543 struct reiserfs_transaction_handle th; 544 545 int err = 0; 546 if (inode->i_sb->s_flags & MS_RDONLY) { 547 reiserfs_warning(inode->i_sb, 548 "clm-6006: writing inode %lu on readonly FS", 549 inode->i_ino); 550 return; 551 } 552 reiserfs_write_lock(inode->i_sb); 553 554 /* this is really only used for atime updates, so they don't have 555 ** to be included in O_SYNC or fsync 556 */ 557 err = journal_begin(&th, inode->i_sb, 1); 558 if (err) { 559 reiserfs_write_unlock(inode->i_sb); 560 return; 561 } 562 reiserfs_update_sd(&th, inode); 563 journal_end(&th, inode->i_sb, 1); 564 reiserfs_write_unlock(inode->i_sb); 565 } 566 567 #ifdef CONFIG_REISERFS_FS_POSIX_ACL 568 static void reiserfs_clear_inode(struct inode *inode) 569 { 570 struct posix_acl *acl; 571 572 acl = REISERFS_I(inode)->i_acl_access; 573 if (acl && !IS_ERR(acl)) 574 posix_acl_release(acl); 575 REISERFS_I(inode)->i_acl_access = NULL; 576 577 acl = REISERFS_I(inode)->i_acl_default; 578 if (acl && !IS_ERR(acl)) 579 posix_acl_release(acl); 580 REISERFS_I(inode)->i_acl_default = NULL; 581 } 582 #else 583 #define reiserfs_clear_inode NULL 584 #endif 585 586 #ifdef CONFIG_QUOTA 587 static ssize_t reiserfs_quota_write(struct super_block *, int, const char *, 588 size_t, loff_t); 589 static ssize_t reiserfs_quota_read(struct super_block *, int, char *, size_t, 590 loff_t); 591 #endif 592 593 static const struct super_operations reiserfs_sops = { 594 .alloc_inode = reiserfs_alloc_inode, 595 .destroy_inode = reiserfs_destroy_inode, 596 .write_inode = reiserfs_write_inode, 597 .dirty_inode = reiserfs_dirty_inode, 598 .delete_inode = reiserfs_delete_inode, 599 .clear_inode = reiserfs_clear_inode, 600 .put_super = reiserfs_put_super, 601 .write_super = reiserfs_write_super, 602 .sync_fs = reiserfs_sync_fs, 603 .write_super_lockfs = reiserfs_write_super_lockfs, 604 .unlockfs = reiserfs_unlockfs, 605 .statfs = reiserfs_statfs, 606 .remount_fs = reiserfs_remount, 607 #ifdef CONFIG_QUOTA 608 .quota_read = reiserfs_quota_read, 609 .quota_write = reiserfs_quota_write, 610 #endif 611 }; 612 613 #ifdef CONFIG_QUOTA 614 #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group") 615 616 static int reiserfs_dquot_initialize(struct inode *, int); 617 static int reiserfs_dquot_drop(struct inode *); 618 static int reiserfs_write_dquot(struct dquot *); 619 static int reiserfs_acquire_dquot(struct dquot *); 620 static int reiserfs_release_dquot(struct dquot *); 621 static int reiserfs_mark_dquot_dirty(struct dquot *); 622 static int reiserfs_write_info(struct super_block *, int); 623 static int reiserfs_quota_on(struct super_block *, int, int, char *); 624 625 static struct dquot_operations reiserfs_quota_operations = { 626 .initialize = reiserfs_dquot_initialize, 627 .drop = reiserfs_dquot_drop, 628 .alloc_space = dquot_alloc_space, 629 .alloc_inode = dquot_alloc_inode, 630 .free_space = dquot_free_space, 631 .free_inode = dquot_free_inode, 632 .transfer = dquot_transfer, 633 .write_dquot = reiserfs_write_dquot, 634 .acquire_dquot = reiserfs_acquire_dquot, 635 .release_dquot = reiserfs_release_dquot, 636 .mark_dirty = reiserfs_mark_dquot_dirty, 637 .write_info = reiserfs_write_info, 638 }; 639 640 static struct quotactl_ops reiserfs_qctl_operations = { 641 .quota_on = reiserfs_quota_on, 642 .quota_off = vfs_quota_off, 643 .quota_sync = vfs_quota_sync, 644 .get_info = vfs_get_dqinfo, 645 .set_info = vfs_set_dqinfo, 646 .get_dqblk = vfs_get_dqblk, 647 .set_dqblk = vfs_set_dqblk, 648 }; 649 #endif 650 651 static struct export_operations reiserfs_export_ops = { 652 .encode_fh = reiserfs_encode_fh, 653 .decode_fh = reiserfs_decode_fh, 654 .get_parent = reiserfs_get_parent, 655 .get_dentry = reiserfs_get_dentry, 656 }; 657 658 /* this struct is used in reiserfs_getopt () for containing the value for those 659 mount options that have values rather than being toggles. */ 660 typedef struct { 661 char *value; 662 int setmask; /* bitmask which is to set on mount_options bitmask when this 663 value is found, 0 is no bits are to be changed. */ 664 int clrmask; /* bitmask which is to clear on mount_options bitmask when this 665 value is found, 0 is no bits are to be changed. This is 666 applied BEFORE setmask */ 667 } arg_desc_t; 668 669 /* Set this bit in arg_required to allow empty arguments */ 670 #define REISERFS_OPT_ALLOWEMPTY 31 671 672 /* this struct is used in reiserfs_getopt() for describing the set of reiserfs 673 mount options */ 674 typedef struct { 675 char *option_name; 676 int arg_required; /* 0 if argument is not required, not 0 otherwise */ 677 const arg_desc_t *values; /* list of values accepted by an option */ 678 int setmask; /* bitmask which is to set on mount_options bitmask when this 679 value is found, 0 is no bits are to be changed. */ 680 int clrmask; /* bitmask which is to clear on mount_options bitmask when this 681 value is found, 0 is no bits are to be changed. This is 682 applied BEFORE setmask */ 683 } opt_desc_t; 684 685 /* possible values for -o data= */ 686 static const arg_desc_t logging_mode[] = { 687 {"ordered", 1 << REISERFS_DATA_ORDERED, 688 (1 << REISERFS_DATA_LOG | 1 << REISERFS_DATA_WRITEBACK)}, 689 {"journal", 1 << REISERFS_DATA_LOG, 690 (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_WRITEBACK)}, 691 {"writeback", 1 << REISERFS_DATA_WRITEBACK, 692 (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_LOG)}, 693 {.value = NULL} 694 }; 695 696 /* possible values for -o barrier= */ 697 static const arg_desc_t barrier_mode[] = { 698 {"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH}, 699 {"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE}, 700 {.value = NULL} 701 }; 702 703 /* possible values for "-o block-allocator=" and bits which are to be set in 704 s_mount_opt of reiserfs specific part of in-core super block */ 705 static const arg_desc_t balloc[] = { 706 {"noborder", 1 << REISERFS_NO_BORDER, 0}, 707 {"border", 0, 1 << REISERFS_NO_BORDER}, 708 {"no_unhashed_relocation", 1 << REISERFS_NO_UNHASHED_RELOCATION, 0}, 709 {"hashed_relocation", 1 << REISERFS_HASHED_RELOCATION, 0}, 710 {"test4", 1 << REISERFS_TEST4, 0}, 711 {"notest4", 0, 1 << REISERFS_TEST4}, 712 {NULL, 0, 0} 713 }; 714 715 static const arg_desc_t tails[] = { 716 {"on", 1 << REISERFS_LARGETAIL, 1 << REISERFS_SMALLTAIL}, 717 {"off", 0, (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)}, 718 {"small", 1 << REISERFS_SMALLTAIL, 1 << REISERFS_LARGETAIL}, 719 {NULL, 0, 0} 720 }; 721 722 static const arg_desc_t error_actions[] = { 723 {"panic", 1 << REISERFS_ERROR_PANIC, 724 (1 << REISERFS_ERROR_RO | 1 << REISERFS_ERROR_CONTINUE)}, 725 {"ro-remount", 1 << REISERFS_ERROR_RO, 726 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_CONTINUE)}, 727 #ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG 728 {"continue", 1 << REISERFS_ERROR_CONTINUE, 729 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_RO)}, 730 #endif 731 {NULL, 0, 0}, 732 }; 733 734 /* proceed only one option from a list *cur - string containing of mount options 735 opts - array of options which are accepted 736 opt_arg - if option is found and requires an argument and if it is specifed 737 in the input - pointer to the argument is stored here 738 bit_flags - if option requires to set a certain bit - it is set here 739 return -1 if unknown option is found, opt->arg_required otherwise */ 740 static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts, 741 char **opt_arg, unsigned long *bit_flags) 742 { 743 char *p; 744 /* foo=bar, 745 ^ ^ ^ 746 | | +-- option_end 747 | +-- arg_start 748 +-- option_start 749 */ 750 const opt_desc_t *opt; 751 const arg_desc_t *arg; 752 753 p = *cur; 754 755 /* assume argument cannot contain commas */ 756 *cur = strchr(p, ','); 757 if (*cur) { 758 *(*cur) = '\0'; 759 (*cur)++; 760 } 761 762 if (!strncmp(p, "alloc=", 6)) { 763 /* Ugly special case, probably we should redo options parser so that 764 it can understand several arguments for some options, also so that 765 it can fill several bitfields with option values. */ 766 if (reiserfs_parse_alloc_options(s, p + 6)) { 767 return -1; 768 } else { 769 return 0; 770 } 771 } 772 773 /* for every option in the list */ 774 for (opt = opts; opt->option_name; opt++) { 775 if (!strncmp(p, opt->option_name, strlen(opt->option_name))) { 776 if (bit_flags) { 777 if (opt->clrmask == 778 (1 << REISERFS_UNSUPPORTED_OPT)) 779 reiserfs_warning(s, "%s not supported.", 780 p); 781 else 782 *bit_flags &= ~opt->clrmask; 783 if (opt->setmask == 784 (1 << REISERFS_UNSUPPORTED_OPT)) 785 reiserfs_warning(s, "%s not supported.", 786 p); 787 else 788 *bit_flags |= opt->setmask; 789 } 790 break; 791 } 792 } 793 if (!opt->option_name) { 794 reiserfs_warning(s, "unknown mount option \"%s\"", p); 795 return -1; 796 } 797 798 p += strlen(opt->option_name); 799 switch (*p) { 800 case '=': 801 if (!opt->arg_required) { 802 reiserfs_warning(s, 803 "the option \"%s\" does not require an argument", 804 opt->option_name); 805 return -1; 806 } 807 break; 808 809 case 0: 810 if (opt->arg_required) { 811 reiserfs_warning(s, 812 "the option \"%s\" requires an argument", 813 opt->option_name); 814 return -1; 815 } 816 break; 817 default: 818 reiserfs_warning(s, "head of option \"%s\" is only correct", 819 opt->option_name); 820 return -1; 821 } 822 823 /* move to the argument, or to next option if argument is not required */ 824 p++; 825 826 if (opt->arg_required 827 && !(opt->arg_required & (1 << REISERFS_OPT_ALLOWEMPTY)) 828 && !strlen(p)) { 829 /* this catches "option=," if not allowed */ 830 reiserfs_warning(s, "empty argument for \"%s\"", 831 opt->option_name); 832 return -1; 833 } 834 835 if (!opt->values) { 836 /* *=NULLopt_arg contains pointer to argument */ 837 *opt_arg = p; 838 return opt->arg_required & ~(1 << REISERFS_OPT_ALLOWEMPTY); 839 } 840 841 /* values possible for this option are listed in opt->values */ 842 for (arg = opt->values; arg->value; arg++) { 843 if (!strcmp(p, arg->value)) { 844 if (bit_flags) { 845 *bit_flags &= ~arg->clrmask; 846 *bit_flags |= arg->setmask; 847 } 848 return opt->arg_required; 849 } 850 } 851 852 reiserfs_warning(s, "bad value \"%s\" for option \"%s\"", p, 853 opt->option_name); 854 return -1; 855 } 856 857 /* returns 0 if something is wrong in option string, 1 - otherwise */ 858 static int reiserfs_parse_options(struct super_block *s, char *options, /* string given via mount's -o */ 859 unsigned long *mount_options, 860 /* after the parsing phase, contains the 861 collection of bitflags defining what 862 mount options were selected. */ 863 unsigned long *blocks, /* strtol-ed from NNN of resize=NNN */ 864 char **jdev_name, 865 unsigned int *commit_max_age) 866 { 867 int c; 868 char *arg = NULL; 869 char *pos; 870 opt_desc_t opts[] = { 871 /* Compatibility stuff, so that -o notail for old setups still work */ 872 {"tails",.arg_required = 't',.values = tails}, 873 {"notail",.clrmask = 874 (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)}, 875 {"conv",.setmask = 1 << REISERFS_CONVERT}, 876 {"attrs",.setmask = 1 << REISERFS_ATTRS}, 877 {"noattrs",.clrmask = 1 << REISERFS_ATTRS}, 878 #ifdef CONFIG_REISERFS_FS_XATTR 879 {"user_xattr",.setmask = 1 << REISERFS_XATTRS_USER}, 880 {"nouser_xattr",.clrmask = 1 << REISERFS_XATTRS_USER}, 881 #else 882 {"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT}, 883 {"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT}, 884 #endif 885 #ifdef CONFIG_REISERFS_FS_POSIX_ACL 886 {"acl",.setmask = 1 << REISERFS_POSIXACL}, 887 {"noacl",.clrmask = 1 << REISERFS_POSIXACL}, 888 #else 889 {"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT}, 890 {"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT}, 891 #endif 892 {.option_name = "nolog"}, 893 {"replayonly",.setmask = 1 << REPLAYONLY}, 894 {"block-allocator",.arg_required = 'a',.values = balloc}, 895 {"data",.arg_required = 'd',.values = logging_mode}, 896 {"barrier",.arg_required = 'b',.values = barrier_mode}, 897 {"resize",.arg_required = 'r',.values = NULL}, 898 {"jdev",.arg_required = 'j',.values = NULL}, 899 {"nolargeio",.arg_required = 'w',.values = NULL}, 900 {"commit",.arg_required = 'c',.values = NULL}, 901 {"usrquota",.setmask = 1 << REISERFS_QUOTA}, 902 {"grpquota",.setmask = 1 << REISERFS_QUOTA}, 903 {"noquota",.clrmask = 1 << REISERFS_QUOTA}, 904 {"errors",.arg_required = 'e',.values = error_actions}, 905 {"usrjquota",.arg_required = 906 'u' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL}, 907 {"grpjquota",.arg_required = 908 'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL}, 909 {"jqfmt",.arg_required = 'f',.values = NULL}, 910 {.option_name = NULL} 911 }; 912 913 *blocks = 0; 914 if (!options || !*options) 915 /* use default configuration: create tails, journaling on, no 916 conversion to newest format */ 917 return 1; 918 919 for (pos = options; pos;) { 920 c = reiserfs_getopt(s, &pos, opts, &arg, mount_options); 921 if (c == -1) 922 /* wrong option is given */ 923 return 0; 924 925 if (c == 'r') { 926 char *p; 927 928 p = NULL; 929 /* "resize=NNN" or "resize=auto" */ 930 931 if (!strcmp(arg, "auto")) { 932 /* From JFS code, to auto-get the size. */ 933 *blocks = 934 s->s_bdev->bd_inode->i_size >> s-> 935 s_blocksize_bits; 936 } else { 937 *blocks = simple_strtoul(arg, &p, 0); 938 if (*p != '\0') { 939 /* NNN does not look like a number */ 940 reiserfs_warning(s, 941 "reiserfs_parse_options: bad value %s", 942 arg); 943 return 0; 944 } 945 } 946 } 947 948 if (c == 'c') { 949 char *p = NULL; 950 unsigned long val = simple_strtoul(arg, &p, 0); 951 /* commit=NNN (time in seconds) */ 952 if (*p != '\0' || val >= (unsigned int)-1) { 953 reiserfs_warning(s, 954 "reiserfs_parse_options: bad value %s", 955 arg); 956 return 0; 957 } 958 *commit_max_age = (unsigned int)val; 959 } 960 961 if (c == 'w') { 962 reiserfs_warning(s, "reiserfs: nolargeio option is no longer supported"); 963 return 0; 964 } 965 966 if (c == 'j') { 967 if (arg && *arg && jdev_name) { 968 if (*jdev_name) { //Hm, already assigned? 969 reiserfs_warning(s, 970 "reiserfs_parse_options: journal device was already specified to be %s", 971 *jdev_name); 972 return 0; 973 } 974 *jdev_name = arg; 975 } 976 } 977 #ifdef CONFIG_QUOTA 978 if (c == 'u' || c == 'g') { 979 int qtype = c == 'u' ? USRQUOTA : GRPQUOTA; 980 981 if (sb_any_quota_enabled(s)) { 982 reiserfs_warning(s, 983 "reiserfs_parse_options: cannot change journalled quota options when quota turned on."); 984 return 0; 985 } 986 if (*arg) { /* Some filename specified? */ 987 if (REISERFS_SB(s)->s_qf_names[qtype] 988 && strcmp(REISERFS_SB(s)->s_qf_names[qtype], 989 arg)) { 990 reiserfs_warning(s, 991 "reiserfs_parse_options: %s quota file already specified.", 992 QTYPE2NAME(qtype)); 993 return 0; 994 } 995 if (strchr(arg, '/')) { 996 reiserfs_warning(s, 997 "reiserfs_parse_options: quotafile must be on filesystem root."); 998 return 0; 999 } 1000 REISERFS_SB(s)->s_qf_names[qtype] = 1001 kmalloc(strlen(arg) + 1, GFP_KERNEL); 1002 if (!REISERFS_SB(s)->s_qf_names[qtype]) { 1003 reiserfs_warning(s, 1004 "reiserfs_parse_options: not enough memory for storing quotafile name."); 1005 return 0; 1006 } 1007 strcpy(REISERFS_SB(s)->s_qf_names[qtype], arg); 1008 *mount_options |= 1 << REISERFS_QUOTA; 1009 } else { 1010 kfree(REISERFS_SB(s)->s_qf_names[qtype]); 1011 REISERFS_SB(s)->s_qf_names[qtype] = NULL; 1012 } 1013 } 1014 if (c == 'f') { 1015 if (!strcmp(arg, "vfsold")) 1016 REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_OLD; 1017 else if (!strcmp(arg, "vfsv0")) 1018 REISERFS_SB(s)->s_jquota_fmt = QFMT_VFS_V0; 1019 else { 1020 reiserfs_warning(s, 1021 "reiserfs_parse_options: unknown quota format specified."); 1022 return 0; 1023 } 1024 } 1025 #else 1026 if (c == 'u' || c == 'g' || c == 'f') { 1027 reiserfs_warning(s, 1028 "reiserfs_parse_options: journalled quota options not supported."); 1029 return 0; 1030 } 1031 #endif 1032 } 1033 1034 #ifdef CONFIG_QUOTA 1035 if (!REISERFS_SB(s)->s_jquota_fmt 1036 && (REISERFS_SB(s)->s_qf_names[USRQUOTA] 1037 || REISERFS_SB(s)->s_qf_names[GRPQUOTA])) { 1038 reiserfs_warning(s, 1039 "reiserfs_parse_options: journalled quota format not specified."); 1040 return 0; 1041 } 1042 /* This checking is not precise wrt the quota type but for our purposes it is sufficient */ 1043 if (!(*mount_options & (1 << REISERFS_QUOTA)) 1044 && sb_any_quota_enabled(s)) { 1045 reiserfs_warning(s, 1046 "reiserfs_parse_options: quota options must be present when quota is turned on."); 1047 return 0; 1048 } 1049 #endif 1050 1051 return 1; 1052 } 1053 1054 static void switch_data_mode(struct super_block *s, unsigned long mode) 1055 { 1056 REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) | 1057 (1 << REISERFS_DATA_ORDERED) | 1058 (1 << REISERFS_DATA_WRITEBACK)); 1059 REISERFS_SB(s)->s_mount_opt |= (1 << mode); 1060 } 1061 1062 static void handle_data_mode(struct super_block *s, unsigned long mount_options) 1063 { 1064 if (mount_options & (1 << REISERFS_DATA_LOG)) { 1065 if (!reiserfs_data_log(s)) { 1066 switch_data_mode(s, REISERFS_DATA_LOG); 1067 reiserfs_info(s, "switching to journaled data mode\n"); 1068 } 1069 } else if (mount_options & (1 << REISERFS_DATA_ORDERED)) { 1070 if (!reiserfs_data_ordered(s)) { 1071 switch_data_mode(s, REISERFS_DATA_ORDERED); 1072 reiserfs_info(s, "switching to ordered data mode\n"); 1073 } 1074 } else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) { 1075 if (!reiserfs_data_writeback(s)) { 1076 switch_data_mode(s, REISERFS_DATA_WRITEBACK); 1077 reiserfs_info(s, "switching to writeback data mode\n"); 1078 } 1079 } 1080 } 1081 1082 static void handle_barrier_mode(struct super_block *s, unsigned long bits) 1083 { 1084 int flush = (1 << REISERFS_BARRIER_FLUSH); 1085 int none = (1 << REISERFS_BARRIER_NONE); 1086 int all_barrier = flush | none; 1087 1088 if (bits & all_barrier) { 1089 REISERFS_SB(s)->s_mount_opt &= ~all_barrier; 1090 if (bits & flush) { 1091 REISERFS_SB(s)->s_mount_opt |= flush; 1092 printk("reiserfs: enabling write barrier flush mode\n"); 1093 } else if (bits & none) { 1094 REISERFS_SB(s)->s_mount_opt |= none; 1095 printk("reiserfs: write barriers turned off\n"); 1096 } 1097 } 1098 } 1099 1100 static void handle_attrs(struct super_block *s) 1101 { 1102 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s); 1103 1104 if (reiserfs_attrs(s)) { 1105 if (old_format_only(s)) { 1106 reiserfs_warning(s, 1107 "reiserfs: cannot support attributes on 3.5.x disk format"); 1108 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS); 1109 return; 1110 } 1111 if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) { 1112 reiserfs_warning(s, 1113 "reiserfs: cannot support attributes until flag is set in super-block"); 1114 REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS); 1115 } 1116 } 1117 } 1118 1119 static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg) 1120 { 1121 struct reiserfs_super_block *rs; 1122 struct reiserfs_transaction_handle th; 1123 unsigned long blocks; 1124 unsigned long mount_options = REISERFS_SB(s)->s_mount_opt; 1125 unsigned long safe_mask = 0; 1126 unsigned int commit_max_age = (unsigned int)-1; 1127 struct reiserfs_journal *journal = SB_JOURNAL(s); 1128 int err; 1129 #ifdef CONFIG_QUOTA 1130 int i; 1131 #endif 1132 1133 rs = SB_DISK_SUPER_BLOCK(s); 1134 1135 if (!reiserfs_parse_options 1136 (s, arg, &mount_options, &blocks, NULL, &commit_max_age)) { 1137 #ifdef CONFIG_QUOTA 1138 for (i = 0; i < MAXQUOTAS; i++) { 1139 kfree(REISERFS_SB(s)->s_qf_names[i]); 1140 REISERFS_SB(s)->s_qf_names[i] = NULL; 1141 } 1142 #endif 1143 return -EINVAL; 1144 } 1145 1146 handle_attrs(s); 1147 1148 /* Add options that are safe here */ 1149 safe_mask |= 1 << REISERFS_SMALLTAIL; 1150 safe_mask |= 1 << REISERFS_LARGETAIL; 1151 safe_mask |= 1 << REISERFS_NO_BORDER; 1152 safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION; 1153 safe_mask |= 1 << REISERFS_HASHED_RELOCATION; 1154 safe_mask |= 1 << REISERFS_TEST4; 1155 safe_mask |= 1 << REISERFS_ATTRS; 1156 safe_mask |= 1 << REISERFS_XATTRS_USER; 1157 safe_mask |= 1 << REISERFS_POSIXACL; 1158 safe_mask |= 1 << REISERFS_BARRIER_FLUSH; 1159 safe_mask |= 1 << REISERFS_BARRIER_NONE; 1160 safe_mask |= 1 << REISERFS_ERROR_RO; 1161 safe_mask |= 1 << REISERFS_ERROR_CONTINUE; 1162 safe_mask |= 1 << REISERFS_ERROR_PANIC; 1163 safe_mask |= 1 << REISERFS_QUOTA; 1164 1165 /* Update the bitmask, taking care to keep 1166 * the bits we're not allowed to change here */ 1167 REISERFS_SB(s)->s_mount_opt = 1168 (REISERFS_SB(s)-> 1169 s_mount_opt & ~safe_mask) | (mount_options & safe_mask); 1170 1171 if (commit_max_age != 0 && commit_max_age != (unsigned int)-1) { 1172 journal->j_max_commit_age = commit_max_age; 1173 journal->j_max_trans_age = commit_max_age; 1174 } else if (commit_max_age == 0) { 1175 /* 0 means restore defaults. */ 1176 journal->j_max_commit_age = journal->j_default_max_commit_age; 1177 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE; 1178 } 1179 1180 if (blocks) { 1181 int rc = reiserfs_resize(s, blocks); 1182 if (rc != 0) 1183 return rc; 1184 } 1185 1186 if (*mount_flags & MS_RDONLY) { 1187 reiserfs_xattr_init(s, *mount_flags); 1188 /* remount read-only */ 1189 if (s->s_flags & MS_RDONLY) 1190 /* it is read-only already */ 1191 return 0; 1192 /* try to remount file system with read-only permissions */ 1193 if (sb_umount_state(rs) == REISERFS_VALID_FS 1194 || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) { 1195 return 0; 1196 } 1197 1198 err = journal_begin(&th, s, 10); 1199 if (err) 1200 return err; 1201 1202 /* Mounting a rw partition read-only. */ 1203 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1); 1204 set_sb_umount_state(rs, REISERFS_SB(s)->s_mount_state); 1205 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s)); 1206 } else { 1207 /* remount read-write */ 1208 if (!(s->s_flags & MS_RDONLY)) { 1209 reiserfs_xattr_init(s, *mount_flags); 1210 return 0; /* We are read-write already */ 1211 } 1212 1213 if (reiserfs_is_journal_aborted(journal)) 1214 return journal->j_errno; 1215 1216 handle_data_mode(s, mount_options); 1217 handle_barrier_mode(s, mount_options); 1218 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs); 1219 s->s_flags &= ~MS_RDONLY; /* now it is safe to call journal_begin */ 1220 err = journal_begin(&th, s, 10); 1221 if (err) 1222 return err; 1223 1224 /* Mount a partition which is read-only, read-write */ 1225 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1); 1226 REISERFS_SB(s)->s_mount_state = sb_umount_state(rs); 1227 s->s_flags &= ~MS_RDONLY; 1228 set_sb_umount_state(rs, REISERFS_ERROR_FS); 1229 /* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */ 1230 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s)); 1231 REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS; 1232 } 1233 /* this will force a full flush of all journal lists */ 1234 SB_JOURNAL(s)->j_must_wait = 1; 1235 err = journal_end(&th, s, 10); 1236 if (err) 1237 return err; 1238 s->s_dirt = 0; 1239 1240 if (!(*mount_flags & MS_RDONLY)) { 1241 finish_unfinished(s); 1242 reiserfs_xattr_init(s, *mount_flags); 1243 } 1244 1245 return 0; 1246 } 1247 1248 static int read_super_block(struct super_block *s, int offset) 1249 { 1250 struct buffer_head *bh; 1251 struct reiserfs_super_block *rs; 1252 int fs_blocksize; 1253 1254 bh = sb_bread(s, offset / s->s_blocksize); 1255 if (!bh) { 1256 reiserfs_warning(s, "sh-2006: read_super_block: " 1257 "bread failed (dev %s, block %lu, size %lu)", 1258 reiserfs_bdevname(s), offset / s->s_blocksize, 1259 s->s_blocksize); 1260 return 1; 1261 } 1262 1263 rs = (struct reiserfs_super_block *)bh->b_data; 1264 if (!is_any_reiserfs_magic_string(rs)) { 1265 brelse(bh); 1266 return 1; 1267 } 1268 // 1269 // ok, reiserfs signature (old or new) found in at the given offset 1270 // 1271 fs_blocksize = sb_blocksize(rs); 1272 brelse(bh); 1273 sb_set_blocksize(s, fs_blocksize); 1274 1275 bh = sb_bread(s, offset / s->s_blocksize); 1276 if (!bh) { 1277 reiserfs_warning(s, "sh-2007: read_super_block: " 1278 "bread failed (dev %s, block %lu, size %lu)\n", 1279 reiserfs_bdevname(s), offset / s->s_blocksize, 1280 s->s_blocksize); 1281 return 1; 1282 } 1283 1284 rs = (struct reiserfs_super_block *)bh->b_data; 1285 if (sb_blocksize(rs) != s->s_blocksize) { 1286 reiserfs_warning(s, "sh-2011: read_super_block: " 1287 "can't find a reiserfs filesystem on (dev %s, block %Lu, size %lu)\n", 1288 reiserfs_bdevname(s), 1289 (unsigned long long)bh->b_blocknr, 1290 s->s_blocksize); 1291 brelse(bh); 1292 return 1; 1293 } 1294 1295 if (rs->s_v1.s_root_block == cpu_to_le32(-1)) { 1296 brelse(bh); 1297 reiserfs_warning(s, 1298 "Unfinished reiserfsck --rebuild-tree run detected. Please run\n" 1299 "reiserfsck --rebuild-tree and wait for a completion. If that fails\n" 1300 "get newer reiserfsprogs package"); 1301 return 1; 1302 } 1303 1304 SB_BUFFER_WITH_SB(s) = bh; 1305 SB_DISK_SUPER_BLOCK(s) = rs; 1306 1307 if (is_reiserfs_jr(rs)) { 1308 /* magic is of non-standard journal filesystem, look at s_version to 1309 find which format is in use */ 1310 if (sb_version(rs) == REISERFS_VERSION_2) 1311 reiserfs_warning(s, 1312 "read_super_block: found reiserfs format \"3.6\"" 1313 " with non-standard journal"); 1314 else if (sb_version(rs) == REISERFS_VERSION_1) 1315 reiserfs_warning(s, 1316 "read_super_block: found reiserfs format \"3.5\"" 1317 " with non-standard journal"); 1318 else { 1319 reiserfs_warning(s, 1320 "sh-2012: read_super_block: found unknown " 1321 "format \"%u\" of reiserfs with non-standard magic", 1322 sb_version(rs)); 1323 return 1; 1324 } 1325 } else 1326 /* s_version of standard format may contain incorrect information, 1327 so we just look at the magic string */ 1328 reiserfs_info(s, 1329 "found reiserfs format \"%s\" with standard journal\n", 1330 is_reiserfs_3_5(rs) ? "3.5" : "3.6"); 1331 1332 s->s_op = &reiserfs_sops; 1333 s->s_export_op = &reiserfs_export_ops; 1334 #ifdef CONFIG_QUOTA 1335 s->s_qcop = &reiserfs_qctl_operations; 1336 s->dq_op = &reiserfs_quota_operations; 1337 #endif 1338 1339 /* new format is limited by the 32 bit wide i_blocks field, want to 1340 ** be one full block below that. 1341 */ 1342 s->s_maxbytes = (512LL << 32) - s->s_blocksize; 1343 return 0; 1344 } 1345 1346 /* after journal replay, reread all bitmap and super blocks */ 1347 static int reread_meta_blocks(struct super_block *s) 1348 { 1349 ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s))); 1350 wait_on_buffer(SB_BUFFER_WITH_SB(s)); 1351 if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) { 1352 reiserfs_warning(s, 1353 "reread_meta_blocks, error reading the super"); 1354 return 1; 1355 } 1356 1357 return 0; 1358 } 1359 1360 ///////////////////////////////////////////////////// 1361 // hash detection stuff 1362 1363 // if root directory is empty - we set default - Yura's - hash and 1364 // warn about it 1365 // FIXME: we look for only one name in a directory. If tea and yura 1366 // bith have the same value - we ask user to send report to the 1367 // mailing list 1368 static __u32 find_hash_out(struct super_block *s) 1369 { 1370 int retval; 1371 struct inode *inode; 1372 struct cpu_key key; 1373 INITIALIZE_PATH(path); 1374 struct reiserfs_dir_entry de; 1375 __u32 hash = DEFAULT_HASH; 1376 1377 inode = s->s_root->d_inode; 1378 1379 do { // Some serious "goto"-hater was there ;) 1380 u32 teahash, r5hash, yurahash; 1381 1382 make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3); 1383 retval = search_by_entry_key(s, &key, &path, &de); 1384 if (retval == IO_ERROR) { 1385 pathrelse(&path); 1386 return UNSET_HASH; 1387 } 1388 if (retval == NAME_NOT_FOUND) 1389 de.de_entry_num--; 1390 set_de_name_and_namelen(&de); 1391 if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) { 1392 /* allow override in this case */ 1393 if (reiserfs_rupasov_hash(s)) { 1394 hash = YURA_HASH; 1395 } 1396 reiserfs_warning(s, "FS seems to be empty, autodetect " 1397 "is using the default hash"); 1398 break; 1399 } 1400 r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen)); 1401 teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen)); 1402 yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen)); 1403 if (((teahash == r5hash) 1404 && 1405 (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) 1406 == r5hash)) || ((teahash == yurahash) 1407 && (yurahash == 1408 GET_HASH_VALUE(deh_offset 1409 (& 1410 (de. 1411 de_deh[de. 1412 de_entry_num]))))) 1413 || ((r5hash == yurahash) 1414 && (yurahash == 1415 GET_HASH_VALUE(deh_offset 1416 (&(de.de_deh[de.de_entry_num])))))) { 1417 reiserfs_warning(s, 1418 "Unable to automatically detect hash function. " 1419 "Please mount with -o hash={tea,rupasov,r5}", 1420 reiserfs_bdevname(s)); 1421 hash = UNSET_HASH; 1422 break; 1423 } 1424 if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) == 1425 yurahash) 1426 hash = YURA_HASH; 1427 else if (GET_HASH_VALUE 1428 (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash) 1429 hash = TEA_HASH; 1430 else if (GET_HASH_VALUE 1431 (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash) 1432 hash = R5_HASH; 1433 else { 1434 reiserfs_warning(s, "Unrecognised hash function"); 1435 hash = UNSET_HASH; 1436 } 1437 } while (0); 1438 1439 pathrelse(&path); 1440 return hash; 1441 } 1442 1443 // finds out which hash names are sorted with 1444 static int what_hash(struct super_block *s) 1445 { 1446 __u32 code; 1447 1448 code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s)); 1449 1450 /* reiserfs_hash_detect() == true if any of the hash mount options 1451 ** were used. We must check them to make sure the user isn't 1452 ** using a bad hash value 1453 */ 1454 if (code == UNSET_HASH || reiserfs_hash_detect(s)) 1455 code = find_hash_out(s); 1456 1457 if (code != UNSET_HASH && reiserfs_hash_detect(s)) { 1458 /* detection has found the hash, and we must check against the 1459 ** mount options 1460 */ 1461 if (reiserfs_rupasov_hash(s) && code != YURA_HASH) { 1462 reiserfs_warning(s, "Error, %s hash detected, " 1463 "unable to force rupasov hash", 1464 reiserfs_hashname(code)); 1465 code = UNSET_HASH; 1466 } else if (reiserfs_tea_hash(s) && code != TEA_HASH) { 1467 reiserfs_warning(s, "Error, %s hash detected, " 1468 "unable to force tea hash", 1469 reiserfs_hashname(code)); 1470 code = UNSET_HASH; 1471 } else if (reiserfs_r5_hash(s) && code != R5_HASH) { 1472 reiserfs_warning(s, "Error, %s hash detected, " 1473 "unable to force r5 hash", 1474 reiserfs_hashname(code)); 1475 code = UNSET_HASH; 1476 } 1477 } else { 1478 /* find_hash_out was not called or could not determine the hash */ 1479 if (reiserfs_rupasov_hash(s)) { 1480 code = YURA_HASH; 1481 } else if (reiserfs_tea_hash(s)) { 1482 code = TEA_HASH; 1483 } else if (reiserfs_r5_hash(s)) { 1484 code = R5_HASH; 1485 } 1486 } 1487 1488 /* if we are mounted RW, and we have a new valid hash code, update 1489 ** the super 1490 */ 1491 if (code != UNSET_HASH && 1492 !(s->s_flags & MS_RDONLY) && 1493 code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) { 1494 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code); 1495 } 1496 return code; 1497 } 1498 1499 // return pointer to appropriate function 1500 static hashf_t hash_function(struct super_block *s) 1501 { 1502 switch (what_hash(s)) { 1503 case TEA_HASH: 1504 reiserfs_info(s, "Using tea hash to sort names\n"); 1505 return keyed_hash; 1506 case YURA_HASH: 1507 reiserfs_info(s, "Using rupasov hash to sort names\n"); 1508 return yura_hash; 1509 case R5_HASH: 1510 reiserfs_info(s, "Using r5 hash to sort names\n"); 1511 return r5_hash; 1512 } 1513 return NULL; 1514 } 1515 1516 // this is used to set up correct value for old partitions 1517 static int function2code(hashf_t func) 1518 { 1519 if (func == keyed_hash) 1520 return TEA_HASH; 1521 if (func == yura_hash) 1522 return YURA_HASH; 1523 if (func == r5_hash) 1524 return R5_HASH; 1525 1526 BUG(); // should never happen 1527 1528 return 0; 1529 } 1530 1531 #define SWARN(silent, s, ...) \ 1532 if (!(silent)) \ 1533 reiserfs_warning (s, __VA_ARGS__) 1534 1535 static int reiserfs_fill_super(struct super_block *s, void *data, int silent) 1536 { 1537 struct inode *root_inode; 1538 struct reiserfs_transaction_handle th; 1539 int old_format = 0; 1540 unsigned long blocks; 1541 unsigned int commit_max_age = 0; 1542 int jinit_done = 0; 1543 struct reiserfs_iget_args args; 1544 struct reiserfs_super_block *rs; 1545 char *jdev_name; 1546 struct reiserfs_sb_info *sbi; 1547 int errval = -EINVAL; 1548 1549 sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL); 1550 if (!sbi) { 1551 errval = -ENOMEM; 1552 goto error; 1553 } 1554 s->s_fs_info = sbi; 1555 /* Set default values for options: non-aggressive tails, RO on errors */ 1556 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL); 1557 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO); 1558 /* no preallocation minimum, be smart in 1559 reiserfs_file_write instead */ 1560 REISERFS_SB(s)->s_alloc_options.preallocmin = 0; 1561 /* Preallocate by 16 blocks (17-1) at once */ 1562 REISERFS_SB(s)->s_alloc_options.preallocsize = 17; 1563 #ifdef CONFIG_REISERFS_FS_XATTR 1564 /* Initialize the rwsem for xattr dir */ 1565 init_rwsem(&REISERFS_SB(s)->xattr_dir_sem); 1566 #endif 1567 /* setup default block allocator options */ 1568 reiserfs_init_alloc_options(s); 1569 1570 jdev_name = NULL; 1571 if (reiserfs_parse_options 1572 (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name, 1573 &commit_max_age) == 0) { 1574 goto error; 1575 } 1576 1577 if (blocks) { 1578 SWARN(silent, s, "jmacd-7: reiserfs_fill_super: resize option " 1579 "for remount only"); 1580 goto error; 1581 } 1582 1583 /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */ 1584 if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES)) 1585 old_format = 1; 1586 /* try new format (64-th 1k block), which can contain reiserfs super block */ 1587 else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) { 1588 SWARN(silent, s, 1589 "sh-2021: reiserfs_fill_super: can not find reiserfs on %s", 1590 reiserfs_bdevname(s)); 1591 goto error; 1592 } 1593 1594 rs = SB_DISK_SUPER_BLOCK(s); 1595 /* Let's do basic sanity check to verify that underlying device is not 1596 smaller than the filesystem. If the check fails then abort and scream, 1597 because bad stuff will happen otherwise. */ 1598 if (s->s_bdev && s->s_bdev->bd_inode 1599 && i_size_read(s->s_bdev->bd_inode) < 1600 sb_block_count(rs) * sb_blocksize(rs)) { 1601 SWARN(silent, s, 1602 "Filesystem on %s cannot be mounted because it is bigger than the device", 1603 reiserfs_bdevname(s)); 1604 SWARN(silent, s, 1605 "You may need to run fsck or increase size of your LVM partition"); 1606 SWARN(silent, s, 1607 "Or may be you forgot to reboot after fdisk when it told you to"); 1608 goto error; 1609 } 1610 1611 sbi->s_mount_state = SB_REISERFS_STATE(s); 1612 sbi->s_mount_state = REISERFS_VALID_FS; 1613 1614 if ((errval = reiserfs_init_bitmap_cache(s))) { 1615 SWARN(silent, s, 1616 "jmacd-8: reiserfs_fill_super: unable to read bitmap"); 1617 goto error; 1618 } 1619 errval = -EINVAL; 1620 #ifdef CONFIG_REISERFS_CHECK 1621 SWARN(silent, s, "CONFIG_REISERFS_CHECK is set ON"); 1622 SWARN(silent, s, "- it is slow mode for debugging."); 1623 #endif 1624 1625 /* make data=ordered the default */ 1626 if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) && 1627 !reiserfs_data_writeback(s)) { 1628 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED); 1629 } 1630 1631 if (reiserfs_data_log(s)) { 1632 reiserfs_info(s, "using journaled data mode\n"); 1633 } else if (reiserfs_data_ordered(s)) { 1634 reiserfs_info(s, "using ordered data mode\n"); 1635 } else { 1636 reiserfs_info(s, "using writeback data mode\n"); 1637 } 1638 if (reiserfs_barrier_flush(s)) { 1639 printk("reiserfs: using flush barriers\n"); 1640 } 1641 // set_device_ro(s->s_dev, 1) ; 1642 if (journal_init(s, jdev_name, old_format, commit_max_age)) { 1643 SWARN(silent, s, 1644 "sh-2022: reiserfs_fill_super: unable to initialize journal space"); 1645 goto error; 1646 } else { 1647 jinit_done = 1; /* once this is set, journal_release must be called 1648 ** if we error out of the mount 1649 */ 1650 } 1651 if (reread_meta_blocks(s)) { 1652 SWARN(silent, s, 1653 "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init"); 1654 goto error; 1655 } 1656 1657 if (replay_only(s)) 1658 goto error; 1659 1660 if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) { 1661 SWARN(silent, s, 1662 "clm-7000: Detected readonly device, marking FS readonly"); 1663 s->s_flags |= MS_RDONLY; 1664 } 1665 args.objectid = REISERFS_ROOT_OBJECTID; 1666 args.dirid = REISERFS_ROOT_PARENT_OBJECTID; 1667 root_inode = 1668 iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor, 1669 reiserfs_init_locked_inode, (void *)(&args)); 1670 if (!root_inode) { 1671 SWARN(silent, s, 1672 "jmacd-10: reiserfs_fill_super: get root inode failed"); 1673 goto error; 1674 } 1675 1676 if (root_inode->i_state & I_NEW) { 1677 reiserfs_read_locked_inode(root_inode, &args); 1678 unlock_new_inode(root_inode); 1679 } 1680 1681 s->s_root = d_alloc_root(root_inode); 1682 if (!s->s_root) { 1683 iput(root_inode); 1684 goto error; 1685 } 1686 // define and initialize hash function 1687 sbi->s_hash_function = hash_function(s); 1688 if (sbi->s_hash_function == NULL) { 1689 dput(s->s_root); 1690 s->s_root = NULL; 1691 goto error; 1692 } 1693 1694 if (is_reiserfs_3_5(rs) 1695 || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1)) 1696 set_bit(REISERFS_3_5, &(sbi->s_properties)); 1697 else if (old_format) 1698 set_bit(REISERFS_OLD_FORMAT, &(sbi->s_properties)); 1699 else 1700 set_bit(REISERFS_3_6, &(sbi->s_properties)); 1701 1702 if (!(s->s_flags & MS_RDONLY)) { 1703 1704 errval = journal_begin(&th, s, 1); 1705 if (errval) { 1706 dput(s->s_root); 1707 s->s_root = NULL; 1708 goto error; 1709 } 1710 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1); 1711 1712 set_sb_umount_state(rs, REISERFS_ERROR_FS); 1713 set_sb_fs_state(rs, 0); 1714 1715 if (old_format_only(s)) { 1716 /* filesystem of format 3.5 either with standard or non-standard 1717 journal */ 1718 if (convert_reiserfs(s)) { 1719 /* and -o conv is given */ 1720 if (!silent) 1721 reiserfs_info(s, 1722 "converting 3.5 filesystem to the 3.6 format"); 1723 1724 if (is_reiserfs_3_5(rs)) 1725 /* put magic string of 3.6 format. 2.2 will not be able to 1726 mount this filesystem anymore */ 1727 memcpy(rs->s_v1.s_magic, 1728 reiserfs_3_6_magic_string, 1729 sizeof 1730 (reiserfs_3_6_magic_string)); 1731 1732 set_sb_version(rs, REISERFS_VERSION_2); 1733 reiserfs_convert_objectid_map_v1(s); 1734 set_bit(REISERFS_3_6, &(sbi->s_properties)); 1735 clear_bit(REISERFS_3_5, &(sbi->s_properties)); 1736 } else if (!silent) { 1737 reiserfs_info(s, "using 3.5.x disk format\n"); 1738 } 1739 } 1740 1741 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s)); 1742 errval = journal_end(&th, s, 1); 1743 if (errval) { 1744 dput(s->s_root); 1745 s->s_root = NULL; 1746 goto error; 1747 } 1748 1749 if ((errval = reiserfs_xattr_init(s, s->s_flags))) { 1750 dput(s->s_root); 1751 s->s_root = NULL; 1752 goto error; 1753 } 1754 1755 /* look for files which were to be removed in previous session */ 1756 finish_unfinished(s); 1757 } else { 1758 if (old_format_only(s) && !silent) { 1759 reiserfs_info(s, "using 3.5.x disk format\n"); 1760 } 1761 1762 if ((errval = reiserfs_xattr_init(s, s->s_flags))) { 1763 dput(s->s_root); 1764 s->s_root = NULL; 1765 goto error; 1766 } 1767 } 1768 // mark hash in super block: it could be unset. overwrite should be ok 1769 set_sb_hash_function_code(rs, function2code(sbi->s_hash_function)); 1770 1771 handle_attrs(s); 1772 1773 reiserfs_proc_info_init(s); 1774 1775 init_waitqueue_head(&(sbi->s_wait)); 1776 spin_lock_init(&sbi->bitmap_lock); 1777 1778 return (0); 1779 1780 error: 1781 if (jinit_done) { /* kill the commit thread, free journal ram */ 1782 journal_release_error(NULL, s); 1783 } 1784 1785 reiserfs_free_bitmap_cache(s); 1786 if (SB_BUFFER_WITH_SB(s)) 1787 brelse(SB_BUFFER_WITH_SB(s)); 1788 #ifdef CONFIG_QUOTA 1789 { 1790 int j; 1791 for (j = 0; j < MAXQUOTAS; j++) { 1792 kfree(sbi->s_qf_names[j]); 1793 sbi->s_qf_names[j] = NULL; 1794 } 1795 } 1796 #endif 1797 kfree(sbi); 1798 1799 s->s_fs_info = NULL; 1800 return errval; 1801 } 1802 1803 static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf) 1804 { 1805 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb); 1806 1807 buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize)); 1808 buf->f_bfree = sb_free_blocks(rs); 1809 buf->f_bavail = buf->f_bfree; 1810 buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1; 1811 buf->f_bsize = dentry->d_sb->s_blocksize; 1812 /* changed to accommodate gcc folks. */ 1813 buf->f_type = REISERFS_SUPER_MAGIC; 1814 return 0; 1815 } 1816 1817 #ifdef CONFIG_QUOTA 1818 static int reiserfs_dquot_initialize(struct inode *inode, int type) 1819 { 1820 struct reiserfs_transaction_handle th; 1821 int ret, err; 1822 1823 /* We may create quota structure so we need to reserve enough blocks */ 1824 reiserfs_write_lock(inode->i_sb); 1825 ret = 1826 journal_begin(&th, inode->i_sb, 1827 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb)); 1828 if (ret) 1829 goto out; 1830 ret = dquot_initialize(inode, type); 1831 err = 1832 journal_end(&th, inode->i_sb, 1833 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb)); 1834 if (!ret && err) 1835 ret = err; 1836 out: 1837 reiserfs_write_unlock(inode->i_sb); 1838 return ret; 1839 } 1840 1841 static int reiserfs_dquot_drop(struct inode *inode) 1842 { 1843 struct reiserfs_transaction_handle th; 1844 int ret, err; 1845 1846 /* We may delete quota structure so we need to reserve enough blocks */ 1847 reiserfs_write_lock(inode->i_sb); 1848 ret = 1849 journal_begin(&th, inode->i_sb, 1850 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)); 1851 if (ret) 1852 goto out; 1853 ret = dquot_drop(inode); 1854 err = 1855 journal_end(&th, inode->i_sb, 1856 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)); 1857 if (!ret && err) 1858 ret = err; 1859 out: 1860 reiserfs_write_unlock(inode->i_sb); 1861 return ret; 1862 } 1863 1864 static int reiserfs_write_dquot(struct dquot *dquot) 1865 { 1866 struct reiserfs_transaction_handle th; 1867 int ret, err; 1868 1869 reiserfs_write_lock(dquot->dq_sb); 1870 ret = 1871 journal_begin(&th, dquot->dq_sb, 1872 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb)); 1873 if (ret) 1874 goto out; 1875 ret = dquot_commit(dquot); 1876 err = 1877 journal_end(&th, dquot->dq_sb, 1878 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb)); 1879 if (!ret && err) 1880 ret = err; 1881 out: 1882 reiserfs_write_unlock(dquot->dq_sb); 1883 return ret; 1884 } 1885 1886 static int reiserfs_acquire_dquot(struct dquot *dquot) 1887 { 1888 struct reiserfs_transaction_handle th; 1889 int ret, err; 1890 1891 reiserfs_write_lock(dquot->dq_sb); 1892 ret = 1893 journal_begin(&th, dquot->dq_sb, 1894 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb)); 1895 if (ret) 1896 goto out; 1897 ret = dquot_acquire(dquot); 1898 err = 1899 journal_end(&th, dquot->dq_sb, 1900 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb)); 1901 if (!ret && err) 1902 ret = err; 1903 out: 1904 reiserfs_write_unlock(dquot->dq_sb); 1905 return ret; 1906 } 1907 1908 static int reiserfs_release_dquot(struct dquot *dquot) 1909 { 1910 struct reiserfs_transaction_handle th; 1911 int ret, err; 1912 1913 reiserfs_write_lock(dquot->dq_sb); 1914 ret = 1915 journal_begin(&th, dquot->dq_sb, 1916 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb)); 1917 if (ret) 1918 goto out; 1919 ret = dquot_release(dquot); 1920 err = 1921 journal_end(&th, dquot->dq_sb, 1922 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb)); 1923 if (!ret && err) 1924 ret = err; 1925 out: 1926 reiserfs_write_unlock(dquot->dq_sb); 1927 return ret; 1928 } 1929 1930 static int reiserfs_mark_dquot_dirty(struct dquot *dquot) 1931 { 1932 /* Are we journalling quotas? */ 1933 if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] || 1934 REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) { 1935 dquot_mark_dquot_dirty(dquot); 1936 return reiserfs_write_dquot(dquot); 1937 } else 1938 return dquot_mark_dquot_dirty(dquot); 1939 } 1940 1941 static int reiserfs_write_info(struct super_block *sb, int type) 1942 { 1943 struct reiserfs_transaction_handle th; 1944 int ret, err; 1945 1946 /* Data block + inode block */ 1947 reiserfs_write_lock(sb); 1948 ret = journal_begin(&th, sb, 2); 1949 if (ret) 1950 goto out; 1951 ret = dquot_commit_info(sb, type); 1952 err = journal_end(&th, sb, 2); 1953 if (!ret && err) 1954 ret = err; 1955 out: 1956 reiserfs_write_unlock(sb); 1957 return ret; 1958 } 1959 1960 /* 1961 * Turn on quotas during mount time - we need to find the quota file and such... 1962 */ 1963 static int reiserfs_quota_on_mount(struct super_block *sb, int type) 1964 { 1965 return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type], 1966 REISERFS_SB(sb)->s_jquota_fmt, type); 1967 } 1968 1969 /* 1970 * Standard function to be called on quota_on 1971 */ 1972 static int reiserfs_quota_on(struct super_block *sb, int type, int format_id, 1973 char *path) 1974 { 1975 int err; 1976 struct nameidata nd; 1977 1978 if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA))) 1979 return -EINVAL; 1980 err = path_lookup(path, LOOKUP_FOLLOW, &nd); 1981 if (err) 1982 return err; 1983 /* Quotafile not on the same filesystem? */ 1984 if (nd.mnt->mnt_sb != sb) { 1985 path_release(&nd); 1986 return -EXDEV; 1987 } 1988 /* We must not pack tails for quota files on reiserfs for quota IO to work */ 1989 if (!REISERFS_I(nd.dentry->d_inode)->i_flags & i_nopack_mask) { 1990 reiserfs_warning(sb, 1991 "reiserfs: Quota file must have tail packing disabled."); 1992 path_release(&nd); 1993 return -EINVAL; 1994 } 1995 /* Not journalling quota? No more tests needed... */ 1996 if (!REISERFS_SB(sb)->s_qf_names[USRQUOTA] && 1997 !REISERFS_SB(sb)->s_qf_names[GRPQUOTA]) { 1998 path_release(&nd); 1999 return vfs_quota_on(sb, type, format_id, path); 2000 } 2001 /* Quotafile not of fs root? */ 2002 if (nd.dentry->d_parent->d_inode != sb->s_root->d_inode) 2003 reiserfs_warning(sb, 2004 "reiserfs: Quota file not on filesystem root. " 2005 "Journalled quota will not work."); 2006 path_release(&nd); 2007 return vfs_quota_on(sb, type, format_id, path); 2008 } 2009 2010 /* Read data from quotafile - avoid pagecache and such because we cannot afford 2011 * acquiring the locks... As quota files are never truncated and quota code 2012 * itself serializes the operations (and noone else should touch the files) 2013 * we don't have to be afraid of races */ 2014 static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data, 2015 size_t len, loff_t off) 2016 { 2017 struct inode *inode = sb_dqopt(sb)->files[type]; 2018 unsigned long blk = off >> sb->s_blocksize_bits; 2019 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy; 2020 size_t toread; 2021 struct buffer_head tmp_bh, *bh; 2022 loff_t i_size = i_size_read(inode); 2023 2024 if (off > i_size) 2025 return 0; 2026 if (off + len > i_size) 2027 len = i_size - off; 2028 toread = len; 2029 while (toread > 0) { 2030 tocopy = 2031 sb->s_blocksize - offset < 2032 toread ? sb->s_blocksize - offset : toread; 2033 tmp_bh.b_state = 0; 2034 /* Quota files are without tails so we can safely use this function */ 2035 reiserfs_write_lock(sb); 2036 err = reiserfs_get_block(inode, blk, &tmp_bh, 0); 2037 reiserfs_write_unlock(sb); 2038 if (err) 2039 return err; 2040 if (!buffer_mapped(&tmp_bh)) /* A hole? */ 2041 memset(data, 0, tocopy); 2042 else { 2043 bh = sb_bread(sb, tmp_bh.b_blocknr); 2044 if (!bh) 2045 return -EIO; 2046 memcpy(data, bh->b_data + offset, tocopy); 2047 brelse(bh); 2048 } 2049 offset = 0; 2050 toread -= tocopy; 2051 data += tocopy; 2052 blk++; 2053 } 2054 return len; 2055 } 2056 2057 /* Write to quotafile (we know the transaction is already started and has 2058 * enough credits) */ 2059 static ssize_t reiserfs_quota_write(struct super_block *sb, int type, 2060 const char *data, size_t len, loff_t off) 2061 { 2062 struct inode *inode = sb_dqopt(sb)->files[type]; 2063 unsigned long blk = off >> sb->s_blocksize_bits; 2064 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy; 2065 int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL; 2066 size_t towrite = len; 2067 struct buffer_head tmp_bh, *bh; 2068 2069 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA); 2070 while (towrite > 0) { 2071 tocopy = sb->s_blocksize - offset < towrite ? 2072 sb->s_blocksize - offset : towrite; 2073 tmp_bh.b_state = 0; 2074 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE); 2075 if (err) 2076 goto out; 2077 if (offset || tocopy != sb->s_blocksize) 2078 bh = sb_bread(sb, tmp_bh.b_blocknr); 2079 else 2080 bh = sb_getblk(sb, tmp_bh.b_blocknr); 2081 if (!bh) { 2082 err = -EIO; 2083 goto out; 2084 } 2085 lock_buffer(bh); 2086 memcpy(bh->b_data + offset, data, tocopy); 2087 flush_dcache_page(bh->b_page); 2088 set_buffer_uptodate(bh); 2089 unlock_buffer(bh); 2090 reiserfs_prepare_for_journal(sb, bh, 1); 2091 journal_mark_dirty(current->journal_info, sb, bh); 2092 if (!journal_quota) 2093 reiserfs_add_ordered_list(inode, bh); 2094 brelse(bh); 2095 offset = 0; 2096 towrite -= tocopy; 2097 data += tocopy; 2098 blk++; 2099 } 2100 out: 2101 if (len == towrite) 2102 return err; 2103 if (inode->i_size < off + len - towrite) 2104 i_size_write(inode, off + len - towrite); 2105 inode->i_version++; 2106 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 2107 mark_inode_dirty(inode); 2108 mutex_unlock(&inode->i_mutex); 2109 return len - towrite; 2110 } 2111 2112 #endif 2113 2114 static int get_super_block(struct file_system_type *fs_type, 2115 int flags, const char *dev_name, 2116 void *data, struct vfsmount *mnt) 2117 { 2118 return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super, 2119 mnt); 2120 } 2121 2122 static int __init init_reiserfs_fs(void) 2123 { 2124 int ret; 2125 2126 if ((ret = init_inodecache())) { 2127 return ret; 2128 } 2129 2130 if ((ret = reiserfs_xattr_register_handlers())) 2131 goto failed_reiserfs_xattr_register_handlers; 2132 2133 reiserfs_proc_info_global_init(); 2134 reiserfs_proc_register_global("version", 2135 reiserfs_global_version_in_proc); 2136 2137 ret = register_filesystem(&reiserfs_fs_type); 2138 2139 if (ret == 0) { 2140 return 0; 2141 } 2142 2143 reiserfs_xattr_unregister_handlers(); 2144 2145 failed_reiserfs_xattr_register_handlers: 2146 reiserfs_proc_unregister_global("version"); 2147 reiserfs_proc_info_global_done(); 2148 destroy_inodecache(); 2149 2150 return ret; 2151 } 2152 2153 static void __exit exit_reiserfs_fs(void) 2154 { 2155 reiserfs_xattr_unregister_handlers(); 2156 reiserfs_proc_unregister_global("version"); 2157 reiserfs_proc_info_global_done(); 2158 unregister_filesystem(&reiserfs_fs_type); 2159 destroy_inodecache(); 2160 } 2161 2162 struct file_system_type reiserfs_fs_type = { 2163 .owner = THIS_MODULE, 2164 .name = "reiserfs", 2165 .get_sb = get_super_block, 2166 .kill_sb = reiserfs_kill_sb, 2167 .fs_flags = FS_REQUIRES_DEV, 2168 }; 2169 2170 MODULE_DESCRIPTION("ReiserFS journaled filesystem"); 2171 MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>"); 2172 MODULE_LICENSE("GPL"); 2173 2174 module_init(init_reiserfs_fs); 2175 module_exit(exit_reiserfs_fs); 2176