1
2
3
4
5
6
7
8
9#include <linux/types.h>
10#include <linux/string.h>
11#include <linux/time.h>
12#include <linux/in.h>
13#include <linux/mutex.h>
14#include <linux/sunrpc/svc.h>
15#include <linux/sunrpc/clnt.h>
16#include <linux/nfsd/nfsfh.h>
17#include <linux/nfsd/export.h>
18#include <linux/lockd/lockd.h>
19#include <linux/lockd/share.h>
20#include <linux/module.h>
21#include <linux/mount.h>
22
23#define NLMDBG_FACILITY NLMDBG_SVCSUBS
24
25
26
27
28
29#define FILE_HASH_BITS 7
30#define FILE_NRHASH (1<<FILE_HASH_BITS)
31static struct hlist_head nlm_files[FILE_NRHASH];
32static DEFINE_MUTEX(nlm_file_mutex);
33
34#ifdef NFSD_DEBUG
35static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
36{
37 u32 *fhp = (u32*)f->data;
38
39
40 dprintk("lockd: %s (%08x %08x %08x %08x %08x %08x %08x %08x)\n",
41 msg, fhp[0], fhp[1], fhp[2], fhp[3],
42 fhp[4], fhp[5], fhp[6], fhp[7]);
43}
44
45static inline void nlm_debug_print_file(char *msg, struct nlm_file *file)
46{
47 struct inode *inode = file->f_file->f_path.dentry->d_inode;
48
49 dprintk("lockd: %s %s/%ld\n",
50 msg, inode->i_sb->s_id, inode->i_ino);
51}
52#else
53static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
54{
55 return;
56}
57
58static inline void nlm_debug_print_file(char *msg, struct nlm_file *file)
59{
60 return;
61}
62#endif
63
64static inline unsigned int file_hash(struct nfs_fh *f)
65{
66 unsigned int tmp=0;
67 int i;
68 for (i=0; i<NFS2_FHSIZE;i++)
69 tmp += f->data[i];
70 return tmp & (FILE_NRHASH - 1);
71}
72
73
74
75
76
77
78
79
80
81
82__be32
83nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result,
84 struct nfs_fh *f)
85{
86 struct hlist_node *pos;
87 struct nlm_file *file;
88 unsigned int hash;
89 __be32 nfserr;
90
91 nlm_debug_print_fh("nlm_lookup_file", f);
92
93 hash = file_hash(f);
94
95
96 mutex_lock(&nlm_file_mutex);
97
98 hlist_for_each_entry(file, pos, &nlm_files[hash], f_list)
99 if (!nfs_compare_fh(&file->f_handle, f))
100 goto found;
101
102 nlm_debug_print_fh("creating file for", f);
103
104 nfserr = nlm_lck_denied_nolocks;
105 file = kzalloc(sizeof(*file), GFP_KERNEL);
106 if (!file)
107 goto out_unlock;
108
109 memcpy(&file->f_handle, f, sizeof(struct nfs_fh));
110 mutex_init(&file->f_mutex);
111 INIT_HLIST_NODE(&file->f_list);
112 INIT_LIST_HEAD(&file->f_blocks);
113
114
115
116
117
118
119
120 if ((nfserr = nlmsvc_ops->fopen(rqstp, f, &file->f_file)) != 0) {
121 dprintk("lockd: open failed (error %d)\n", nfserr);
122 goto out_free;
123 }
124
125 hlist_add_head(&file->f_list, &nlm_files[hash]);
126
127found:
128 dprintk("lockd: found file %p (count %d)\n", file, file->f_count);
129 *result = file;
130 file->f_count++;
131 nfserr = 0;
132
133out_unlock:
134 mutex_unlock(&nlm_file_mutex);
135 return nfserr;
136
137out_free:
138 kfree(file);
139 goto out_unlock;
140}
141
142
143
144
145static inline void
146nlm_delete_file(struct nlm_file *file)
147{
148 nlm_debug_print_file("closing file", file);
149 if (!hlist_unhashed(&file->f_list)) {
150 hlist_del(&file->f_list);
151 nlmsvc_ops->fclose(file->f_file);
152 kfree(file);
153 } else {
154 printk(KERN_WARNING "lockd: attempt to release unknown file!\n");
155 }
156}
157
158
159
160
161
162static int
163nlm_traverse_locks(struct nlm_host *host, struct nlm_file *file,
164 nlm_host_match_fn_t match)
165{
166 struct inode *inode = nlmsvc_file_inode(file);
167 struct file_lock *fl;
168 struct nlm_host *lockhost;
169
170again:
171 file->f_locks = 0;
172 for (fl = inode->i_flock; fl; fl = fl->fl_next) {
173 if (fl->fl_lmops != &nlmsvc_lock_operations)
174 continue;
175
176
177 file->f_locks++;
178
179 lockhost = (struct nlm_host *) fl->fl_owner;
180 if (match(lockhost, host)) {
181 struct file_lock lock = *fl;
182
183 lock.fl_type = F_UNLCK;
184 lock.fl_start = 0;
185 lock.fl_end = OFFSET_MAX;
186 if (vfs_lock_file(file->f_file, F_SETLK, &lock, NULL) < 0) {
187 printk("lockd: unlock failure in %s:%d\n",
188 __FILE__, __LINE__);
189 return 1;
190 }
191 goto again;
192 }
193 }
194
195 return 0;
196}
197
198static int
199nlmsvc_always_match(void *dummy1, struct nlm_host *dummy2)
200{
201 return 1;
202}
203
204
205
206
207static inline int
208nlm_inspect_file(struct nlm_host *host, struct nlm_file *file, nlm_host_match_fn_t match)
209{
210 nlmsvc_traverse_blocks(host, file, match);
211 nlmsvc_traverse_shares(host, file, match);
212 return nlm_traverse_locks(host, file, match);
213}
214
215
216
217
218
219static inline int
220nlm_file_inuse(struct nlm_file *file)
221{
222 struct inode *inode = nlmsvc_file_inode(file);
223 struct file_lock *fl;
224
225 if (file->f_count || !list_empty(&file->f_blocks) || file->f_shares)
226 return 1;
227
228 for (fl = inode->i_flock; fl; fl = fl->fl_next) {
229 if (fl->fl_lmops == &nlmsvc_lock_operations)
230 return 1;
231 }
232 file->f_locks = 0;
233 return 0;
234}
235
236
237
238
239static int
240nlm_traverse_files(void *data, nlm_host_match_fn_t match,
241 int (*is_failover_file)(void *data, struct nlm_file *file))
242{
243 struct hlist_node *pos, *next;
244 struct nlm_file *file;
245 int i, ret = 0;
246
247 mutex_lock(&nlm_file_mutex);
248 for (i = 0; i < FILE_NRHASH; i++) {
249 hlist_for_each_entry_safe(file, pos, next, &nlm_files[i], f_list) {
250 if (is_failover_file && !is_failover_file(data, file))
251 continue;
252 file->f_count++;
253 mutex_unlock(&nlm_file_mutex);
254
255
256
257 if (nlm_inspect_file(data, file, match))
258 ret = 1;
259
260 mutex_lock(&nlm_file_mutex);
261 file->f_count--;
262
263 if (list_empty(&file->f_blocks) && !file->f_locks
264 && !file->f_shares && !file->f_count) {
265 hlist_del(&file->f_list);
266 nlmsvc_ops->fclose(file->f_file);
267 kfree(file);
268 }
269 }
270 }
271 mutex_unlock(&nlm_file_mutex);
272 return ret;
273}
274
275
276
277
278
279
280
281
282
283
284void
285nlm_release_file(struct nlm_file *file)
286{
287 dprintk("lockd: nlm_release_file(%p, ct = %d)\n",
288 file, file->f_count);
289
290
291 mutex_lock(&nlm_file_mutex);
292
293
294 if (--file->f_count == 0 && !nlm_file_inuse(file))
295 nlm_delete_file(file);
296
297 mutex_unlock(&nlm_file_mutex);
298}
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315static int
316nlmsvc_mark_host(void *data, struct nlm_host *dummy)
317{
318 struct nlm_host *host = data;
319
320 host->h_inuse = 1;
321 return 0;
322}
323
324static int
325nlmsvc_same_host(void *data, struct nlm_host *other)
326{
327 struct nlm_host *host = data;
328
329 return host == other;
330}
331
332static int
333nlmsvc_is_client(void *data, struct nlm_host *dummy)
334{
335 struct nlm_host *host = data;
336
337 if (host->h_server) {
338
339
340
341
342 if (host->h_nsmhandle)
343 host->h_nsmhandle->sm_sticky = 1;
344 return 1;
345 } else
346 return 0;
347}
348
349
350
351
352void
353nlmsvc_mark_resources(void)
354{
355 dprintk("lockd: nlmsvc_mark_resources\n");
356 nlm_traverse_files(NULL, nlmsvc_mark_host, NULL);
357}
358
359
360
361
362void
363nlmsvc_free_host_resources(struct nlm_host *host)
364{
365 dprintk("lockd: nlmsvc_free_host_resources\n");
366
367 if (nlm_traverse_files(host, nlmsvc_same_host, NULL)) {
368 printk(KERN_WARNING
369 "lockd: couldn't remove all locks held by %s\n",
370 host->h_name);
371 BUG();
372 }
373}
374
375
376
377
378
379
380
381void
382nlmsvc_invalidate_all(void)
383{
384
385
386
387
388
389
390 nlm_traverse_files(NULL, nlmsvc_is_client, NULL);
391}
392
393static int
394nlmsvc_match_sb(void *datap, struct nlm_file *file)
395{
396 struct super_block *sb = datap;
397
398 return sb == file->f_file->f_path.mnt->mnt_sb;
399}
400
401
402
403
404
405
406
407int
408nlmsvc_unlock_all_by_sb(struct super_block *sb)
409{
410 int ret;
411
412 ret = nlm_traverse_files(sb, nlmsvc_always_match, nlmsvc_match_sb);
413 return ret ? -EIO : 0;
414}
415EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_sb);
416
417static int
418nlmsvc_match_ip(void *datap, struct nlm_host *host)
419{
420 return rpc_cmp_addr(nlm_srcaddr(host), datap);
421}
422
423
424
425
426
427
428
429
430int
431nlmsvc_unlock_all_by_ip(struct sockaddr *server_addr)
432{
433 int ret;
434
435 ret = nlm_traverse_files(server_addr, nlmsvc_match_ip, NULL);
436 return ret ? -EIO : 0;
437}
438EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_ip);
439