diff options
Diffstat (limited to 'fs/gfs2/locking/dlm/mount.c')
-rw-r--r-- | fs/gfs2/locking/dlm/mount.c | 276 |
1 files changed, 0 insertions, 276 deletions
diff --git a/fs/gfs2/locking/dlm/mount.c b/fs/gfs2/locking/dlm/mount.c deleted file mode 100644 index 1aa7eb6a0226..000000000000 --- a/fs/gfs2/locking/dlm/mount.c +++ /dev/null | |||
@@ -1,276 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | ||
3 | * Copyright (C) 2004-2005 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 "lock_dlm.h" | ||
11 | |||
12 | const struct lm_lockops gdlm_ops; | ||
13 | |||
14 | |||
15 | static struct gdlm_ls *init_gdlm(lm_callback_t cb, struct gfs2_sbd *sdp, | ||
16 | int flags, char *table_name) | ||
17 | { | ||
18 | struct gdlm_ls *ls; | ||
19 | char buf[256], *p; | ||
20 | |||
21 | ls = kzalloc(sizeof(struct gdlm_ls), GFP_KERNEL); | ||
22 | if (!ls) | ||
23 | return NULL; | ||
24 | |||
25 | ls->fscb = cb; | ||
26 | ls->sdp = sdp; | ||
27 | ls->fsflags = flags; | ||
28 | spin_lock_init(&ls->async_lock); | ||
29 | INIT_LIST_HEAD(&ls->delayed); | ||
30 | INIT_LIST_HEAD(&ls->submit); | ||
31 | init_waitqueue_head(&ls->thread_wait); | ||
32 | init_waitqueue_head(&ls->wait_control); | ||
33 | ls->jid = -1; | ||
34 | |||
35 | strncpy(buf, table_name, 256); | ||
36 | buf[255] = '\0'; | ||
37 | |||
38 | p = strchr(buf, ':'); | ||
39 | if (!p) { | ||
40 | log_info("invalid table_name \"%s\"", table_name); | ||
41 | kfree(ls); | ||
42 | return NULL; | ||
43 | } | ||
44 | *p = '\0'; | ||
45 | p++; | ||
46 | |||
47 | strncpy(ls->clustername, buf, GDLM_NAME_LEN); | ||
48 | strncpy(ls->fsname, p, GDLM_NAME_LEN); | ||
49 | |||
50 | return ls; | ||
51 | } | ||
52 | |||
53 | static int make_args(struct gdlm_ls *ls, char *data_arg, int *nodir) | ||
54 | { | ||
55 | char data[256]; | ||
56 | char *options, *x, *y; | ||
57 | int error = 0; | ||
58 | |||
59 | memset(data, 0, 256); | ||
60 | strncpy(data, data_arg, 255); | ||
61 | |||
62 | if (!strlen(data)) { | ||
63 | log_error("no mount options, (u)mount helpers not installed"); | ||
64 | return -EINVAL; | ||
65 | } | ||
66 | |||
67 | for (options = data; (x = strsep(&options, ":")); ) { | ||
68 | if (!*x) | ||
69 | continue; | ||
70 | |||
71 | y = strchr(x, '='); | ||
72 | if (y) | ||
73 | *y++ = 0; | ||
74 | |||
75 | if (!strcmp(x, "jid")) { | ||
76 | if (!y) { | ||
77 | log_error("need argument to jid"); | ||
78 | error = -EINVAL; | ||
79 | break; | ||
80 | } | ||
81 | sscanf(y, "%u", &ls->jid); | ||
82 | |||
83 | } else if (!strcmp(x, "first")) { | ||
84 | if (!y) { | ||
85 | log_error("need argument to first"); | ||
86 | error = -EINVAL; | ||
87 | break; | ||
88 | } | ||
89 | sscanf(y, "%u", &ls->first); | ||
90 | |||
91 | } else if (!strcmp(x, "id")) { | ||
92 | if (!y) { | ||
93 | log_error("need argument to id"); | ||
94 | error = -EINVAL; | ||
95 | break; | ||
96 | } | ||
97 | sscanf(y, "%u", &ls->id); | ||
98 | |||
99 | } else if (!strcmp(x, "nodir")) { | ||
100 | if (!y) { | ||
101 | log_error("need argument to nodir"); | ||
102 | error = -EINVAL; | ||
103 | break; | ||
104 | } | ||
105 | sscanf(y, "%u", nodir); | ||
106 | |||
107 | } else { | ||
108 | log_error("unkonwn option: %s", x); | ||
109 | error = -EINVAL; | ||
110 | break; | ||
111 | } | ||
112 | } | ||
113 | |||
114 | return error; | ||
115 | } | ||
116 | |||
117 | static int gdlm_mount(char *table_name, char *host_data, | ||
118 | lm_callback_t cb, void *cb_data, | ||
119 | unsigned int min_lvb_size, int flags, | ||
120 | struct lm_lockstruct *lockstruct, | ||
121 | struct kobject *fskobj) | ||
122 | { | ||
123 | struct gdlm_ls *ls; | ||
124 | int error = -ENOMEM, nodir = 0; | ||
125 | |||
126 | if (min_lvb_size > GDLM_LVB_SIZE) | ||
127 | goto out; | ||
128 | |||
129 | ls = init_gdlm(cb, cb_data, flags, table_name); | ||
130 | if (!ls) | ||
131 | goto out; | ||
132 | |||
133 | error = make_args(ls, host_data, &nodir); | ||
134 | if (error) | ||
135 | goto out; | ||
136 | |||
137 | error = gdlm_init_threads(ls); | ||
138 | if (error) | ||
139 | goto out_free; | ||
140 | |||
141 | error = gdlm_kobject_setup(ls, fskobj); | ||
142 | if (error) | ||
143 | goto out_thread; | ||
144 | |||
145 | error = dlm_new_lockspace(ls->fsname, strlen(ls->fsname), | ||
146 | &ls->dlm_lockspace, | ||
147 | DLM_LSFL_FS | DLM_LSFL_NEWEXCL | | ||
148 | (nodir ? DLM_LSFL_NODIR : 0), | ||
149 | GDLM_LVB_SIZE); | ||
150 | if (error) { | ||
151 | log_error("dlm_new_lockspace error %d", error); | ||
152 | goto out_kobj; | ||
153 | } | ||
154 | |||
155 | lockstruct->ls_jid = ls->jid; | ||
156 | lockstruct->ls_first = ls->first; | ||
157 | lockstruct->ls_lockspace = ls; | ||
158 | lockstruct->ls_ops = &gdlm_ops; | ||
159 | lockstruct->ls_flags = 0; | ||
160 | lockstruct->ls_lvb_size = GDLM_LVB_SIZE; | ||
161 | return 0; | ||
162 | |||
163 | out_kobj: | ||
164 | gdlm_kobject_release(ls); | ||
165 | out_thread: | ||
166 | gdlm_release_threads(ls); | ||
167 | out_free: | ||
168 | kfree(ls); | ||
169 | out: | ||
170 | return error; | ||
171 | } | ||
172 | |||
173 | static void gdlm_unmount(void *lockspace) | ||
174 | { | ||
175 | struct gdlm_ls *ls = lockspace; | ||
176 | |||
177 | log_debug("unmount flags %lx", ls->flags); | ||
178 | |||
179 | /* FIXME: serialize unmount and withdraw in case they | ||
180 | happen at once. Also, if unmount follows withdraw, | ||
181 | wait for withdraw to finish. */ | ||
182 | |||
183 | if (test_bit(DFL_WITHDRAW, &ls->flags)) | ||
184 | goto out; | ||
185 | |||
186 | gdlm_kobject_release(ls); | ||
187 | dlm_release_lockspace(ls->dlm_lockspace, 2); | ||
188 | gdlm_release_threads(ls); | ||
189 | BUG_ON(ls->all_locks_count); | ||
190 | out: | ||
191 | kfree(ls); | ||
192 | } | ||
193 | |||
194 | static void gdlm_recovery_done(void *lockspace, unsigned int jid, | ||
195 | unsigned int message) | ||
196 | { | ||
197 | char env_jid[20]; | ||
198 | char env_status[20]; | ||
199 | char *envp[] = { env_jid, env_status, NULL }; | ||
200 | struct gdlm_ls *ls = lockspace; | ||
201 | ls->recover_jid_done = jid; | ||
202 | ls->recover_jid_status = message; | ||
203 | sprintf(env_jid, "JID=%d", jid); | ||
204 | sprintf(env_status, "RECOVERY=%s", | ||
205 | message == LM_RD_SUCCESS ? "Done" : "Failed"); | ||
206 | kobject_uevent_env(&ls->kobj, KOBJ_CHANGE, envp); | ||
207 | } | ||
208 | |||
209 | static void gdlm_others_may_mount(void *lockspace) | ||
210 | { | ||
211 | char *message = "FIRSTMOUNT=Done"; | ||
212 | char *envp[] = { message, NULL }; | ||
213 | struct gdlm_ls *ls = lockspace; | ||
214 | ls->first_done = 1; | ||
215 | kobject_uevent_env(&ls->kobj, KOBJ_CHANGE, envp); | ||
216 | } | ||
217 | |||
218 | /* Userspace gets the offline uevent, blocks new gfs locks on | ||
219 | other mounters, and lets us know (sets WITHDRAW flag). Then, | ||
220 | userspace leaves the mount group while we leave the lockspace. */ | ||
221 | |||
222 | static void gdlm_withdraw(void *lockspace) | ||
223 | { | ||
224 | struct gdlm_ls *ls = lockspace; | ||
225 | |||
226 | kobject_uevent(&ls->kobj, KOBJ_OFFLINE); | ||
227 | |||
228 | wait_event_interruptible(ls->wait_control, | ||
229 | test_bit(DFL_WITHDRAW, &ls->flags)); | ||
230 | |||
231 | dlm_release_lockspace(ls->dlm_lockspace, 2); | ||
232 | gdlm_release_threads(ls); | ||
233 | gdlm_kobject_release(ls); | ||
234 | } | ||
235 | |||
236 | static int gdlm_plock(void *lockspace, struct lm_lockname *name, | ||
237 | struct file *file, int cmd, struct file_lock *fl) | ||
238 | { | ||
239 | struct gdlm_ls *ls = lockspace; | ||
240 | return dlm_posix_lock(ls->dlm_lockspace, name->ln_number, file, cmd, fl); | ||
241 | } | ||
242 | |||
243 | static int gdlm_punlock(void *lockspace, struct lm_lockname *name, | ||
244 | struct file *file, struct file_lock *fl) | ||
245 | { | ||
246 | struct gdlm_ls *ls = lockspace; | ||
247 | return dlm_posix_unlock(ls->dlm_lockspace, name->ln_number, file, fl); | ||
248 | } | ||
249 | |||
250 | static int gdlm_plock_get(void *lockspace, struct lm_lockname *name, | ||
251 | struct file *file, struct file_lock *fl) | ||
252 | { | ||
253 | struct gdlm_ls *ls = lockspace; | ||
254 | return dlm_posix_get(ls->dlm_lockspace, name->ln_number, file, fl); | ||
255 | } | ||
256 | |||
257 | const struct lm_lockops gdlm_ops = { | ||
258 | .lm_proto_name = "lock_dlm", | ||
259 | .lm_mount = gdlm_mount, | ||
260 | .lm_others_may_mount = gdlm_others_may_mount, | ||
261 | .lm_unmount = gdlm_unmount, | ||
262 | .lm_withdraw = gdlm_withdraw, | ||
263 | .lm_get_lock = gdlm_get_lock, | ||
264 | .lm_put_lock = gdlm_put_lock, | ||
265 | .lm_lock = gdlm_lock, | ||
266 | .lm_unlock = gdlm_unlock, | ||
267 | .lm_plock = gdlm_plock, | ||
268 | .lm_punlock = gdlm_punlock, | ||
269 | .lm_plock_get = gdlm_plock_get, | ||
270 | .lm_cancel = gdlm_cancel, | ||
271 | .lm_hold_lvb = gdlm_hold_lvb, | ||
272 | .lm_unhold_lvb = gdlm_unhold_lvb, | ||
273 | .lm_recovery_done = gdlm_recovery_done, | ||
274 | .lm_owner = THIS_MODULE, | ||
275 | }; | ||
276 | |||