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