1
2
3
4
5
6
7
8
9
10#include <linux/sched.h>
11#include <linux/slab.h>
12#include <linux/spinlock.h>
13#include <linux/completion.h>
14#include <linux/buffer_head.h>
15#include <linux/blkdev.h>
16#include <linux/kthread.h>
17#include <linux/namei.h>
18#include <linux/mount.h>
19#include <linux/gfs2_ondisk.h>
20#include <linux/lm_interface.h>
21
22#include "gfs2.h"
23#include "incore.h"
24#include "daemon.h"
25#include "glock.h"
26#include "glops.h"
27#include "inode.h"
28#include "lm.h"
29#include "mount.h"
30#include "ops_fstype.h"
31#include "ops_dentry.h"
32#include "ops_super.h"
33#include "recovery.h"
34#include "rgrp.h"
35#include "super.h"
36#include "sys.h"
37#include "util.h"
38#include "log.h"
39
40#define DO 0
41#define UNDO 1
42
43static struct gfs2_sbd *init_sbd(struct super_block *sb)
44{
45 struct gfs2_sbd *sdp;
46
47 sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
48 if (!sdp)
49 return NULL;
50
51 sb->s_fs_info = sdp;
52 sdp->sd_vfs = sb;
53
54 gfs2_tune_init(&sdp->sd_tune);
55
56 INIT_LIST_HEAD(&sdp->sd_reclaim_list);
57 spin_lock_init(&sdp->sd_reclaim_lock);
58 init_waitqueue_head(&sdp->sd_reclaim_wq);
59
60 mutex_init(&sdp->sd_inum_mutex);
61 spin_lock_init(&sdp->sd_statfs_spin);
62 mutex_init(&sdp->sd_statfs_mutex);
63
64 spin_lock_init(&sdp->sd_rindex_spin);
65 mutex_init(&sdp->sd_rindex_mutex);
66 INIT_LIST_HEAD(&sdp->sd_rindex_list);
67 INIT_LIST_HEAD(&sdp->sd_rindex_mru_list);
68 INIT_LIST_HEAD(&sdp->sd_rindex_recent_list);
69
70 INIT_LIST_HEAD(&sdp->sd_jindex_list);
71 spin_lock_init(&sdp->sd_jindex_spin);
72 mutex_init(&sdp->sd_jindex_mutex);
73
74 INIT_LIST_HEAD(&sdp->sd_quota_list);
75 spin_lock_init(&sdp->sd_quota_spin);
76 mutex_init(&sdp->sd_quota_mutex);
77
78 spin_lock_init(&sdp->sd_log_lock);
79
80 INIT_LIST_HEAD(&sdp->sd_log_le_gl);
81 INIT_LIST_HEAD(&sdp->sd_log_le_buf);
82 INIT_LIST_HEAD(&sdp->sd_log_le_revoke);
83 INIT_LIST_HEAD(&sdp->sd_log_le_rg);
84 INIT_LIST_HEAD(&sdp->sd_log_le_databuf);
85 INIT_LIST_HEAD(&sdp->sd_log_le_ordered);
86
87 mutex_init(&sdp->sd_log_reserve_mutex);
88 INIT_LIST_HEAD(&sdp->sd_ail1_list);
89 INIT_LIST_HEAD(&sdp->sd_ail2_list);
90
91 init_rwsem(&sdp->sd_log_flush_lock);
92 atomic_set(&sdp->sd_log_in_flight, 0);
93 init_waitqueue_head(&sdp->sd_log_flush_wait);
94
95 INIT_LIST_HEAD(&sdp->sd_revoke_list);
96
97 mutex_init(&sdp->sd_freeze_lock);
98
99 return sdp;
100}
101
102static void init_vfs(struct super_block *sb, unsigned noatime)
103{
104 struct gfs2_sbd *sdp = sb->s_fs_info;
105
106 sb->s_magic = GFS2_MAGIC;
107 sb->s_op = &gfs2_super_ops;
108 sb->s_export_op = &gfs2_export_ops;
109 sb->s_time_gran = 1;
110 sb->s_maxbytes = MAX_LFS_FILESIZE;
111
112 if (sb->s_flags & (MS_NOATIME | MS_NODIRATIME))
113 set_bit(noatime, &sdp->sd_flags);
114
115
116 sb->s_flags |= MS_NOATIME | MS_NODIRATIME;
117}
118
119static int init_names(struct gfs2_sbd *sdp, int silent)
120{
121 char *proto, *table;
122 int error = 0;
123
124 proto = sdp->sd_args.ar_lockproto;
125 table = sdp->sd_args.ar_locktable;
126
127
128
129 if (!proto[0] || !table[0]) {
130 error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
131 if (error)
132 return error;
133
134 error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
135 if (error)
136 goto out;
137
138 if (!proto[0])
139 proto = sdp->sd_sb.sb_lockproto;
140 if (!table[0])
141 table = sdp->sd_sb.sb_locktable;
142 }
143
144 if (!table[0])
145 table = sdp->sd_vfs->s_id;
146
147 snprintf(sdp->sd_proto_name, GFS2_FSNAME_LEN, "%s", proto);
148 snprintf(sdp->sd_table_name, GFS2_FSNAME_LEN, "%s", table);
149
150 table = sdp->sd_table_name;
151 while ((table = strchr(table, '/')))
152 *table = '_';
153
154out:
155 return error;
156}
157
158static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
159 int undo)
160{
161 struct task_struct *p;
162 int error = 0;
163
164 if (undo)
165 goto fail_trans;
166
167 for (sdp->sd_glockd_num = 0;
168 sdp->sd_glockd_num < sdp->sd_args.ar_num_glockd;
169 sdp->sd_glockd_num++) {
170 p = kthread_run(gfs2_glockd, sdp, "gfs2_glockd");
171 error = IS_ERR(p);
172 if (error) {
173 fs_err(sdp, "can't start glockd thread: %d\n", error);
174 goto fail;
175 }
176 sdp->sd_glockd_process[sdp->sd_glockd_num] = p;
177 }
178
179 error = gfs2_glock_nq_num(sdp,
180 GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
181 LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
182 mount_gh);
183 if (error) {
184 fs_err(sdp, "can't acquire mount glock: %d\n", error);
185 goto fail;
186 }
187
188 error = gfs2_glock_nq_num(sdp,
189 GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
190 LM_ST_SHARED,
191 LM_FLAG_NOEXP | GL_EXACT,
192 &sdp->sd_live_gh);
193 if (error) {
194 fs_err(sdp, "can't acquire live glock: %d\n", error);
195 goto fail_mount;
196 }
197
198 error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
199 CREATE, &sdp->sd_rename_gl);
200 if (error) {
201 fs_err(sdp, "can't create rename glock: %d\n", error);
202 goto fail_live;
203 }
204
205 error = gfs2_glock_get(sdp, GFS2_TRANS_LOCK, &gfs2_trans_glops,
206 CREATE, &sdp->sd_trans_gl);
207 if (error) {
208 fs_err(sdp, "can't create transaction glock: %d\n", error);
209 goto fail_rename;
210 }
211 set_bit(GLF_STICKY, &sdp->sd_trans_gl->gl_flags);
212
213 return 0;
214
215fail_trans:
216 gfs2_glock_put(sdp->sd_trans_gl);
217fail_rename:
218 gfs2_glock_put(sdp->sd_rename_gl);
219fail_live:
220 gfs2_glock_dq_uninit(&sdp->sd_live_gh);
221fail_mount:
222 gfs2_glock_dq_uninit(mount_gh);
223fail:
224 while (sdp->sd_glockd_num--)
225 kthread_stop(sdp->sd_glockd_process[sdp->sd_glockd_num]);
226
227 return error;
228}
229
230static inline struct inode *gfs2_lookup_root(struct super_block *sb,
231 u64 no_addr)
232{
233 return gfs2_inode_lookup(sb, DT_DIR, no_addr, 0, 0);
234}
235
236static int init_sb(struct gfs2_sbd *sdp, int silent, int undo)
237{
238 struct super_block *sb = sdp->sd_vfs;
239 struct gfs2_holder sb_gh;
240 u64 no_addr;
241 struct inode *inode;
242 int error = 0;
243
244 if (undo) {
245 if (sb->s_root) {
246 dput(sb->s_root);
247 sb->s_root = NULL;
248 }
249 return 0;
250 }
251
252 error = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
253 LM_ST_SHARED, 0, &sb_gh);
254 if (error) {
255 fs_err(sdp, "can't acquire superblock glock: %d\n", error);
256 return error;
257 }
258
259 error = gfs2_read_sb(sdp, sb_gh.gh_gl, silent);
260 if (error) {
261 fs_err(sdp, "can't read superblock: %d\n", error);
262 goto out;
263 }
264
265
266 if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) {
267 error = -EINVAL;
268 fs_err(sdp, "FS block size (%u) is too small for device "
269 "block size (%u)\n",
270 sdp->sd_sb.sb_bsize, bdev_hardsect_size(sb->s_bdev));
271 goto out;
272 }
273 if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
274 error = -EINVAL;
275 fs_err(sdp, "FS block size (%u) is too big for machine "
276 "page size (%u)\n",
277 sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
278 goto out;
279 }
280 sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
281
282
283 no_addr = sdp->sd_sb.sb_root_dir.no_addr;
284 if (sb->s_type == &gfs2meta_fs_type)
285 no_addr = sdp->sd_sb.sb_master_dir.no_addr;
286 inode = gfs2_lookup_root(sb, no_addr);
287 if (IS_ERR(inode)) {
288 error = PTR_ERR(inode);
289 fs_err(sdp, "can't read in root inode: %d\n", error);
290 goto out;
291 }
292
293 sb->s_root = d_alloc_root(inode);
294 if (!sb->s_root) {
295 fs_err(sdp, "can't get root dentry\n");
296 error = -ENOMEM;
297 iput(inode);
298 } else
299 sb->s_root->d_op = &gfs2_dops;
300
301out:
302 gfs2_glock_dq_uninit(&sb_gh);
303 return error;
304}
305
306static int init_journal(struct gfs2_sbd *sdp, int undo)
307{
308 struct gfs2_holder ji_gh;
309 struct task_struct *p;
310 struct gfs2_inode *ip;
311 int jindex = 1;
312 int error = 0;
313
314 if (undo) {
315 jindex = 0;
316 goto fail_recoverd;
317 }
318
319 sdp->sd_jindex = gfs2_lookup_simple(sdp->sd_master_dir, "jindex");
320 if (IS_ERR(sdp->sd_jindex)) {
321 fs_err(sdp, "can't lookup journal index: %d\n", error);
322 return PTR_ERR(sdp->sd_jindex);
323 }
324 ip = GFS2_I(sdp->sd_jindex);
325 set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
326
327
328
329 error = gfs2_jindex_hold(sdp, &ji_gh);
330 if (error) {
331 fs_err(sdp, "can't read journal index: %d\n", error);
332 goto fail;
333 }
334
335 error = -EINVAL;
336 if (!gfs2_jindex_size(sdp)) {
337 fs_err(sdp, "no journals!\n");
338 goto fail_jindex;
339 }
340
341 if (sdp->sd_args.ar_spectator) {
342 sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
343 sdp->sd_log_blks_free = sdp->sd_jdesc->jd_blocks;
344 } else {
345 if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
346 fs_err(sdp, "can't mount journal #%u\n",
347 sdp->sd_lockstruct.ls_jid);
348 fs_err(sdp, "there are only %u journals (0 - %u)\n",
349 gfs2_jindex_size(sdp),
350 gfs2_jindex_size(sdp) - 1);
351 goto fail_jindex;
352 }
353 sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
354
355 error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
356 &gfs2_journal_glops,
357 LM_ST_EXCLUSIVE, LM_FLAG_NOEXP,
358 &sdp->sd_journal_gh);
359 if (error) {
360 fs_err(sdp, "can't acquire journal glock: %d\n", error);
361 goto fail_jindex;
362 }
363
364 ip = GFS2_I(sdp->sd_jdesc->jd_inode);
365 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
366 LM_FLAG_NOEXP | GL_EXACT | GL_NOCACHE,
367 &sdp->sd_jinode_gh);
368 if (error) {
369 fs_err(sdp, "can't acquire journal inode glock: %d\n",
370 error);
371 goto fail_journal_gh;
372 }
373
374 error = gfs2_jdesc_check(sdp->sd_jdesc);
375 if (error) {
376 fs_err(sdp, "my journal (%u) is bad: %d\n",
377 sdp->sd_jdesc->jd_jid, error);
378 goto fail_jinode_gh;
379 }
380 sdp->sd_log_blks_free = sdp->sd_jdesc->jd_blocks;
381 }
382
383 if (sdp->sd_lockstruct.ls_first) {
384 unsigned int x;
385 for (x = 0; x < sdp->sd_journals; x++) {
386 error = gfs2_recover_journal(gfs2_jdesc_find(sdp, x));
387 if (error) {
388 fs_err(sdp, "error recovering journal %u: %d\n",
389 x, error);
390 goto fail_jinode_gh;
391 }
392 }
393
394 gfs2_lm_others_may_mount(sdp);
395 } else if (!sdp->sd_args.ar_spectator) {
396 error = gfs2_recover_journal(sdp->sd_jdesc);
397 if (error) {
398 fs_err(sdp, "error recovering my journal: %d\n", error);
399 goto fail_jinode_gh;
400 }
401 }
402
403 set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
404 gfs2_glock_dq_uninit(&ji_gh);
405 jindex = 0;
406
407 p = kthread_run(gfs2_recoverd, sdp, "gfs2_recoverd");
408 error = IS_ERR(p);
409 if (error) {
410 fs_err(sdp, "can't start recoverd thread: %d\n", error);
411 goto fail_jinode_gh;
412 }
413 sdp->sd_recoverd_process = p;
414
415 return 0;
416
417fail_recoverd:
418 kthread_stop(sdp->sd_recoverd_process);
419fail_jinode_gh:
420 if (!sdp->sd_args.ar_spectator)
421 gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
422fail_journal_gh:
423 if (!sdp->sd_args.ar_spectator)
424 gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
425fail_jindex:
426 gfs2_jindex_free(sdp);
427 if (jindex)
428 gfs2_glock_dq_uninit(&ji_gh);
429fail:
430 iput(sdp->sd_jindex);
431 return error;
432}
433
434
435static int init_inodes(struct gfs2_sbd *sdp, int undo)
436{
437 int error = 0;
438 struct gfs2_inode *ip;
439 struct inode *inode;
440
441 if (undo)
442 goto fail_qinode;
443
444 inode = gfs2_lookup_root(sdp->sd_vfs, sdp->sd_sb.sb_master_dir.no_addr);
445 if (IS_ERR(inode)) {
446 error = PTR_ERR(inode);
447 fs_err(sdp, "can't read in master directory: %d\n", error);
448 goto fail;
449 }
450 sdp->sd_master_dir = inode;
451
452 error = init_journal(sdp, undo);
453 if (error)
454 goto fail_master;
455
456
457 sdp->sd_inum_inode = gfs2_lookup_simple(sdp->sd_master_dir, "inum");
458 if (IS_ERR(sdp->sd_inum_inode)) {
459 error = PTR_ERR(sdp->sd_inum_inode);
460 fs_err(sdp, "can't read in inum inode: %d\n", error);
461 goto fail_journal;
462 }
463
464
465
466 sdp->sd_statfs_inode = gfs2_lookup_simple(sdp->sd_master_dir, "statfs");
467 if (IS_ERR(sdp->sd_statfs_inode)) {
468 error = PTR_ERR(sdp->sd_statfs_inode);
469 fs_err(sdp, "can't read in statfs inode: %d\n", error);
470 goto fail_inum;
471 }
472
473
474 sdp->sd_rindex = gfs2_lookup_simple(sdp->sd_master_dir, "rindex");
475 if (IS_ERR(sdp->sd_rindex)) {
476 error = PTR_ERR(sdp->sd_rindex);
477 fs_err(sdp, "can't get resource index inode: %d\n", error);
478 goto fail_statfs;
479 }
480 ip = GFS2_I(sdp->sd_rindex);
481 set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
482 sdp->sd_rindex_vn = ip->i_gl->gl_vn - 1;
483
484
485 sdp->sd_quota_inode = gfs2_lookup_simple(sdp->sd_master_dir, "quota");
486 if (IS_ERR(sdp->sd_quota_inode)) {
487 error = PTR_ERR(sdp->sd_quota_inode);
488 fs_err(sdp, "can't get quota file inode: %d\n", error);
489 goto fail_rindex;
490 }
491 return 0;
492
493fail_qinode:
494 iput(sdp->sd_quota_inode);
495fail_rindex:
496 gfs2_clear_rgrpd(sdp);
497 iput(sdp->sd_rindex);
498fail_statfs:
499 iput(sdp->sd_statfs_inode);
500fail_inum:
501 iput(sdp->sd_inum_inode);
502fail_journal:
503 init_journal(sdp, UNDO);
504fail_master:
505 iput(sdp->sd_master_dir);
506fail:
507 return error;
508}
509
510static int init_per_node(struct gfs2_sbd *sdp, int undo)
511{
512 struct inode *pn = NULL;
513 char buf[30];
514 int error = 0;
515 struct gfs2_inode *ip;
516
517 if (sdp->sd_args.ar_spectator)
518 return 0;
519
520 if (undo)
521 goto fail_qc_gh;
522
523 pn = gfs2_lookup_simple(sdp->sd_master_dir, "per_node");
524 if (IS_ERR(pn)) {
525 error = PTR_ERR(pn);
526 fs_err(sdp, "can't find per_node directory: %d\n", error);
527 return error;
528 }
529
530 sprintf(buf, "inum_range%u", sdp->sd_jdesc->jd_jid);
531 sdp->sd_ir_inode = gfs2_lookup_simple(pn, buf);
532 if (IS_ERR(sdp->sd_ir_inode)) {
533 error = PTR_ERR(sdp->sd_ir_inode);
534 fs_err(sdp, "can't find local \"ir\" file: %d\n", error);
535 goto fail;
536 }
537
538 sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
539 sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
540 if (IS_ERR(sdp->sd_sc_inode)) {
541 error = PTR_ERR(sdp->sd_sc_inode);
542 fs_err(sdp, "can't find local \"sc\" file: %d\n", error);
543 goto fail_ir_i;
544 }
545
546 sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
547 sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
548 if (IS_ERR(sdp->sd_qc_inode)) {
549 error = PTR_ERR(sdp->sd_qc_inode);
550 fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
551 goto fail_ut_i;
552 }
553
554 iput(pn);
555 pn = NULL;
556
557 ip = GFS2_I(sdp->sd_ir_inode);
558 error = gfs2_glock_nq_init(ip->i_gl,
559 LM_ST_EXCLUSIVE, 0,
560 &sdp->sd_ir_gh);
561 if (error) {
562 fs_err(sdp, "can't lock local \"ir\" file: %d\n", error);
563 goto fail_qc_i;
564 }
565
566 ip = GFS2_I(sdp->sd_sc_inode);
567 error = gfs2_glock_nq_init(ip->i_gl,
568 LM_ST_EXCLUSIVE, 0,
569 &sdp->sd_sc_gh);
570 if (error) {
571 fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
572 goto fail_ir_gh;
573 }
574
575 ip = GFS2_I(sdp->sd_qc_inode);
576 error = gfs2_glock_nq_init(ip->i_gl,
577 LM_ST_EXCLUSIVE, 0,
578 &sdp->sd_qc_gh);
579 if (error) {
580 fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
581 goto fail_ut_gh;
582 }
583
584 return 0;
585
586fail_qc_gh:
587 gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
588fail_ut_gh:
589 gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
590fail_ir_gh:
591 gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
592fail_qc_i:
593 iput(sdp->sd_qc_inode);
594fail_ut_i:
595 iput(sdp->sd_sc_inode);
596fail_ir_i:
597 iput(sdp->sd_ir_inode);
598fail:
599 if (pn)
600 iput(pn);
601 return error;
602}
603
604static int init_threads(struct gfs2_sbd *sdp, int undo)
605{
606 struct task_struct *p;
607 int error = 0;
608
609 if (undo)
610 goto fail_quotad;
611
612 sdp->sd_log_flush_time = jiffies;
613 sdp->sd_jindex_refresh_time = jiffies;
614
615 p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
616 error = IS_ERR(p);
617 if (error) {
618 fs_err(sdp, "can't start logd thread: %d\n", error);
619 return error;
620 }
621 sdp->sd_logd_process = p;
622
623 sdp->sd_statfs_sync_time = jiffies;
624 sdp->sd_quota_sync_time = jiffies;
625
626 p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
627 error = IS_ERR(p);
628 if (error) {
629 fs_err(sdp, "can't start quotad thread: %d\n", error);
630 goto fail;
631 }
632 sdp->sd_quotad_process = p;
633
634 return 0;
635
636
637fail_quotad:
638 kthread_stop(sdp->sd_quotad_process);
639fail:
640 kthread_stop(sdp->sd_logd_process);
641 return error;
642}
643
644
645
646
647
648
649
650
651
652
653static int fill_super(struct super_block *sb, void *data, int silent)
654{
655 struct gfs2_sbd *sdp;
656 struct gfs2_holder mount_gh;
657 int error;
658
659 sdp = init_sbd(sb);
660 if (!sdp) {
661 printk(KERN_WARNING "GFS2: can't alloc struct gfs2_sbd\n");
662 return -ENOMEM;
663 }
664
665 error = gfs2_mount_args(sdp, (char *)data, 0);
666 if (error) {
667 printk(KERN_WARNING "GFS2: can't parse mount arguments\n");
668 goto fail;
669 }
670
671 init_vfs(sb, SDF_NOATIME);
672
673
674
675 sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
676 sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
677 sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
678 GFS2_BASIC_BLOCK_SHIFT;
679 sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
680
681 error = init_names(sdp, silent);
682 if (error)
683 goto fail;
684
685 gfs2_create_debugfs_file(sdp);
686
687 error = gfs2_sys_fs_add(sdp);
688 if (error)
689 goto fail;
690
691 error = gfs2_lm_mount(sdp, silent);
692 if (error)
693 goto fail_sys;
694
695 error = init_locking(sdp, &mount_gh, DO);
696 if (error)
697 goto fail_lm;
698
699 error = init_sb(sdp, silent, DO);
700 if (error)
701 goto fail_locking;
702
703 error = init_inodes(sdp, DO);
704 if (error)
705 goto fail_sb;
706
707 error = init_per_node(sdp, DO);
708 if (error)
709 goto fail_inodes;
710
711 error = gfs2_statfs_init(sdp);
712 if (error) {
713 fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
714 goto fail_per_node;
715 }
716
717 error = init_threads(sdp, DO);
718 if (error)
719 goto fail_per_node;
720
721 if (!(sb->s_flags & MS_RDONLY)) {
722 error = gfs2_make_fs_rw(sdp);
723 if (error) {
724 fs_err(sdp, "can't make FS RW: %d\n", error);
725 goto fail_threads;
726 }
727 }
728
729 gfs2_glock_dq_uninit(&mount_gh);
730
731 return 0;
732
733fail_threads:
734 init_threads(sdp, UNDO);
735fail_per_node:
736 init_per_node(sdp, UNDO);
737fail_inodes:
738 init_inodes(sdp, UNDO);
739fail_sb:
740 init_sb(sdp, 0, UNDO);
741fail_locking:
742 init_locking(sdp, &mount_gh, UNDO);
743fail_lm:
744 gfs2_gl_hash_clear(sdp, WAIT);
745 gfs2_lm_unmount(sdp);
746 while (invalidate_inodes(sb))
747 yield();
748fail_sys:
749 gfs2_sys_fs_del(sdp);
750fail:
751 gfs2_delete_debugfs_file(sdp);
752 kfree(sdp);
753 sb->s_fs_info = NULL;
754 return error;
755}
756
757static int gfs2_get_sb(struct file_system_type *fs_type, int flags,
758 const char *dev_name, void *data, struct vfsmount *mnt)
759{
760 struct super_block *sb;
761 struct gfs2_sbd *sdp;
762 int error = get_sb_bdev(fs_type, flags, dev_name, data, fill_super, mnt);
763 if (error)
764 goto out;
765 sb = mnt->mnt_sb;
766 sdp = sb->s_fs_info;
767 sdp->sd_gfs2mnt = mnt;
768out:
769 return error;
770}
771
772static int fill_super_meta(struct super_block *sb, struct super_block *new,
773 void *data, int silent)
774{
775 struct gfs2_sbd *sdp = sb->s_fs_info;
776 struct inode *inode;
777 int error = 0;
778
779 new->s_fs_info = sdp;
780 sdp->sd_vfs_meta = sb;
781
782 init_vfs(new, SDF_NOATIME);
783
784
785 inode = igrab(sdp->sd_master_dir);
786
787 new->s_root = d_alloc_root(inode);
788 if (!new->s_root) {
789 fs_err(sdp, "can't get root dentry\n");
790 error = -ENOMEM;
791 iput(inode);
792 } else
793 new->s_root->d_op = &gfs2_dops;
794
795 return error;
796}
797
798static int set_bdev_super(struct super_block *s, void *data)
799{
800 s->s_bdev = data;
801 s->s_dev = s->s_bdev->bd_dev;
802 return 0;
803}
804
805static int test_bdev_super(struct super_block *s, void *data)
806{
807 return s->s_bdev == data;
808}
809
810static struct super_block* get_gfs2_sb(const char *dev_name)
811{
812 struct kstat stat;
813 struct nameidata nd;
814 struct file_system_type *fstype;
815 struct super_block *sb = NULL, *s;
816 int error;
817
818 error = path_lookup(dev_name, LOOKUP_FOLLOW, &nd);
819 if (error) {
820 printk(KERN_WARNING "GFS2: path_lookup on %s returned error\n",
821 dev_name);
822 goto out;
823 }
824 error = vfs_getattr(nd.mnt, nd.dentry, &stat);
825
826 fstype = get_fs_type("gfs2");
827 list_for_each_entry(s, &fstype->fs_supers, s_instances) {
828 if ((S_ISBLK(stat.mode) && s->s_dev == stat.rdev) ||
829 (S_ISDIR(stat.mode) && s == nd.dentry->d_inode->i_sb)) {
830 sb = s;
831 goto free_nd;
832 }
833 }
834
835 printk(KERN_WARNING "GFS2: Unrecognized block device or "
836 "mount point %s\n", dev_name);
837
838free_nd:
839 path_release(&nd);
840out:
841 return sb;
842}
843
844static int gfs2_get_sb_meta(struct file_system_type *fs_type, int flags,
845 const char *dev_name, void *data, struct vfsmount *mnt)
846{
847 int error = 0;
848 struct super_block *sb = NULL, *new;
849 struct gfs2_sbd *sdp;
850
851 sb = get_gfs2_sb(dev_name);
852 if (!sb) {
853 printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n");
854 error = -ENOENT;
855 goto error;
856 }
857 sdp = sb->s_fs_info;
858 if (sdp->sd_vfs_meta) {
859 printk(KERN_WARNING "GFS2: gfs2meta mount already exists\n");
860 error = -EBUSY;
861 goto error;
862 }
863 down(&sb->s_bdev->bd_mount_sem);
864 new = sget(fs_type, test_bdev_super, set_bdev_super, sb->s_bdev);
865 up(&sb->s_bdev->bd_mount_sem);
866 if (IS_ERR(new)) {
867 error = PTR_ERR(new);
868 goto error;
869 }
870 module_put(fs_type->owner);
871 new->s_flags = flags;
872 strlcpy(new->s_id, sb->s_id, sizeof(new->s_id));
873 sb_set_blocksize(new, sb->s_blocksize);
874 error = fill_super_meta(sb, new, data, flags & MS_SILENT ? 1 : 0);
875 if (error) {
876 up_write(&new->s_umount);
877 deactivate_super(new);
878 goto error;
879 }
880
881 new->s_flags |= MS_ACTIVE;
882
883
884 atomic_inc(&sdp->sd_gfs2mnt->mnt_count);
885 return simple_set_mnt(mnt, new);
886error:
887 return error;
888}
889
890static void gfs2_kill_sb(struct super_block *sb)
891{
892 if (sb->s_fs_info) {
893 gfs2_delete_debugfs_file(sb->s_fs_info);
894 gfs2_meta_syncfs(sb->s_fs_info);
895 }
896 kill_block_super(sb);
897}
898
899static void gfs2_kill_sb_meta(struct super_block *sb)
900{
901 struct gfs2_sbd *sdp = sb->s_fs_info;
902 generic_shutdown_super(sb);
903 sdp->sd_vfs_meta = NULL;
904 atomic_dec(&sdp->sd_gfs2mnt->mnt_count);
905}
906
907struct file_system_type gfs2_fs_type = {
908 .name = "gfs2",
909 .fs_flags = FS_REQUIRES_DEV,
910 .get_sb = gfs2_get_sb,
911 .kill_sb = gfs2_kill_sb,
912 .owner = THIS_MODULE,
913};
914
915struct file_system_type gfs2meta_fs_type = {
916 .name = "gfs2meta",
917 .fs_flags = FS_REQUIRES_DEV,
918 .get_sb = gfs2_get_sb_meta,
919 .kill_sb = gfs2_kill_sb_meta,
920 .owner = THIS_MODULE,
921};
922
923
