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