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