blob: 62f4a385177f355c993ca957cca12974d20e9d27 [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
9#include <linux/config.h>
10#include <linux/types.h>
11#include <linux/string.h>
12#include <linux/time.h>
13#include <linux/in.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/lockd/sm_inter.h>
21
22#define NLMDBG_FACILITY NLMDBG_SVCSUBS
23
24
25/*
26 * Global file hash table
27 */
28#define FILE_HASH_BITS 5
29#define FILE_NRHASH (1<<FILE_HASH_BITS)
30static struct nlm_file * nlm_files[FILE_NRHASH];
31static DECLARE_MUTEX(nlm_file_sema);
32
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{
85 struct nlm_file *file;
86 unsigned int hash;
87 u32 nfserr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Chuck Lever0bbacc42005-11-01 16:53:32 -050089 nlm_debug_print_fh("nlm_file_lookup", f);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
91 hash = file_hash(f);
92
93 /* Lock file table */
94 down(&nlm_file_sema);
95
96 for (file = nlm_files[hash]; file; file = file->f_next)
97 if (!nfs_compare_fh(&file->f_handle, f))
98 goto found;
99
Chuck Lever0bbacc42005-11-01 16:53:32 -0500100 nlm_debug_print_fh("creating file for", f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
102 nfserr = nlm_lck_denied_nolocks;
103 file = (struct nlm_file *) kmalloc(sizeof(*file), GFP_KERNEL);
104 if (!file)
105 goto out_unlock;
106
107 memset(file, 0, sizeof(*file));
108 memcpy(&file->f_handle, f, sizeof(struct nfs_fh));
109 file->f_hash = hash;
110 init_MUTEX(&file->f_sema);
111
112 /* Open the file. Note that this must not sleep for too long, else
113 * we would lock up lockd:-) So no NFS re-exports, folks.
114 *
115 * We have to make sure we have the right credential to open
116 * the file.
117 */
118 if ((nfserr = nlmsvc_ops->fopen(rqstp, f, &file->f_file)) != 0) {
119 dprintk("lockd: open failed (nfserr %d)\n", ntohl(nfserr));
120 goto out_free;
121 }
122
123 file->f_next = nlm_files[hash];
124 nlm_files[hash] = file;
125
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:
133 up(&nlm_file_sema);
134 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{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 struct nlm_file **fp, *f;
154
Chuck Lever0bbacc42005-11-01 16:53:32 -0500155 nlm_debug_print_file("closing file", file);
156
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 fp = nlm_files + file->f_hash;
158 while ((f = *fp) != NULL) {
159 if (f == file) {
160 *fp = file->f_next;
161 nlmsvc_ops->fclose(file->f_file);
162 kfree(file);
163 return;
164 }
165 fp = &f->f_next;
166 }
167
168 printk(KERN_WARNING "lockd: attempt to release unknown file!\n");
169}
170
171/*
172 * Loop over all locks on the given file and perform the specified
173 * action.
174 */
175static int
176nlm_traverse_locks(struct nlm_host *host, struct nlm_file *file, int action)
177{
178 struct inode *inode = nlmsvc_file_inode(file);
179 struct file_lock *fl;
180 struct nlm_host *lockhost;
181
182again:
183 file->f_locks = 0;
184 for (fl = inode->i_flock; fl; fl = fl->fl_next) {
185 if (!(fl->fl_flags & FL_LOCKD))
186 continue;
187
188 /* update current lock count */
189 file->f_locks++;
190 lockhost = (struct nlm_host *) fl->fl_owner;
191 if (action == NLM_ACT_MARK)
192 lockhost->h_inuse = 1;
193 else if (action == NLM_ACT_CHECK)
194 return 1;
195 else if (action == NLM_ACT_UNLOCK) {
196 struct file_lock lock = *fl;
197
198 if (host && lockhost != host)
199 continue;
200
201 lock.fl_type = F_UNLCK;
202 lock.fl_start = 0;
203 lock.fl_end = OFFSET_MAX;
204 if (posix_lock_file(file->f_file, &lock) < 0) {
205 printk("lockd: unlock failure in %s:%d\n",
206 __FILE__, __LINE__);
207 return 1;
208 }
209 goto again;
210 }
211 }
212
213 return 0;
214}
215
216/*
217 * Operate on a single file
218 */
219static inline int
220nlm_inspect_file(struct nlm_host *host, struct nlm_file *file, int action)
221{
222 if (action == NLM_ACT_CHECK) {
223 /* Fast path for mark and sweep garbage collection */
224 if (file->f_count || file->f_blocks || file->f_shares)
225 return 1;
226 } else {
227 if (nlmsvc_traverse_blocks(host, file, action)
228 || nlmsvc_traverse_shares(host, file, action))
229 return 1;
230 }
231 return nlm_traverse_locks(host, file, action);
232}
233
234/*
235 * Loop over all files in the file table.
236 */
237static int
238nlm_traverse_files(struct nlm_host *host, int action)
239{
240 struct nlm_file *file, **fp;
241 int i;
242
243 down(&nlm_file_sema);
244 for (i = 0; i < FILE_NRHASH; i++) {
245 fp = nlm_files + i;
246 while ((file = *fp) != NULL) {
247 /* Traverse locks, blocks and shares of this file
248 * and update file->f_locks count */
249 if (nlm_inspect_file(host, file, action)) {
250 up(&nlm_file_sema);
251 return 1;
252 }
253
254 /* No more references to this file. Let go of it. */
255 if (!file->f_blocks && !file->f_locks
256 && !file->f_shares && !file->f_count) {
257 *fp = file->f_next;
258 nlmsvc_ops->fclose(file->f_file);
259 kfree(file);
260 } else {
261 fp = &file->f_next;
262 }
263 }
264 }
265 up(&nlm_file_sema);
266 return 0;
267}
268
269/*
270 * Release file. If there are no more remote locks on this file,
271 * close it and free the handle.
272 *
273 * Note that we can't do proper reference counting without major
274 * contortions because the code in fs/locks.c creates, deletes and
275 * splits locks without notification. Our only way is to walk the
276 * entire lock list each time we remove a lock.
277 */
278void
279nlm_release_file(struct nlm_file *file)
280{
281 dprintk("lockd: nlm_release_file(%p, ct = %d)\n",
282 file, file->f_count);
283
284 /* Lock file table */
285 down(&nlm_file_sema);
286
287 /* If there are no more locks etc, delete the file */
288 if(--file->f_count == 0) {
289 if(!nlm_inspect_file(NULL, file, NLM_ACT_CHECK))
290 nlm_delete_file(file);
291 }
292
293 up(&nlm_file_sema);
294}
295
296/*
297 * Mark all hosts that still hold resources
298 */
299void
300nlmsvc_mark_resources(void)
301{
302 dprintk("lockd: nlmsvc_mark_resources\n");
303
304 nlm_traverse_files(NULL, NLM_ACT_MARK);
305}
306
307/*
308 * Release all resources held by the given client
309 */
310void
311nlmsvc_free_host_resources(struct nlm_host *host)
312{
313 dprintk("lockd: nlmsvc_free_host_resources\n");
314
315 if (nlm_traverse_files(host, NLM_ACT_UNLOCK))
316 printk(KERN_WARNING
317 "lockd: couldn't remove all locks held by %s",
318 host->h_name);
319}
320
321/*
322 * delete all hosts structs for clients
323 */
324void
325nlmsvc_invalidate_all(void)
326{
327 struct nlm_host *host;
328 while ((host = nlm_find_client()) != NULL) {
329 nlmsvc_free_host_resources(host);
330 host->h_expires = 0;
331 host->h_killed = 1;
332 nlm_release_host(host);
333 }
334}