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