2 * linux/fs/lockd/svcsubs.c
4 * Various support routines for the NLM server.
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
9 #include <linux/types.h>
10 #include <linux/string.h>
11 #include <linux/time.h>
13 #include <linux/slab.h>
14 #include <linux/mutex.h>
15 #include <linux/sunrpc/svc.h>
16 #include <linux/sunrpc/addr.h>
17 #include <linux/lockd/lockd.h>
18 #include <linux/lockd/share.h>
19 #include <linux/module.h>
20 #include <linux/mount.h>
21 #include <uapi/linux/nfs2.h>
23 #define NLMDBG_FACILITY NLMDBG_SVCSUBS
27 * Global file hash table
29 #define FILE_HASH_BITS 7
30 #define FILE_NRHASH (1<<FILE_HASH_BITS)
31 static struct hlist_head nlm_files
[FILE_NRHASH
];
32 static DEFINE_MUTEX(nlm_file_mutex
);
35 static inline void nlm_debug_print_fh(char *msg
, struct nfs_fh
*f
)
37 u32
*fhp
= (u32
*)f
->data
;
39 /* print the first 32 bytes of the fh */
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]);
45 static inline void nlm_debug_print_file(char *msg
, struct nlm_file
*file
)
47 struct inode
*inode
= file_inode(file
->f_file
);
49 dprintk("lockd: %s %s/%ld\n",
50 msg
, inode
->i_sb
->s_id
, inode
->i_ino
);
53 static inline void nlm_debug_print_fh(char *msg
, struct nfs_fh
*f
)
58 static inline void nlm_debug_print_file(char *msg
, struct nlm_file
*file
)
64 static inline unsigned int file_hash(struct nfs_fh
*f
)
68 for (i
=0; i
<NFS2_FHSIZE
;i
++)
70 return tmp
& (FILE_NRHASH
- 1);
74 * Lookup file info. If it doesn't exist, create a file info struct
75 * and open a (VFS) file for the given inode.
78 * Note that we open the file O_RDONLY even when creating write locks.
79 * This is not quite right, but for now, we assume the client performs
80 * the proper R/W checking.
83 nlm_lookup_file(struct svc_rqst
*rqstp
, struct nlm_file
**result
,
86 struct nlm_file
*file
;
90 nlm_debug_print_fh("nlm_lookup_file", f
);
95 mutex_lock(&nlm_file_mutex
);
97 hlist_for_each_entry(file
, &nlm_files
[hash
], f_list
)
98 if (!nfs_compare_fh(&file
->f_handle
, f
))
101 nlm_debug_print_fh("creating file for", f
);
103 nfserr
= nlm_lck_denied_nolocks
;
104 file
= kzalloc(sizeof(*file
), GFP_KERNEL
);
108 memcpy(&file
->f_handle
, f
, sizeof(struct nfs_fh
));
109 mutex_init(&file
->f_mutex
);
110 INIT_HLIST_NODE(&file
->f_list
);
111 INIT_LIST_HEAD(&file
->f_blocks
);
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.
116 * We have to make sure we have the right credential to open
119 if ((nfserr
= nlmsvc_ops
->fopen(rqstp
, f
, &file
->f_file
)) != 0) {
120 dprintk("lockd: open failed (error %d)\n", nfserr
);
124 hlist_add_head(&file
->f_list
, &nlm_files
[hash
]);
127 dprintk("lockd: found file %p (count %d)\n", file
, file
->f_count
);
133 mutex_unlock(&nlm_file_mutex
);
142 * Delete a file after having released all locks, blocks and shares
145 nlm_delete_file(struct nlm_file
*file
)
147 nlm_debug_print_file("closing file", file
);
148 if (!hlist_unhashed(&file
->f_list
)) {
149 hlist_del(&file
->f_list
);
150 nlmsvc_ops
->fclose(file
->f_file
);
153 printk(KERN_WARNING
"lockd: attempt to release unknown file!\n");
158 * Loop over all locks on the given file and perform the specified
162 nlm_traverse_locks(struct nlm_host
*host
, struct nlm_file
*file
,
163 nlm_host_match_fn_t match
)
165 struct inode
*inode
= nlmsvc_file_inode(file
);
166 struct file_lock
*fl
;
167 struct nlm_host
*lockhost
;
171 spin_lock(&inode
->i_lock
);
172 for (fl
= inode
->i_flock
; fl
; fl
= fl
->fl_next
) {
173 if (fl
->fl_lmops
!= &nlmsvc_lock_operations
)
176 /* update current lock count */
179 lockhost
= (struct nlm_host
*) fl
->fl_owner
;
180 if (match(lockhost
, host
)) {
181 struct file_lock lock
= *fl
;
183 spin_unlock(&inode
->i_lock
);
184 lock
.fl_type
= F_UNLCK
;
186 lock
.fl_end
= OFFSET_MAX
;
187 if (vfs_lock_file(file
->f_file
, F_SETLK
, &lock
, NULL
) < 0) {
188 printk("lockd: unlock failure in %s:%d\n",
195 spin_unlock(&inode
->i_lock
);
201 nlmsvc_always_match(void *dummy1
, struct nlm_host
*dummy2
)
207 * Inspect a single file
210 nlm_inspect_file(struct nlm_host
*host
, struct nlm_file
*file
, nlm_host_match_fn_t match
)
212 nlmsvc_traverse_blocks(host
, file
, match
);
213 nlmsvc_traverse_shares(host
, file
, match
);
214 return nlm_traverse_locks(host
, file
, match
);
218 * Quick check whether there are still any locks, blocks or
219 * shares on a given file.
222 nlm_file_inuse(struct nlm_file
*file
)
224 struct inode
*inode
= nlmsvc_file_inode(file
);
225 struct file_lock
*fl
;
227 if (file
->f_count
|| !list_empty(&file
->f_blocks
) || file
->f_shares
)
230 spin_lock(&inode
->i_lock
);
231 for (fl
= inode
->i_flock
; fl
; fl
= fl
->fl_next
) {
232 if (fl
->fl_lmops
== &nlmsvc_lock_operations
) {
233 spin_unlock(&inode
->i_lock
);
237 spin_unlock(&inode
->i_lock
);
243 * Loop over all files in the file table.
246 nlm_traverse_files(void *data
, nlm_host_match_fn_t match
,
247 int (*is_failover_file
)(void *data
, struct nlm_file
*file
))
249 struct hlist_node
*next
;
250 struct nlm_file
*file
;
253 mutex_lock(&nlm_file_mutex
);
254 for (i
= 0; i
< FILE_NRHASH
; i
++) {
255 hlist_for_each_entry_safe(file
, next
, &nlm_files
[i
], f_list
) {
256 if (is_failover_file
&& !is_failover_file(data
, file
))
259 mutex_unlock(&nlm_file_mutex
);
261 /* Traverse locks, blocks and shares of this file
262 * and update file->f_locks count */
263 if (nlm_inspect_file(data
, file
, match
))
266 mutex_lock(&nlm_file_mutex
);
268 /* No more references to this file. Let go of it. */
269 if (list_empty(&file
->f_blocks
) && !file
->f_locks
270 && !file
->f_shares
&& !file
->f_count
) {
271 hlist_del(&file
->f_list
);
272 nlmsvc_ops
->fclose(file
->f_file
);
277 mutex_unlock(&nlm_file_mutex
);
282 * Release file. If there are no more remote locks on this file,
283 * close it and free the handle.
285 * Note that we can't do proper reference counting without major
286 * contortions because the code in fs/locks.c creates, deletes and
287 * splits locks without notification. Our only way is to walk the
288 * entire lock list each time we remove a lock.
291 nlm_release_file(struct nlm_file
*file
)
293 dprintk("lockd: nlm_release_file(%p, ct = %d)\n",
294 file
, file
->f_count
);
296 /* Lock file table */
297 mutex_lock(&nlm_file_mutex
);
299 /* If there are no more locks etc, delete the file */
300 if (--file
->f_count
== 0 && !nlm_file_inuse(file
))
301 nlm_delete_file(file
);
303 mutex_unlock(&nlm_file_mutex
);
307 * Helpers function for resource traversal
310 * used by the garbage collector; simply sets h_inuse only for those
311 * hosts, which passed network check.
315 * returns 1 iff the two hosts match. Used to release
316 * all resources bound to a specific host.
319 * returns 1 iff the host is a client.
320 * Used by nlmsvc_invalidate_all
324 nlmsvc_mark_host(void *data
, struct nlm_host
*hint
)
326 struct nlm_host
*host
= data
;
328 if ((hint
->net
== NULL
) ||
329 (host
->net
== hint
->net
))
335 nlmsvc_same_host(void *data
, struct nlm_host
*other
)
337 struct nlm_host
*host
= data
;
339 return host
== other
;
343 nlmsvc_is_client(void *data
, struct nlm_host
*dummy
)
345 struct nlm_host
*host
= data
;
347 if (host
->h_server
) {
348 /* we are destroying locks even though the client
349 * hasn't asked us too, so don't unmonitor the
352 if (host
->h_nsmhandle
)
353 host
->h_nsmhandle
->sm_sticky
= 1;
360 * Mark all hosts that still hold resources
363 nlmsvc_mark_resources(struct net
*net
)
365 struct nlm_host hint
;
367 dprintk("lockd: nlmsvc_mark_resources for net %p\n", net
);
369 nlm_traverse_files(&hint
, nlmsvc_mark_host
, NULL
);
373 * Release all resources held by the given client
376 nlmsvc_free_host_resources(struct nlm_host
*host
)
378 dprintk("lockd: nlmsvc_free_host_resources\n");
380 if (nlm_traverse_files(host
, nlmsvc_same_host
, NULL
)) {
382 "lockd: couldn't remove all locks held by %s\n",
389 * nlmsvc_invalidate_all - remove all locks held for clients
391 * Release all locks held by NFS clients.
395 nlmsvc_invalidate_all(void)
398 * Previously, the code would call
399 * nlmsvc_free_host_resources for each client in
400 * turn, which is about as inefficient as it gets.
401 * Now we just do it once in nlm_traverse_files.
403 nlm_traverse_files(NULL
, nlmsvc_is_client
, NULL
);
407 nlmsvc_match_sb(void *datap
, struct nlm_file
*file
)
409 struct super_block
*sb
= datap
;
411 return sb
== file
->f_file
->f_path
.dentry
->d_sb
;
415 * nlmsvc_unlock_all_by_sb - release locks held on this file system
418 * Release all locks held by clients accessing this file system.
421 nlmsvc_unlock_all_by_sb(struct super_block
*sb
)
425 ret
= nlm_traverse_files(sb
, nlmsvc_always_match
, nlmsvc_match_sb
);
426 return ret
? -EIO
: 0;
428 EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_sb
);
431 nlmsvc_match_ip(void *datap
, struct nlm_host
*host
)
433 return rpc_cmp_addr(nlm_srcaddr(host
), datap
);
437 * nlmsvc_unlock_all_by_ip - release local locks by IP address
438 * @server_addr: server's IP address as seen by clients
440 * Release all locks held by clients accessing this host
441 * via the passed in IP address.
444 nlmsvc_unlock_all_by_ip(struct sockaddr
*server_addr
)
448 ret
= nlm_traverse_files(server_addr
, nlmsvc_match_ip
, NULL
);
449 return ret
? -EIO
: 0;
451 EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_ip
);