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