www.pilppa.org Git - linux-2.6-omap-h63xx.git/blob

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