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 30struct file_system_type reiserfs_fs_type; 31 32static const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING; 33static const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING; 34static const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING; 35 36int 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 42int 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 48int 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 54static 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 60static int reiserfs_remount(struct super_block *s, int *flags, char *data); 61static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf); 62 63static 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 80static void reiserfs_write_super(struct super_block *s) 81{ 82 reiserfs_sync_fs(s, 1); 83} 84 85static 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 105static void reiserfs_unlockfs(struct super_block *s) 106{ 107 reiserfs_allow_writes(s); 108} 109 110extern 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 */ 119static 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 139static int reiserfs_quota_on_mount(struct super_block *, int); 140#endif 141 142/* look for uncompleted unlinks and truncates and complete them */ 143static 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 */ 311void 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 */ 392int 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 432static 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 452static 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 493static struct kmem_cache *reiserfs_inode_cachep; 494 495static 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 505static void reiserfs_destroy_inode(struct inode *inode) 506{ 507 kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode)); 508} 509 510static 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 522static 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 535static 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 */ 541static 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 568static 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 587static ssize_t reiserfs_quota_write(struct super_block *, int, const char *, 588 size_t, loff_t); 589static ssize_t reiserfs_quota_read(struct super_block *, int, char *, size_t, 590 loff_t); 591#endif 592 593static 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 616static int reiserfs_dquot_initialize(struct inode *, int); 617static int reiserfs_dquot_drop(struct inode *); 618static int reiserfs_write_dquot(struct dquot *); 619static int reiserfs_acquire_dquot(struct dquot *); 620static int reiserfs_release_dquot(struct dquot *); 621static int reiserfs_mark_dquot_dirty(struct dquot *); 622static int reiserfs_write_info(struct super_block *, int); 623static int reiserfs_quota_on(struct super_block *, int, int, char *); 624 625static 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 640static 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 651static 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. */ 660typedef 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 */ 674typedef 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= */ 686static 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= */ 697static 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 */ 705static 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 715static 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 722static 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 */ 740static 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 */ 858static 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 1054static 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 1062static 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 1082static 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 1100static 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 1119static 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 1248static 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 */ 1347static 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// bith have the same value - we ask user to send report to the 1366// mailing list 1367static __u32 find_hash_out(struct super_block *s) 1368{ 1369 int retval; 1370 struct inode *inode; 1371 struct cpu_key key; 1372 INITIALIZE_PATH(path); 1373 struct reiserfs_dir_entry de; 1374 __u32 hash = DEFAULT_HASH; 1375 1376 inode = s->s_root->d_inode; 1377 1378 do { // Some serious "goto"-hater was there ;) 1379 u32 teahash, r5hash, yurahash; 1380 1381 make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3); 1382 retval = search_by_entry_key(s, &key, &path, &de); 1383 if (retval == IO_ERROR) { 1384 pathrelse(&path); 1385 return UNSET_HASH; 1386 } 1387 if (retval == NAME_NOT_FOUND) 1388 de.de_entry_num--; 1389 set_de_name_and_namelen(&de); 1390 if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) { 1391 /* allow override in this case */ 1392 if (reiserfs_rupasov_hash(s)) { 1393 hash = YURA_HASH; 1394 } 1395 reiserfs_warning(s, "FS seems to be empty, autodetect " 1396 "is using the default hash"); 1397 break; 1398 } 1399 r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen)); 1400 teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen)); 1401 yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen)); 1402 if (((teahash == r5hash) 1403 && 1404 (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) 1405 == r5hash)) || ((teahash == yurahash) 1406 && (yurahash == 1407 GET_HASH_VALUE(deh_offset 1408 (& 1409 (de. 1410 de_deh[de. 1411 de_entry_num]))))) 1412 || ((r5hash == yurahash) 1413 && (yurahash == 1414 GET_HASH_VALUE(deh_offset 1415 (&(de.de_deh[de.de_entry_num])))))) { 1416 reiserfs_warning(s, 1417 "Unable to automatically detect hash function. " 1418 "Please mount with -o hash={tea,rupasov,r5}", 1419 reiserfs_bdevname(s)); 1420 hash = UNSET_HASH; 1421 break; 1422 } 1423 if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) == 1424 yurahash) 1425 hash = YURA_HASH; 1426 else if (GET_HASH_VALUE 1427 (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash) 1428 hash = TEA_HASH; 1429 else if (GET_HASH_VALUE 1430 (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash) 1431 hash = R5_HASH; 1432 else { 1433 reiserfs_warning(s, "Unrecognised hash function"); 1434 hash = UNSET_HASH; 1435 } 1436 } while (0); 1437 1438 pathrelse(&path); 1439 return hash; 1440} 1441 1442// finds out which hash names are sorted with 1443static int what_hash(struct super_block *s) 1444{ 1445 __u32 code; 1446 1447 code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s)); 1448 1449 /* reiserfs_hash_detect() == true if any of the hash mount options 1450 ** were used. We must check them to make sure the user isn't 1451 ** using a bad hash value 1452 */ 1453 if (code == UNSET_HASH || reiserfs_hash_detect(s)) 1454 code = find_hash_out(s); 1455 1456 if (code != UNSET_HASH && reiserfs_hash_detect(s)) { 1457 /* detection has found the hash, and we must check against the 1458 ** mount options 1459 */ 1460 if (reiserfs_rupasov_hash(s) && code != YURA_HASH) { 1461 reiserfs_warning(s, "Error, %s hash detected, " 1462 "unable to force rupasov hash", 1463 reiserfs_hashname(code)); 1464 code = UNSET_HASH; 1465 } else if (reiserfs_tea_hash(s) && code != TEA_HASH) { 1466 reiserfs_warning(s, "Error, %s hash detected, " 1467 "unable to force tea hash", 1468 reiserfs_hashname(code)); 1469 code = UNSET_HASH; 1470 } else if (reiserfs_r5_hash(s) && code != R5_HASH) { 1471 reiserfs_warning(s, "Error, %s hash detected, " 1472 "unable to force r5 hash", 1473 reiserfs_hashname(code)); 1474 code = UNSET_HASH; 1475 } 1476 } else { 1477 /* find_hash_out was not called or could not determine the hash */ 1478 if (reiserfs_rupasov_hash(s)) { 1479 code = YURA_HASH; 1480 } else if (reiserfs_tea_hash(s)) { 1481 code = TEA_HASH; 1482 } else if (reiserfs_r5_hash(s)) { 1483 code = R5_HASH; 1484 } 1485 } 1486 1487 /* if we are mounted RW, and we have a new valid hash code, update 1488 ** the super 1489 */ 1490 if (code != UNSET_HASH && 1491 !(s->s_flags & MS_RDONLY) && 1492 code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) { 1493 set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code); 1494 } 1495 return code; 1496} 1497 1498// return pointer to appropriate function 1499static hashf_t hash_function(struct super_block *s) 1500{ 1501 switch (what_hash(s)) { 1502 case TEA_HASH: 1503 reiserfs_info(s, "Using tea hash to sort names\n"); 1504 return keyed_hash; 1505 case YURA_HASH: 1506 reiserfs_info(s, "Using rupasov hash to sort names\n"); 1507 return yura_hash; 1508 case R5_HASH: 1509 reiserfs_info(s, "Using r5 hash to sort names\n"); 1510 return r5_hash; 1511 } 1512 return NULL; 1513} 1514 1515// this is used to set up correct value for old partitions 1516static int function2code(hashf_t func) 1517{ 1518 if (func == keyed_hash) 1519 return TEA_HASH; 1520 if (func == yura_hash) 1521 return YURA_HASH; 1522 if (func == r5_hash) 1523 return R5_HASH; 1524 1525 BUG(); // should never happen 1526 1527 return 0; 1528} 1529 1530#define SWARN(silent, s, ...) \ 1531 if (!(silent)) \ 1532 reiserfs_warning (s, __VA_ARGS__) 1533 1534static int reiserfs_fill_super(struct super_block *s, void *data, int silent) 1535{ 1536 struct inode *root_inode; 1537 struct reiserfs_transaction_handle th; 1538 int old_format = 0; 1539 unsigned long blocks; 1540 unsigned int commit_max_age = 0; 1541 int jinit_done = 0; 1542 struct reiserfs_iget_args args; 1543 struct reiserfs_super_block *rs; 1544 char *jdev_name; 1545 struct reiserfs_sb_info *sbi; 1546 int errval = -EINVAL; 1547 1548 sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL); 1549 if (!sbi) { 1550 errval = -ENOMEM; 1551 goto error; 1552 } 1553 s->s_fs_info = sbi; 1554 /* Set default values for options: non-aggressive tails, RO on errors */ 1555 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL); 1556 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO); 1557 /* no preallocation minimum, be smart in 1558 reiserfs_file_write instead */ 1559 REISERFS_SB(s)->s_alloc_options.preallocmin = 0; 1560 /* Preallocate by 16 blocks (17-1) at once */ 1561 REISERFS_SB(s)->s_alloc_options.preallocsize = 17; 1562#ifdef CONFIG_REISERFS_FS_XATTR 1563 /* Initialize the rwsem for xattr dir */ 1564 init_rwsem(&REISERFS_SB(s)->xattr_dir_sem); 1565#endif 1566 /* setup default block allocator options */ 1567 reiserfs_init_alloc_options(s); 1568 1569 jdev_name = NULL; 1570 if (reiserfs_parse_options 1571 (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name, 1572 &commit_max_age) == 0) { 1573 goto error; 1574 } 1575 1576 if (blocks) { 1577 SWARN(silent, s, "jmacd-7: reiserfs_fill_super: resize option " 1578 "for remount only"); 1579 goto error; 1580 } 1581 1582 /* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */ 1583 if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES)) 1584 old_format = 1; 1585 /* try new format (64-th 1k block), which can contain reiserfs super block */ 1586 else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) { 1587 SWARN(silent, s, 1588 "sh-2021: reiserfs_fill_super: can not find reiserfs on %s", 1589 reiserfs_bdevname(s)); 1590 goto error; 1591 } 1592 1593 rs = SB_DISK_SUPER_BLOCK(s); 1594 /* Let's do basic sanity check to verify that underlying device is not 1595 smaller than the filesystem. If the check fails then abort and scream, 1596 because bad stuff will happen otherwise. */ 1597 if (s->s_bdev && s->s_bdev->bd_inode 1598 && i_size_read(s->s_bdev->bd_inode) < 1599 sb_block_count(rs) * sb_blocksize(rs)) { 1600 SWARN(silent, s, 1601 "Filesystem on %s cannot be mounted because it is bigger than the device", 1602 reiserfs_bdevname(s)); 1603 SWARN(silent, s, 1604 "You may need to run fsck or increase size of your LVM partition"); 1605 SWARN(silent, s, 1606 "Or may be you forgot to reboot after fdisk when it told you to"); 1607 goto error; 1608 } 1609 1610 sbi->s_mount_state = SB_REISERFS_STATE(s); 1611 sbi->s_mount_state = REISERFS_VALID_FS; 1612 1613 if ((errval = reiserfs_init_bitmap_cache(s))) { 1614 SWARN(silent, s, 1615 "jmacd-8: reiserfs_fill_super: unable to read bitmap"); 1616 goto error; 1617 } 1618 errval = -EINVAL; 1619#ifdef CONFIG_REISERFS_CHECK 1620 SWARN(silent, s, "CONFIG_REISERFS_CHECK is set ON"); 1621 SWARN(silent, s, "- it is slow mode for debugging."); 1622#endif 1623 1624 /* make data=ordered the default */ 1625 if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) && 1626 !reiserfs_data_writeback(s)) { 1627 REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED); 1628 } 1629 1630 if (reiserfs_data_log(s)) { 1631 reiserfs_info(s, "using journaled data mode\n"); 1632 } else if (reiserfs_data_ordered(s)) { 1633 reiserfs_info(s, "using ordered data mode\n"); 1634 } else { 1635 reiserfs_info(s, "using writeback data mode\n"); 1636 } 1637 if (reiserfs_barrier_flush(s)) { 1638 printk("reiserfs: using flush barriers\n"); 1639 } 1640 // set_device_ro(s->s_dev, 1) ; 1641 if (journal_init(s, jdev_name, old_format, commit_max_age)) { 1642 SWARN(silent, s, 1643 "sh-2022: reiserfs_fill_super: unable to initialize journal space"); 1644 goto error; 1645 } else { 1646 jinit_done = 1; /* once this is set, journal_release must be called 1647 ** if we error out of the mount 1648 */ 1649 } 1650 if (reread_meta_blocks(s)) { 1651 SWARN(silent, s, 1652 "jmacd-9: reiserfs_fill_super: unable to reread meta blocks after journal init"); 1653 goto error; 1654 } 1655 1656 if (replay_only(s)) 1657 goto error; 1658 1659 if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) { 1660 SWARN(silent, s, 1661 "clm-7000: Detected readonly device, marking FS readonly"); 1662 s->s_flags |= MS_RDONLY; 1663 } 1664 args.objectid = REISERFS_ROOT_OBJECTID; 1665 args.dirid = REISERFS_ROOT_PARENT_OBJECTID; 1666 root_inode = 1667 iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor, 1668 reiserfs_init_locked_inode, (void *)(&args)); 1669 if (!root_inode) { 1670 SWARN(silent, s, 1671 "jmacd-10: reiserfs_fill_super: get root inode failed"); 1672 goto error; 1673 } 1674 1675 if (root_inode->i_state & I_NEW) { 1676 reiserfs_read_locked_inode(root_inode, &args); 1677 unlock_new_inode(root_inode); 1678 } 1679 1680 s->s_root = d_alloc_root(root_inode); 1681 if (!s->s_root) { 1682 iput(root_inode); 1683 goto error; 1684 } 1685 // define and initialize hash function 1686 sbi->s_hash_function = hash_function(s); 1687 if (sbi->s_hash_function == NULL) { 1688 dput(s->s_root); 1689 s->s_root = NULL; 1690 goto error; 1691 } 1692 1693 if (is_reiserfs_3_5(rs) 1694 || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1)) 1695 set_bit(REISERFS_3_5, &(sbi->s_properties)); 1696 else if (old_format) 1697 set_bit(REISERFS_OLD_FORMAT, &(sbi->s_properties)); 1698 else 1699 set_bit(REISERFS_3_6, &(sbi->s_properties)); 1700 1701 if (!(s->s_flags & MS_RDONLY)) { 1702 1703 errval = journal_begin(&th, s, 1); 1704 if (errval) { 1705 dput(s->s_root); 1706 s->s_root = NULL; 1707 goto error; 1708 } 1709 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1); 1710 1711 set_sb_umount_state(rs, REISERFS_ERROR_FS); 1712 set_sb_fs_state(rs, 0); 1713 1714 if (old_format_only(s)) { 1715 /* filesystem of format 3.5 either with standard or non-standard 1716 journal */ 1717 if (convert_reiserfs(s)) { 1718 /* and -o conv is given */ 1719 if (!silent) 1720 reiserfs_info(s, 1721 "converting 3.5 filesystem to the 3.6 format"); 1722 1723 if (is_reiserfs_3_5(rs)) 1724 /* put magic string of 3.6 format. 2.2 will not be able to 1725 mount this filesystem anymore */ 1726 memcpy(rs->s_v1.s_magic, 1727 reiserfs_3_6_magic_string, 1728 sizeof 1729 (reiserfs_3_6_magic_string)); 1730 1731 set_sb_version(rs, REISERFS_VERSION_2); 1732 reiserfs_convert_objectid_map_v1(s); 1733 set_bit(REISERFS_3_6, &(sbi->s_properties)); 1734 clear_bit(REISERFS_3_5, &(sbi->s_properties)); 1735 } else if (!silent) { 1736 reiserfs_info(s, "using 3.5.x disk format\n"); 1737 } 1738 } 1739 1740 journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s)); 1741 errval = journal_end(&th, s, 1); 1742 if (errval) { 1743 dput(s->s_root); 1744 s->s_root = NULL; 1745 goto error; 1746 } 1747 1748 if ((errval = reiserfs_xattr_init(s, s->s_flags))) { 1749 dput(s->s_root); 1750 s->s_root = NULL; 1751 goto error; 1752 } 1753 1754 /* look for files which were to be removed in previous session */ 1755 finish_unfinished(s); 1756 } else { 1757 if (old_format_only(s) && !silent) { 1758 reiserfs_info(s, "using 3.5.x disk format\n"); 1759 } 1760 1761 if ((errval = reiserfs_xattr_init(s, s->s_flags))) { 1762 dput(s->s_root); 1763 s->s_root = NULL; 1764 goto error; 1765 } 1766 } 1767 // mark hash in super block: it could be unset. overwrite should be ok 1768 set_sb_hash_function_code(rs, function2code(sbi->s_hash_function)); 1769 1770 handle_attrs(s); 1771 1772 reiserfs_proc_info_init(s); 1773 1774 init_waitqueue_head(&(sbi->s_wait)); 1775 spin_lock_init(&sbi->bitmap_lock); 1776 1777 return (0); 1778 1779 error: 1780 if (jinit_done) { /* kill the commit thread, free journal ram */ 1781 journal_release_error(NULL, s); 1782 } 1783 1784 reiserfs_free_bitmap_cache(s); 1785 if (SB_BUFFER_WITH_SB(s)) 1786 brelse(SB_BUFFER_WITH_SB(s)); 1787#ifdef CONFIG_QUOTA 1788 { 1789 int j; 1790 for (j = 0; j < MAXQUOTAS; j++) { 1791 kfree(sbi->s_qf_names[j]); 1792 sbi->s_qf_names[j] = NULL; 1793 } 1794 } 1795#endif 1796 kfree(sbi); 1797 1798 s->s_fs_info = NULL; 1799 return errval; 1800} 1801 1802static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf) 1803{ 1804 struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb); 1805 1806 buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize)); 1807 buf->f_bfree = sb_free_blocks(rs); 1808 buf->f_bavail = buf->f_bfree; 1809 buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1; 1810 buf->f_bsize = dentry->d_sb->s_blocksize; 1811 /* changed to accommodate gcc folks. */ 1812 buf->f_type = REISERFS_SUPER_MAGIC; 1813 return 0; 1814} 1815 1816#ifdef CONFIG_QUOTA 1817static int reiserfs_dquot_initialize(struct inode *inode, int type) 1818{ 1819 struct reiserfs_transaction_handle th; 1820 int ret, err; 1821 1822 /* We may create quota structure so we need to reserve enough blocks */ 1823 reiserfs_write_lock(inode->i_sb); 1824 ret = 1825 journal_begin(&th, inode->i_sb, 1826 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb)); 1827 if (ret) 1828 goto out; 1829 ret = dquot_initialize(inode, type); 1830 err = 1831 journal_end(&th, inode->i_sb, 1832 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb)); 1833 if (!ret && err) 1834 ret = err; 1835 out: 1836 reiserfs_write_unlock(inode->i_sb); 1837 return ret; 1838} 1839 1840static int reiserfs_dquot_drop(struct inode *inode) 1841{ 1842 struct reiserfs_transaction_handle th; 1843 int ret, err; 1844 1845 /* We may delete quota structure so we need to reserve enough blocks */ 1846 reiserfs_write_lock(inode->i_sb); 1847 ret = 1848 journal_begin(&th, inode->i_sb, 1849 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)); 1850 if (ret) 1851 goto out; 1852 ret = dquot_drop(inode); 1853 err = 1854 journal_end(&th, inode->i_sb, 1855 2 * REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)); 1856 if (!ret && err) 1857 ret = err; 1858 out: 1859 reiserfs_write_unlock(inode->i_sb); 1860 return ret; 1861} 1862 1863static int reiserfs_write_dquot(struct dquot *dquot) 1864{ 1865 struct reiserfs_transaction_handle th; 1866 int ret, err; 1867 1868 reiserfs_write_lock(dquot->dq_sb); 1869 ret = 1870 journal_begin(&th, dquot->dq_sb, 1871 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb)); 1872 if (ret) 1873 goto out; 1874 ret = dquot_commit(dquot); 1875 err = 1876 journal_end(&th, dquot->dq_sb, 1877 REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb)); 1878 if (!ret && err) 1879 ret = err; 1880 out: 1881 reiserfs_write_unlock(dquot->dq_sb); 1882 return ret; 1883} 1884 1885static int reiserfs_acquire_dquot(struct dquot *dquot) 1886{ 1887 struct reiserfs_transaction_handle th; 1888 int ret, err; 1889 1890 reiserfs_write_lock(dquot->dq_sb); 1891 ret = 1892 journal_begin(&th, dquot->dq_sb, 1893 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb)); 1894 if (ret) 1895 goto out; 1896 ret = dquot_acquire(dquot); 1897 err = 1898 journal_end(&th, dquot->dq_sb, 1899 REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb)); 1900 if (!ret && err) 1901 ret = err; 1902 out: 1903 reiserfs_write_unlock(dquot->dq_sb); 1904 return ret; 1905} 1906 1907static int reiserfs_release_dquot(struct dquot *dquot) 1908{ 1909 struct reiserfs_transaction_handle th; 1910 int ret, err; 1911 1912 reiserfs_write_lock(dquot->dq_sb); 1913 ret = 1914 journal_begin(&th, dquot->dq_sb, 1915 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb)); 1916 if (ret) 1917 goto out; 1918 ret = dquot_release(dquot); 1919 err = 1920 journal_end(&th, dquot->dq_sb, 1921 REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb)); 1922 if (!ret && err) 1923 ret = err; 1924 out: 1925 reiserfs_write_unlock(dquot->dq_sb); 1926 return ret; 1927} 1928 1929static int reiserfs_mark_dquot_dirty(struct dquot *dquot) 1930{ 1931 /* Are we journalling quotas? */ 1932 if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] || 1933 REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) { 1934 dquot_mark_dquot_dirty(dquot); 1935 return reiserfs_write_dquot(dquot); 1936 } else 1937 return dquot_mark_dquot_dirty(dquot); 1938} 1939 1940static int reiserfs_write_info(struct super_block *sb, int type) 1941{ 1942 struct reiserfs_transaction_handle th; 1943 int ret, err; 1944 1945 /* Data block + inode block */ 1946 reiserfs_write_lock(sb); 1947 ret = journal_begin(&th, sb, 2); 1948 if (ret) 1949 goto out; 1950 ret = dquot_commit_info(sb, type); 1951 err = journal_end(&th, sb, 2); 1952 if (!ret && err) 1953 ret = err; 1954 out: 1955 reiserfs_write_unlock(sb); 1956 return ret; 1957} 1958 1959/* 1960 * Turn on quotas during mount time - we need to find the quota file and such... 1961 */ 1962static int reiserfs_quota_on_mount(struct super_block *sb, int type) 1963{ 1964 return vfs_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type], 1965 REISERFS_SB(sb)->s_jquota_fmt, type); 1966} 1967 1968/* 1969 * Standard function to be called on quota_on 1970 */ 1971static int reiserfs_quota_on(struct super_block *sb, int type, int format_id, 1972 char *path) 1973{ 1974 int err; 1975 struct nameidata nd; 1976 1977 if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA))) 1978 return -EINVAL; 1979 err = path_lookup(path, LOOKUP_FOLLOW, &nd); 1980 if (err) 1981 return err; 1982 /* Quotafile not on the same filesystem? */ 1983 if (nd.mnt->mnt_sb != sb) { 1984 path_release(&nd); 1985 return -EXDEV; 1986 } 1987 /* We must not pack tails for quota files on reiserfs for quota IO to work */ 1988 if (!REISERFS_I(nd.dentry->d_inode)->i_flags & i_nopack_mask) { 1989 reiserfs_warning(sb, 1990 "reiserfs: Quota file must have tail packing disabled."); 1991 path_release(&nd); 1992 return -EINVAL; 1993 } 1994 /* Not journalling quota? No more tests needed... */ 1995 if (!REISERFS_SB(sb)->s_qf_names[USRQUOTA] && 1996 !REISERFS_SB(sb)->s_qf_names[GRPQUOTA]) { 1997 path_release(&nd); 1998 return vfs_quota_on(sb, type, format_id, path); 1999 } 2000 /* Quotafile not of fs root? */ 2001 if (nd.dentry->d_parent->d_inode != sb->s_root->d_inode) 2002 reiserfs_warning(sb, 2003 "reiserfs: Quota file not on filesystem root. " 2004 "Journalled quota will not work."); 2005 path_release(&nd); 2006 return vfs_quota_on(sb, type, format_id, path); 2007} 2008 2009/* Read data from quotafile - avoid pagecache and such because we cannot afford 2010 * acquiring the locks... As quota files are never truncated and quota code 2011 * itself serializes the operations (and noone else should touch the files) 2012 * we don't have to be afraid of races */ 2013static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data, 2014 size_t len, loff_t off) 2015{ 2016 struct inode *inode = sb_dqopt(sb)->files[type]; 2017 unsigned long blk = off >> sb->s_blocksize_bits; 2018 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy; 2019 size_t toread; 2020 struct buffer_head tmp_bh, *bh; 2021 loff_t i_size = i_size_read(inode); 2022 2023 if (off > i_size) 2024 return 0; 2025 if (off + len > i_size) 2026 len = i_size - off; 2027 toread = len; 2028 while (toread > 0) { 2029 tocopy = 2030 sb->s_blocksize - offset < 2031 toread ? sb->s_blocksize - offset : toread; 2032 tmp_bh.b_state = 0; 2033 /* Quota files are without tails so we can safely use this function */ 2034 reiserfs_write_lock(sb); 2035 err = reiserfs_get_block(inode, blk, &tmp_bh, 0); 2036 reiserfs_write_unlock(sb); 2037 if (err) 2038 return err; 2039 if (!buffer_mapped(&tmp_bh)) /* A hole? */ 2040 memset(data, 0, tocopy); 2041 else { 2042 bh = sb_bread(sb, tmp_bh.b_blocknr); 2043 if (!bh) 2044 return -EIO; 2045 memcpy(data, bh->b_data + offset, tocopy); 2046 brelse(bh); 2047 } 2048 offset = 0; 2049 toread -= tocopy; 2050 data += tocopy; 2051 blk++; 2052 } 2053 return len; 2054} 2055 2056/* Write to quotafile (we know the transaction is already started and has 2057 * enough credits) */ 2058static ssize_t reiserfs_quota_write(struct super_block *sb, int type, 2059 const char *data, size_t len, loff_t off) 2060{ 2061 struct inode *inode = sb_dqopt(sb)->files[type]; 2062 unsigned long blk = off >> sb->s_blocksize_bits; 2063 int err = 0, offset = off & (sb->s_blocksize - 1), tocopy; 2064 int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL; 2065 size_t towrite = len; 2066 struct buffer_head tmp_bh, *bh; 2067 2068 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA); 2069 while (towrite > 0) { 2070 tocopy = sb->s_blocksize - offset < towrite ? 2071 sb->s_blocksize - offset : towrite; 2072 tmp_bh.b_state = 0; 2073 err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE); 2074 if (err) 2075 goto out; 2076 if (offset || tocopy != sb->s_blocksize) 2077 bh = sb_bread(sb, tmp_bh.b_blocknr); 2078 else 2079 bh = sb_getblk(sb, tmp_bh.b_blocknr); 2080 if (!bh) { 2081 err = -EIO; 2082 goto out; 2083 } 2084 lock_buffer(bh); 2085 memcpy(bh->b_data + offset, data, tocopy); 2086 flush_dcache_page(bh->b_page); 2087 set_buffer_uptodate(bh); 2088 unlock_buffer(bh); 2089 reiserfs_prepare_for_journal(sb, bh, 1); 2090 journal_mark_dirty(current->journal_info, sb, bh); 2091 if (!journal_quota) 2092 reiserfs_add_ordered_list(inode, bh); 2093 brelse(bh); 2094 offset = 0; 2095 towrite -= tocopy; 2096 data += tocopy; 2097 blk++; 2098 } 2099 out: 2100 if (len == towrite) 2101 return err; 2102 if (inode->i_size < off + len - towrite) 2103 i_size_write(inode, off + len - towrite); 2104 inode->i_version++; 2105 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 2106 mark_inode_dirty(inode); 2107 mutex_unlock(&inode->i_mutex); 2108 return len - towrite; 2109} 2110 2111#endif 2112 2113static int get_super_block(struct file_system_type *fs_type, 2114 int flags, const char *dev_name, 2115 void *data, struct vfsmount *mnt) 2116{ 2117 return get_sb_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super, 2118 mnt); 2119} 2120 2121static int __init init_reiserfs_fs(void) 2122{ 2123 int ret; 2124 2125 if ((ret = init_inodecache())) { 2126 return ret; 2127 } 2128 2129 if ((ret = reiserfs_xattr_register_handlers())) 2130 goto failed_reiserfs_xattr_register_handlers; 2131 2132 reiserfs_proc_info_global_init(); 2133 reiserfs_proc_register_global("version", 2134 reiserfs_global_version_in_proc); 2135 2136 ret = register_filesystem(&reiserfs_fs_type); 2137 2138 if (ret == 0) { 2139 return 0; 2140 } 2141 2142 reiserfs_xattr_unregister_handlers(); 2143 2144 failed_reiserfs_xattr_register_handlers: 2145 reiserfs_proc_unregister_global("version"); 2146 reiserfs_proc_info_global_done(); 2147 destroy_inodecache(); 2148 2149 return ret; 2150} 2151 2152static void __exit exit_reiserfs_fs(void) 2153{ 2154 reiserfs_xattr_unregister_handlers(); 2155 reiserfs_proc_unregister_global("version"); 2156 reiserfs_proc_info_global_done(); 2157 unregister_filesystem(&reiserfs_fs_type); 2158 destroy_inodecache(); 2159} 2160 2161struct file_system_type reiserfs_fs_type = { 2162 .owner = THIS_MODULE, 2163 .name = "reiserfs", 2164 .get_sb = get_super_block, 2165 .kill_sb = reiserfs_kill_sb, 2166 .fs_flags = FS_REQUIRES_DEV, 2167}; 2168 2169MODULE_DESCRIPTION("ReiserFS journaled filesystem"); 2170MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>"); 2171MODULE_LICENSE("GPL"); 2172 2173module_init(init_reiserfs_fs); 2174module_exit(exit_reiserfs_fs); 2175