]>
Commit | Line | Data |
---|---|---|
869d81df DT |
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 | |
e9fc2aa0 | 7 | * of the GNU General Public License version 2. |
869d81df | 8 | */ |
29b7998d DT |
9 | |
10 | #include <linux/module.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/module.h> | |
13 | #include <linux/init.h> | |
14 | #include <linux/types.h> | |
15 | #include <linux/fs.h> | |
16 | #include <linux/smp_lock.h> | |
17 | ||
18 | #include "../../lm_interface.h" | |
19 | ||
20 | struct nolock_lockspace { | |
21 | unsigned int nl_lvb_size; | |
22 | }; | |
23 | ||
08bc2dbc | 24 | static struct lm_lockops nolock_ops; |
29b7998d | 25 | |
29b7998d DT |
26 | static int nolock_mount(char *table_name, char *host_data, |
27 | lm_callback_t cb, lm_fsdata_t *fsdata, | |
28 | unsigned int min_lvb_size, int flags, | |
869d81df DT |
29 | struct lm_lockstruct *lockstruct, |
30 | struct kobject *fskobj) | |
29b7998d DT |
31 | { |
32 | char *c; | |
33 | unsigned int jid; | |
34 | struct nolock_lockspace *nl; | |
35 | ||
29b7998d DT |
36 | c = strstr(host_data, "jid="); |
37 | if (!c) | |
38 | jid = 0; | |
39 | else { | |
40 | c += 4; | |
41 | sscanf(c, "%u", &jid); | |
42 | } | |
43 | ||
d92a8d48 | 44 | nl = kzalloc(sizeof(struct nolock_lockspace), GFP_KERNEL); |
29b7998d DT |
45 | if (!nl) |
46 | return -ENOMEM; | |
47 | ||
29b7998d DT |
48 | nl->nl_lvb_size = min_lvb_size; |
49 | ||
50 | lockstruct->ls_jid = jid; | |
51 | lockstruct->ls_first = 1; | |
52 | lockstruct->ls_lvb_size = min_lvb_size; | |
53 | lockstruct->ls_lockspace = (lm_lockspace_t *)nl; | |
54 | lockstruct->ls_ops = &nolock_ops; | |
55 | lockstruct->ls_flags = LM_LSFLAG_LOCAL; | |
56 | ||
57 | return 0; | |
58 | } | |
59 | ||
29b7998d DT |
60 | static void nolock_others_may_mount(lm_lockspace_t *lockspace) |
61 | { | |
62 | } | |
63 | ||
29b7998d DT |
64 | static void nolock_unmount(lm_lockspace_t *lockspace) |
65 | { | |
66 | struct nolock_lockspace *nl = (struct nolock_lockspace *)lockspace; | |
67 | kfree(nl); | |
68 | } | |
69 | ||
29b7998d DT |
70 | static void nolock_withdraw(lm_lockspace_t *lockspace) |
71 | { | |
72 | } | |
73 | ||
74 | /** | |
75 | * nolock_get_lock - get a lm_lock_t given a descripton of the lock | |
76 | * @lockspace: the lockspace the lock lives in | |
77 | * @name: the name of the lock | |
78 | * @lockp: return the lm_lock_t here | |
79 | * | |
80 | * Returns: 0 on success, -EXXX on failure | |
81 | */ | |
82 | ||
83 | static int nolock_get_lock(lm_lockspace_t *lockspace, struct lm_lockname *name, | |
84 | lm_lock_t **lockp) | |
85 | { | |
86 | *lockp = (lm_lock_t *)lockspace; | |
87 | return 0; | |
88 | } | |
89 | ||
90 | /** | |
91 | * nolock_put_lock - get rid of a lock structure | |
92 | * @lock: the lock to throw away | |
93 | * | |
94 | */ | |
95 | ||
96 | static void nolock_put_lock(lm_lock_t *lock) | |
97 | { | |
98 | } | |
99 | ||
100 | /** | |
101 | * nolock_lock - acquire a lock | |
102 | * @lock: the lock to manipulate | |
103 | * @cur_state: the current state | |
104 | * @req_state: the requested state | |
105 | * @flags: modifier flags | |
106 | * | |
107 | * Returns: A bitmap of LM_OUT_* | |
108 | */ | |
109 | ||
110 | static unsigned int nolock_lock(lm_lock_t *lock, unsigned int cur_state, | |
111 | unsigned int req_state, unsigned int flags) | |
112 | { | |
113 | return req_state | LM_OUT_CACHEABLE; | |
114 | } | |
115 | ||
116 | /** | |
117 | * nolock_unlock - unlock a lock | |
118 | * @lock: the lock to manipulate | |
119 | * @cur_state: the current state | |
120 | * | |
121 | * Returns: 0 | |
122 | */ | |
123 | ||
124 | static unsigned int nolock_unlock(lm_lock_t *lock, unsigned int cur_state) | |
125 | { | |
126 | return 0; | |
127 | } | |
128 | ||
29b7998d DT |
129 | static void nolock_cancel(lm_lock_t *lock) |
130 | { | |
131 | } | |
132 | ||
133 | /** | |
134 | * nolock_hold_lvb - hold on to a lock value block | |
135 | * @lock: the lock the LVB is associated with | |
136 | * @lvbp: return the lm_lvb_t here | |
137 | * | |
138 | * Returns: 0 on success, -EXXX on failure | |
139 | */ | |
140 | ||
141 | static int nolock_hold_lvb(lm_lock_t *lock, char **lvbp) | |
142 | { | |
143 | struct nolock_lockspace *nl = (struct nolock_lockspace *)lock; | |
144 | int error = 0; | |
145 | ||
d92a8d48 SW |
146 | *lvbp = kzalloc(nl->nl_lvb_size, GFP_KERNEL); |
147 | if (!*lvbp) | |
29b7998d DT |
148 | error = -ENOMEM; |
149 | ||
150 | return error; | |
151 | } | |
152 | ||
153 | /** | |
154 | * nolock_unhold_lvb - release a LVB | |
155 | * @lock: the lock the LVB is associated with | |
156 | * @lvb: the lock value block | |
157 | * | |
158 | */ | |
159 | ||
160 | static void nolock_unhold_lvb(lm_lock_t *lock, char *lvb) | |
161 | { | |
162 | kfree(lvb); | |
163 | } | |
164 | ||
165 | /** | |
166 | * nolock_sync_lvb - sync out the value of a lvb | |
167 | * @lock: the lock the LVB is associated with | |
168 | * @lvb: the lock value block | |
169 | * | |
170 | */ | |
171 | ||
172 | static void nolock_sync_lvb(lm_lock_t *lock, char *lvb) | |
173 | { | |
174 | } | |
175 | ||
29b7998d DT |
176 | static int nolock_plock_get(lm_lockspace_t *lockspace, struct lm_lockname *name, |
177 | struct file *file, struct file_lock *fl) | |
178 | { | |
8628de05 SW |
179 | struct file_lock tmp; |
180 | int ret; | |
29b7998d | 181 | |
8628de05 | 182 | ret = posix_test_lock(file, fl, &tmp); |
29b7998d | 183 | fl->fl_type = F_UNLCK; |
8628de05 SW |
184 | if (ret) |
185 | memcpy(fl, &tmp, sizeof(struct file_lock)); | |
29b7998d DT |
186 | |
187 | return 0; | |
188 | } | |
189 | ||
29b7998d DT |
190 | static int nolock_plock(lm_lockspace_t *lockspace, struct lm_lockname *name, |
191 | struct file *file, int cmd, struct file_lock *fl) | |
192 | { | |
193 | int error; | |
29b7998d | 194 | error = posix_lock_file_wait(file, fl); |
29b7998d DT |
195 | return error; |
196 | } | |
197 | ||
29b7998d DT |
198 | static int nolock_punlock(lm_lockspace_t *lockspace, struct lm_lockname *name, |
199 | struct file *file, struct file_lock *fl) | |
200 | { | |
201 | int error; | |
29b7998d | 202 | error = posix_lock_file_wait(file, fl); |
29b7998d DT |
203 | return error; |
204 | } | |
205 | ||
29b7998d DT |
206 | static void nolock_recovery_done(lm_lockspace_t *lockspace, unsigned int jid, |
207 | unsigned int message) | |
208 | { | |
209 | } | |
210 | ||
08bc2dbc | 211 | static struct lm_lockops nolock_ops = { |
29b7998d DT |
212 | .lm_proto_name = "lock_nolock", |
213 | .lm_mount = nolock_mount, | |
214 | .lm_others_may_mount = nolock_others_may_mount, | |
215 | .lm_unmount = nolock_unmount, | |
216 | .lm_withdraw = nolock_withdraw, | |
217 | .lm_get_lock = nolock_get_lock, | |
218 | .lm_put_lock = nolock_put_lock, | |
219 | .lm_lock = nolock_lock, | |
220 | .lm_unlock = nolock_unlock, | |
221 | .lm_cancel = nolock_cancel, | |
222 | .lm_hold_lvb = nolock_hold_lvb, | |
223 | .lm_unhold_lvb = nolock_unhold_lvb, | |
224 | .lm_sync_lvb = nolock_sync_lvb, | |
225 | .lm_plock_get = nolock_plock_get, | |
226 | .lm_plock = nolock_plock, | |
227 | .lm_punlock = nolock_punlock, | |
228 | .lm_recovery_done = nolock_recovery_done, | |
229 | .lm_owner = THIS_MODULE, | |
230 | }; | |
231 | ||
08bc2dbc | 232 | static int __init init_nolock(void) |
29b7998d DT |
233 | { |
234 | int error; | |
235 | ||
3120ec54 | 236 | error = gfs2_register_lockproto(&nolock_ops); |
29b7998d | 237 | if (error) { |
f382894e SW |
238 | printk(KERN_WARNING |
239 | "lock_nolock: can't register protocol: %d\n", error); | |
29b7998d DT |
240 | return error; |
241 | } | |
242 | ||
f382894e SW |
243 | printk(KERN_INFO |
244 | "Lock_Nolock (built %s %s) installed\n", __DATE__, __TIME__); | |
29b7998d DT |
245 | return 0; |
246 | } | |
247 | ||
08bc2dbc | 248 | static void __exit exit_nolock(void) |
29b7998d | 249 | { |
3120ec54 | 250 | gfs2_unregister_lockproto(&nolock_ops); |
29b7998d DT |
251 | } |
252 | ||
253 | module_init(init_nolock); | |
254 | module_exit(exit_nolock); | |
255 | ||
256 | MODULE_DESCRIPTION("GFS Nolock Locking Module"); | |
257 | MODULE_AUTHOR("Red Hat, Inc."); | |
258 | MODULE_LICENSE("GPL"); | |
259 |