[PATCH] ext2: fsid for statvfs
[linux-2.6.git] / fs / gfs2 / lm.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/delay.h>
16 #include <linux/gfs2_ondisk.h>
17 #include <linux/lm_interface.h>
18
19 #include "gfs2.h"
20 #include "incore.h"
21 #include "glock.h"
22 #include "lm.h"
23 #include "super.h"
24 #include "util.h"
25
26 /**
27  * gfs2_lm_mount - mount a locking protocol
28  * @sdp: the filesystem
29  * @args: mount arguements
30  * @silent: if 1, don't complain if the FS isn't a GFS2 fs
31  *
32  * Returns: errno
33  */
34
35 int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
36 {
37         char *proto = sdp->sd_proto_name;
38         char *table = sdp->sd_table_name;
39         int flags = 0;
40         int error;
41
42         if (sdp->sd_args.ar_spectator)
43                 flags |= LM_MFLAG_SPECTATOR;
44
45         fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
46
47         error = gfs2_mount_lockproto(proto, table, sdp->sd_args.ar_hostdata,
48                                      gfs2_glock_cb, sdp,
49                                      GFS2_MIN_LVB_SIZE, flags,
50                                      &sdp->sd_lockstruct, &sdp->sd_kobj);
51         if (error) {
52                 fs_info(sdp, "can't mount proto=%s, table=%s, hostdata=%s\n",
53                         proto, table, sdp->sd_args.ar_hostdata);
54                 goto out;
55         }
56
57         if (gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lockspace) ||
58             gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_ops) ||
59             gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lvb_size >=
60                                   GFS2_MIN_LVB_SIZE)) {
61                 gfs2_unmount_lockproto(&sdp->sd_lockstruct);
62                 goto out;
63         }
64
65         if (sdp->sd_args.ar_spectator)
66                 snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.s", table);
67         else
68                 snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.%u", table,
69                          sdp->sd_lockstruct.ls_jid);
70
71         fs_info(sdp, "Joined cluster. Now mounting FS...\n");
72
73         if ((sdp->sd_lockstruct.ls_flags & LM_LSFLAG_LOCAL) &&
74             !sdp->sd_args.ar_ignore_local_fs) {
75                 sdp->sd_args.ar_localflocks = 1;
76                 sdp->sd_args.ar_localcaching = 1;
77         }
78
79 out:
80         return error;
81 }
82
83 void gfs2_lm_others_may_mount(struct gfs2_sbd *sdp)
84 {
85         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
86                 sdp->sd_lockstruct.ls_ops->lm_others_may_mount(
87                                         sdp->sd_lockstruct.ls_lockspace);
88 }
89
90 void gfs2_lm_unmount(struct gfs2_sbd *sdp)
91 {
92         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
93                 gfs2_unmount_lockproto(&sdp->sd_lockstruct);
94 }
95
96 int gfs2_lm_withdraw(struct gfs2_sbd *sdp, char *fmt, ...)
97 {
98         va_list args;
99
100         if (test_and_set_bit(SDF_SHUTDOWN, &sdp->sd_flags))
101                 return 0;
102
103         va_start(args, fmt);
104         vprintk(fmt, args);
105         va_end(args);
106
107         fs_err(sdp, "about to withdraw from the cluster\n");
108         BUG_ON(sdp->sd_args.ar_debug);
109
110
111         fs_err(sdp, "waiting for outstanding I/O\n");
112
113         /* FIXME: suspend dm device so oustanding bio's complete
114            and all further io requests fail */
115
116         fs_err(sdp, "telling LM to withdraw\n");
117         gfs2_withdraw_lockproto(&sdp->sd_lockstruct);
118         fs_err(sdp, "withdrawn\n");
119         dump_stack();
120
121         return -1;
122 }
123
124 int gfs2_lm_get_lock(struct gfs2_sbd *sdp, struct lm_lockname *name,
125                      void **lockp)
126 {
127         int error = -EIO;
128         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
129                 error = sdp->sd_lockstruct.ls_ops->lm_get_lock(
130                                 sdp->sd_lockstruct.ls_lockspace, name, lockp);
131         return error;
132 }
133
134 void gfs2_lm_put_lock(struct gfs2_sbd *sdp, void *lock)
135 {
136         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
137                 sdp->sd_lockstruct.ls_ops->lm_put_lock(lock);
138 }
139
140 unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, void *lock,
141                           unsigned int cur_state, unsigned int req_state,
142                           unsigned int flags)
143 {
144         int ret = 0;
145         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
146                 ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock, cur_state,
147                                                          req_state, flags);
148         return ret;
149 }
150
151 unsigned int gfs2_lm_unlock(struct gfs2_sbd *sdp, void *lock,
152                             unsigned int cur_state)
153 {
154         int ret = 0;
155         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
156                 ret =  sdp->sd_lockstruct.ls_ops->lm_unlock(lock, cur_state);
157         return ret;
158 }
159
160 void gfs2_lm_cancel(struct gfs2_sbd *sdp, void *lock)
161 {
162         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
163                 sdp->sd_lockstruct.ls_ops->lm_cancel(lock);
164 }
165
166 int gfs2_lm_hold_lvb(struct gfs2_sbd *sdp, void *lock, char **lvbp)
167 {
168         int error = -EIO;
169         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
170                 error = sdp->sd_lockstruct.ls_ops->lm_hold_lvb(lock, lvbp);
171         return error;
172 }
173
174 void gfs2_lm_unhold_lvb(struct gfs2_sbd *sdp, void *lock, char *lvb)
175 {
176         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
177                 sdp->sd_lockstruct.ls_ops->lm_unhold_lvb(lock, lvb);
178 }
179
180 int gfs2_lm_plock_get(struct gfs2_sbd *sdp, struct lm_lockname *name,
181                       struct file *file, struct file_lock *fl)
182 {
183         int error = -EIO;
184         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
185                 error = sdp->sd_lockstruct.ls_ops->lm_plock_get(
186                                 sdp->sd_lockstruct.ls_lockspace, name, file, fl);
187         return error;
188 }
189
190 int gfs2_lm_plock(struct gfs2_sbd *sdp, struct lm_lockname *name,
191                   struct file *file, int cmd, struct file_lock *fl)
192 {
193         int error = -EIO;
194         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
195                 error = sdp->sd_lockstruct.ls_ops->lm_plock(
196                                 sdp->sd_lockstruct.ls_lockspace, name, file, cmd, fl);
197         return error;
198 }
199
200 int gfs2_lm_punlock(struct gfs2_sbd *sdp, struct lm_lockname *name,
201                     struct file *file, struct file_lock *fl)
202 {
203         int error = -EIO;
204         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
205                 error = sdp->sd_lockstruct.ls_ops->lm_punlock(
206                                 sdp->sd_lockstruct.ls_lockspace, name, file, fl);
207         return error;
208 }
209
210 void gfs2_lm_recovery_done(struct gfs2_sbd *sdp, unsigned int jid,
211                            unsigned int message)
212 {
213         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
214                 sdp->sd_lockstruct.ls_ops->lm_recovery_done(
215                         sdp->sd_lockstruct.ls_lockspace, jid, message);
216 }
217