diff options
Diffstat (limited to 'fs/gfs2/lm.c')
-rw-r--r-- | fs/gfs2/lm.c | 217 |
1 files changed, 217 insertions, 0 deletions
diff --git a/fs/gfs2/lm.c b/fs/gfs2/lm.c new file mode 100644 index 000000000000..effe4a337c1d --- /dev/null +++ b/fs/gfs2/lm.c | |||
@@ -0,0 +1,217 @@ | |||
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 | |||