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