blob: a1c7c08484159aa8f66fd1254941e4eb5e56ab5f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/lockd/svcsubs.c
3 *
4 * Various support routines for the NLM server.
5 *
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
7 */
8
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/types.h>
10#include <linux/string.h>
11#include <linux/time.h>
12#include <linux/in.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080013#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#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/lockd/sm_inter.h>
21
22#define NLMDBG_FACILITY NLMDBG_SVCSUBS
23
24
25/*
26 * Global file hash table
27 */
Olaf Kirch07ba8062006-10-04 02:15:58 -070028#define FILE_HASH_BITS 7
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#define FILE_NRHASH (1<<FILE_HASH_BITS)
Olaf Kirch07ba8062006-10-04 02:15:58 -070030static struct hlist_head nlm_files[FILE_NRHASH];
Ingo Molnar353ab6e2006-03-26 01:37:12 -080031static DEFINE_MUTEX(nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Chuck Lever0bbacc42005-11-01 16:53:32 -050033#ifdef NFSD_DEBUG
34static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
35{
36 u32 *fhp = (u32*)f->data;
37
38 /* print the first 32 bytes of the fh */
39 dprintk("lockd: %s (%08x %08x %08x %08x %08x %08x %08x %08x)\n",
40 msg, fhp[0], fhp[1], fhp[2], fhp[3],
41 fhp[4], fhp[5], fhp[6], fhp[7]);
42}
43
44static inline void nlm_debug_print_file(char *msg, struct nlm_file *file)
45{
46 struct inode *inode = file->f_file->f_dentry->d_inode;
47
48 dprintk("lockd: %s %s/%ld\n",
49 msg, inode->i_sb->s_id, inode->i_ino);
50}
51#else
52static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
53{
54 return;
55}
56
57static inline void nlm_debug_print_file(char *msg, struct nlm_file *file)
58{
59 return;
60}
61#endif
62
Linus Torvalds1da177e2005-04-16 15:20:36 -070063static inline unsigned int file_hash(struct nfs_fh *f)
64{
65 unsigned int tmp=0;
66 int i;
67 for (i=0; i<NFS2_FHSIZE;i++)
68 tmp += f->data[i];
69 return tmp & (FILE_NRHASH - 1);
70}
71
72/*
73 * Lookup file info. If it doesn't exist, create a file info struct
74 * and open a (VFS) file for the given inode.
75 *
76 * FIXME:
77 * Note that we open the file O_RDONLY even when creating write locks.
78 * This is not quite right, but for now, we assume the client performs
79 * the proper R/W checking.
80 */
81u32
82nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result,
83 struct nfs_fh *f)
84{
Olaf Kirch07ba8062006-10-04 02:15:58 -070085 struct hlist_node *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 struct nlm_file *file;
87 unsigned int hash;
88 u32 nfserr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Chuck Lever0bbacc42005-11-01 16:53:32 -050090 nlm_debug_print_fh("nlm_file_lookup", f);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92 hash = file_hash(f);
93
94 /* Lock file table */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080095 mutex_lock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
Olaf Kirch07ba8062006-10-04 02:15:58 -070097 hlist_for_each_entry(file, pos, &nlm_files[hash], f_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 if (!nfs_compare_fh(&file->f_handle, f))
99 goto found;
100
Chuck Lever0bbacc42005-11-01 16:53:32 -0500101 nlm_debug_print_fh("creating file for", f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
103 nfserr = nlm_lck_denied_nolocks;
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -0700104 file = kzalloc(sizeof(*file), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 if (!file)
106 goto out_unlock;
107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 memcpy(&file->f_handle, f, sizeof(struct nfs_fh));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 init_MUTEX(&file->f_sema);
Olaf Kirch07ba8062006-10-04 02:15:58 -0700110 INIT_HLIST_NODE(&file->f_list);
Olaf Kirch68a2d762006-10-04 02:15:57 -0700111 INIT_LIST_HEAD(&file->f_blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
113 /* Open the file. Note that this must not sleep for too long, else
114 * we would lock up lockd:-) So no NFS re-exports, folks.
115 *
116 * We have to make sure we have the right credential to open
117 * the file.
118 */
119 if ((nfserr = nlmsvc_ops->fopen(rqstp, f, &file->f_file)) != 0) {
Olaf Kirchf0737a32006-10-04 02:15:54 -0700120 dprintk("lockd: open failed (error %d)\n", nfserr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 goto out_free;
122 }
123
Olaf Kirch07ba8062006-10-04 02:15:58 -0700124 hlist_add_head(&file->f_list, &nlm_files[hash]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126found:
127 dprintk("lockd: found file %p (count %d)\n", file, file->f_count);
128 *result = file;
129 file->f_count++;
130 nfserr = 0;
131
132out_unlock:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800133 mutex_unlock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 return nfserr;
135
136out_free:
137 kfree(file);
138#ifdef CONFIG_LOCKD_V4
139 if (nfserr == 1)
140 nfserr = nlm4_stale_fh;
141 else
142#endif
143 nfserr = nlm_lck_denied;
144 goto out_unlock;
145}
146
147/*
148 * Delete a file after having released all locks, blocks and shares
149 */
150static inline void
151nlm_delete_file(struct nlm_file *file)
152{
Chuck Lever0bbacc42005-11-01 16:53:32 -0500153 nlm_debug_print_file("closing file", file);
Olaf Kirch07ba8062006-10-04 02:15:58 -0700154 if (!hlist_unhashed(&file->f_list)) {
155 hlist_del(&file->f_list);
156 nlmsvc_ops->fclose(file->f_file);
157 kfree(file);
158 } else {
159 printk(KERN_WARNING "lockd: attempt to release unknown file!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161}
162
163/*
164 * Loop over all locks on the given file and perform the specified
165 * action.
166 */
167static int
Olaf Kirchf2af7932006-10-04 02:15:59 -0700168nlm_traverse_locks(struct nlm_host *host, struct nlm_file *file,
169 nlm_host_match_fn_t match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
171 struct inode *inode = nlmsvc_file_inode(file);
172 struct file_lock *fl;
173 struct nlm_host *lockhost;
174
175again:
176 file->f_locks = 0;
177 for (fl = inode->i_flock; fl; fl = fl->fl_next) {
J. Bruce Fields7117bf32006-03-20 13:44:26 -0500178 if (fl->fl_lmops != &nlmsvc_lock_operations)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 continue;
180
181 /* update current lock count */
182 file->f_locks++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Olaf Kirchf2af7932006-10-04 02:15:59 -0700184 lockhost = (struct nlm_host *) fl->fl_owner;
185 if (match(lockhost, host)) {
186 struct file_lock lock = *fl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 lock.fl_type = F_UNLCK;
189 lock.fl_start = 0;
190 lock.fl_end = OFFSET_MAX;
191 if (posix_lock_file(file->f_file, &lock) < 0) {
192 printk("lockd: unlock failure in %s:%d\n",
193 __FILE__, __LINE__);
194 return 1;
195 }
196 goto again;
197 }
198 }
199
200 return 0;
201}
202
203/*
Olaf Kirchf2af7932006-10-04 02:15:59 -0700204 * Inspect a single file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 */
206static inline int
Olaf Kirchf2af7932006-10-04 02:15:59 -0700207nlm_inspect_file(struct nlm_host *host, struct nlm_file *file, nlm_host_match_fn_t match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208{
Olaf Kirchf2af7932006-10-04 02:15:59 -0700209 nlmsvc_traverse_blocks(host, file, match);
210 nlmsvc_traverse_shares(host, file, match);
211 return nlm_traverse_locks(host, file, match);
212}
213
214/*
215 * Quick check whether there are still any locks, blocks or
216 * shares on a given file.
217 */
218static inline int
219nlm_file_inuse(struct nlm_file *file)
220{
221 struct inode *inode = nlmsvc_file_inode(file);
222 struct file_lock *fl;
223
224 if (file->f_count || !list_empty(&file->f_blocks) || file->f_shares)
225 return 1;
226
227 for (fl = inode->i_flock; fl; fl = fl->fl_next) {
228 if (fl->fl_lmops == &nlmsvc_lock_operations)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 }
Olaf Kirchf2af7932006-10-04 02:15:59 -0700231 file->f_locks = 0;
232 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233}
234
235/*
236 * Loop over all files in the file table.
237 */
238static int
Olaf Kirchf2af7932006-10-04 02:15:59 -0700239nlm_traverse_files(struct nlm_host *host, nlm_host_match_fn_t match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Olaf Kirch07ba8062006-10-04 02:15:58 -0700241 struct hlist_node *pos, *next;
242 struct nlm_file *file;
Trond Myklebust01df9c52006-08-10 11:58:57 -0400243 int i, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800245 mutex_lock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 for (i = 0; i < FILE_NRHASH; i++) {
Olaf Kirch07ba8062006-10-04 02:15:58 -0700247 hlist_for_each_entry_safe(file, pos, next, &nlm_files[i], f_list) {
Trond Myklebust01df9c52006-08-10 11:58:57 -0400248 file->f_count++;
249 mutex_unlock(&nlm_file_mutex);
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 /* Traverse locks, blocks and shares of this file
252 * and update file->f_locks count */
Olaf Kirchf2af7932006-10-04 02:15:59 -0700253 if (nlm_inspect_file(host, file, match))
Trond Myklebust01df9c52006-08-10 11:58:57 -0400254 ret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
Trond Myklebust01df9c52006-08-10 11:58:57 -0400256 mutex_lock(&nlm_file_mutex);
257 file->f_count--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 /* No more references to this file. Let go of it. */
Olaf Kirch68a2d762006-10-04 02:15:57 -0700259 if (list_empty(&file->f_blocks) && !file->f_locks
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 && !file->f_shares && !file->f_count) {
Olaf Kirch07ba8062006-10-04 02:15:58 -0700261 hlist_del(&file->f_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 nlmsvc_ops->fclose(file->f_file);
263 kfree(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 }
265 }
266 }
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800267 mutex_unlock(&nlm_file_mutex);
Trond Myklebust01df9c52006-08-10 11:58:57 -0400268 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
270
271/*
272 * Release file. If there are no more remote locks on this file,
273 * close it and free the handle.
274 *
275 * Note that we can't do proper reference counting without major
276 * contortions because the code in fs/locks.c creates, deletes and
277 * splits locks without notification. Our only way is to walk the
278 * entire lock list each time we remove a lock.
279 */
280void
281nlm_release_file(struct nlm_file *file)
282{
283 dprintk("lockd: nlm_release_file(%p, ct = %d)\n",
284 file, file->f_count);
285
286 /* Lock file table */
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800287 mutex_lock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 /* If there are no more locks etc, delete the file */
Olaf Kirchf2af7932006-10-04 02:15:59 -0700290 if (--file->f_count == 0 && !nlm_file_inuse(file))
291 nlm_delete_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800293 mutex_unlock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294}
295
296/*
Olaf Kirchf2af7932006-10-04 02:15:59 -0700297 * Helpers function for resource traversal
298 *
299 * nlmsvc_mark_host:
300 * used by the garbage collector; simply sets h_inuse.
301 * Always returns 0.
302 *
303 * nlmsvc_same_host:
304 * returns 1 iff the two hosts match. Used to release
305 * all resources bound to a specific host.
306 *
307 * nlmsvc_is_client:
308 * returns 1 iff the host is a client.
309 * Used by nlmsvc_invalidate_all
310 */
311static int
312nlmsvc_mark_host(struct nlm_host *host, struct nlm_host *dummy)
313{
314 host->h_inuse = 1;
315 return 0;
316}
317
318static int
319nlmsvc_same_host(struct nlm_host *host, struct nlm_host *other)
320{
321 return host == other;
322}
323
324static int
325nlmsvc_is_client(struct nlm_host *host, struct nlm_host *dummy)
326{
327 return host->h_server;
328}
329
330/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 * Mark all hosts that still hold resources
332 */
333void
334nlmsvc_mark_resources(void)
335{
336 dprintk("lockd: nlmsvc_mark_resources\n");
Olaf Kirchf2af7932006-10-04 02:15:59 -0700337 nlm_traverse_files(NULL, nlmsvc_mark_host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338}
339
340/*
341 * Release all resources held by the given client
342 */
343void
344nlmsvc_free_host_resources(struct nlm_host *host)
345{
346 dprintk("lockd: nlmsvc_free_host_resources\n");
347
Olaf Kirchf2af7932006-10-04 02:15:59 -0700348 if (nlm_traverse_files(host, nlmsvc_same_host)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 printk(KERN_WARNING
Olaf Kirchf0737a32006-10-04 02:15:54 -0700350 "lockd: couldn't remove all locks held by %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 host->h_name);
Olaf Kirchf0737a32006-10-04 02:15:54 -0700352 BUG();
353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354}
355
356/*
NeilBrown350fce82006-10-04 02:16:00 -0700357 * Remove all locks held for clients
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 */
359void
360nlmsvc_invalidate_all(void)
361{
Olaf Kirchf2af7932006-10-04 02:15:59 -0700362 /* Release all locks held by NFS clients.
363 * Previously, the code would call
364 * nlmsvc_free_host_resources for each client in
365 * turn, which is about as inefficient as it gets.
366 * Now we just do it once in nlm_traverse_files.
367 */
368 nlm_traverse_files(NULL, nlmsvc_is_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369}