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