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