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