blob: dc5c75930f0fea94145c9556f2aab6dbc8ea91a3 [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090013#include <linux/slab.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080014#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/sunrpc/svc.h>
Jeff Layton59766872013-02-04 12:50:00 -050016#include <linux/sunrpc/addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/nfsd/nfsfh.h>
18#include <linux/nfsd/export.h>
19#include <linux/lockd/lockd.h>
20#include <linux/lockd/share.h>
Wendy Cheng4373ea82008-01-17 11:10:12 -050021#include <linux/module.h>
22#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24#define NLMDBG_FACILITY NLMDBG_SVCSUBS
25
26
27/*
28 * Global file hash table
29 */
Olaf Kirch07ba8062006-10-04 02:15:58 -070030#define FILE_HASH_BITS 7
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#define FILE_NRHASH (1<<FILE_HASH_BITS)
Olaf Kirch07ba8062006-10-04 02:15:58 -070032static struct hlist_head nlm_files[FILE_NRHASH];
Ingo Molnar353ab6e2006-03-26 01:37:12 -080033static DEFINE_MUTEX(nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Chuck Lever0bbacc42005-11-01 16:53:32 -050035#ifdef NFSD_DEBUG
36static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
37{
38 u32 *fhp = (u32*)f->data;
39
40 /* print the first 32 bytes of the fh */
41 dprintk("lockd: %s (%08x %08x %08x %08x %08x %08x %08x %08x)\n",
42 msg, fhp[0], fhp[1], fhp[2], fhp[3],
43 fhp[4], fhp[5], fhp[6], fhp[7]);
44}
45
46static inline void nlm_debug_print_file(char *msg, struct nlm_file *file)
47{
Al Viro496ad9a2013-01-23 17:07:38 -050048 struct inode *inode = file_inode(file->f_file);
Chuck Lever0bbacc42005-11-01 16:53:32 -050049
50 dprintk("lockd: %s %s/%ld\n",
51 msg, inode->i_sb->s_id, inode->i_ino);
52}
53#else
54static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
55{
56 return;
57}
58
59static inline void nlm_debug_print_file(char *msg, struct nlm_file *file)
60{
61 return;
62}
63#endif
64
Linus Torvalds1da177e2005-04-16 15:20:36 -070065static inline unsigned int file_hash(struct nfs_fh *f)
66{
67 unsigned int tmp=0;
68 int i;
69 for (i=0; i<NFS2_FHSIZE;i++)
70 tmp += f->data[i];
71 return tmp & (FILE_NRHASH - 1);
72}
73
74/*
75 * Lookup file info. If it doesn't exist, create a file info struct
76 * and open a (VFS) file for the given inode.
77 *
78 * FIXME:
79 * Note that we open the file O_RDONLY even when creating write locks.
80 * This is not quite right, but for now, we assume the client performs
81 * the proper R/W checking.
82 */
Al Viro52921e02006-10-19 23:28:46 -070083__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -070084nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result,
85 struct nfs_fh *f)
86{
87 struct nlm_file *file;
88 unsigned int hash;
Al Viro52921e02006-10-19 23:28:46 -070089 __be32 nfserr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
J. Bruce Fields50431d92007-08-31 17:09:33 -040091 nlm_debug_print_fh("nlm_lookup_file", f);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
93 hash = file_hash(f);
94
95 /* Lock file table */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080096 mutex_lock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Sasha Levinb67bfe02013-02-27 17:06:00 -080098 hlist_for_each_entry(file, &nlm_files[hash], f_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 if (!nfs_compare_fh(&file->f_handle, f))
100 goto found;
101
Chuck Lever0bbacc42005-11-01 16:53:32 -0500102 nlm_debug_print_fh("creating file for", f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104 nfserr = nlm_lck_denied_nolocks;
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -0700105 file = kzalloc(sizeof(*file), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 if (!file)
107 goto out_unlock;
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 memcpy(&file->f_handle, f, sizeof(struct nfs_fh));
Neil Brown89e63ef2006-10-04 02:16:06 -0700110 mutex_init(&file->f_mutex);
Olaf Kirch07ba8062006-10-04 02:15:58 -0700111 INIT_HLIST_NODE(&file->f_list);
Olaf Kirch68a2d76c2006-10-04 02:15:57 -0700112 INIT_LIST_HEAD(&file->f_blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
114 /* Open the file. Note that this must not sleep for too long, else
115 * we would lock up lockd:-) So no NFS re-exports, folks.
116 *
117 * We have to make sure we have the right credential to open
118 * the file.
119 */
120 if ((nfserr = nlmsvc_ops->fopen(rqstp, f, &file->f_file)) != 0) {
Olaf Kirchf0737a32006-10-04 02:15:54 -0700121 dprintk("lockd: open failed (error %d)\n", nfserr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 goto out_free;
123 }
124
Olaf Kirch07ba8062006-10-04 02:15:58 -0700125 hlist_add_head(&file->f_list, &nlm_files[hash]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
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:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800134 mutex_unlock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 return nfserr;
136
137out_free:
138 kfree(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 goto out_unlock;
140}
141
142/*
143 * Delete a file after having released all locks, blocks and shares
144 */
145static inline void
146nlm_delete_file(struct nlm_file *file)
147{
Chuck Lever0bbacc42005-11-01 16:53:32 -0500148 nlm_debug_print_file("closing file", file);
Olaf Kirch07ba8062006-10-04 02:15:58 -0700149 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156}
157
158/*
159 * Loop over all locks on the given file and perform the specified
160 * action.
161 */
162static int
Olaf Kirchf2af7932006-10-04 02:15:59 -0700163nlm_traverse_locks(struct nlm_host *host, struct nlm_file *file,
164 nlm_host_match_fn_t match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165{
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;
Jeff Layton1c8c6012013-06-21 08:58:15 -0400172 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 for (fl = inode->i_flock; fl; fl = fl->fl_next) {
J. Bruce Fields7117bf32006-03-20 13:44:26 -0500174 if (fl->fl_lmops != &nlmsvc_lock_operations)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 continue;
176
177 /* update current lock count */
178 file->f_locks++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
Olaf Kirchf2af7932006-10-04 02:15:59 -0700180 lockhost = (struct nlm_host *) fl->fl_owner;
181 if (match(lockhost, host)) {
182 struct file_lock lock = *fl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Jeff Layton1c8c6012013-06-21 08:58:15 -0400184 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 lock.fl_type = F_UNLCK;
186 lock.fl_start = 0;
187 lock.fl_end = OFFSET_MAX;
Marc Eshel1a8322b2006-11-28 16:27:06 -0500188 if (vfs_lock_file(file->f_file, F_SETLK, &lock, NULL) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 printk("lockd: unlock failure in %s:%d\n",
190 __FILE__, __LINE__);
191 return 1;
192 }
193 goto again;
194 }
195 }
Jeff Layton1c8c6012013-06-21 08:58:15 -0400196 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198 return 0;
199}
200
Wendy Cheng17efa372008-01-17 11:10:12 -0500201static int
202nlmsvc_always_match(void *dummy1, struct nlm_host *dummy2)
203{
204 return 1;
205}
206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207/*
Olaf Kirchf2af7932006-10-04 02:15:59 -0700208 * Inspect a single file
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 */
210static inline int
Olaf Kirchf2af7932006-10-04 02:15:59 -0700211nlm_inspect_file(struct nlm_host *host, struct nlm_file *file, nlm_host_match_fn_t match)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
Olaf Kirchf2af7932006-10-04 02:15:59 -0700213 nlmsvc_traverse_blocks(host, file, match);
214 nlmsvc_traverse_shares(host, file, match);
215 return nlm_traverse_locks(host, file, match);
216}
217
218/*
219 * Quick check whether there are still any locks, blocks or
220 * shares on a given file.
221 */
222static inline int
223nlm_file_inuse(struct nlm_file *file)
224{
225 struct inode *inode = nlmsvc_file_inode(file);
226 struct file_lock *fl;
227
228 if (file->f_count || !list_empty(&file->f_blocks) || file->f_shares)
229 return 1;
230
Jeff Layton1c8c6012013-06-21 08:58:15 -0400231 spin_lock(&inode->i_lock);
Olaf Kirchf2af7932006-10-04 02:15:59 -0700232 for (fl = inode->i_flock; fl; fl = fl->fl_next) {
Arnd Bergmann763641d2010-10-26 22:55:40 +0200233 if (fl->fl_lmops == &nlmsvc_lock_operations) {
Jeff Layton1c8c6012013-06-21 08:58:15 -0400234 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 return 1;
Arnd Bergmann763641d2010-10-26 22:55:40 +0200236 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 }
Jeff Layton1c8c6012013-06-21 08:58:15 -0400238 spin_unlock(&inode->i_lock);
Olaf Kirchf2af7932006-10-04 02:15:59 -0700239 file->f_locks = 0;
240 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241}
242
243/*
244 * Loop over all files in the file table.
245 */
246static int
Wendy Cheng17efa372008-01-17 11:10:12 -0500247nlm_traverse_files(void *data, nlm_host_match_fn_t match,
248 int (*is_failover_file)(void *data, struct nlm_file *file))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
Sasha Levinb67bfe02013-02-27 17:06:00 -0800250 struct hlist_node *next;
Olaf Kirch07ba8062006-10-04 02:15:58 -0700251 struct nlm_file *file;
Trond Myklebust01df9c52006-08-10 11:58:57 -0400252 int i, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800254 mutex_lock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 for (i = 0; i < FILE_NRHASH; i++) {
Sasha Levinb67bfe02013-02-27 17:06:00 -0800256 hlist_for_each_entry_safe(file, next, &nlm_files[i], f_list) {
Wendy Cheng17efa372008-01-17 11:10:12 -0500257 if (is_failover_file && !is_failover_file(data, file))
258 continue;
Trond Myklebust01df9c52006-08-10 11:58:57 -0400259 file->f_count++;
260 mutex_unlock(&nlm_file_mutex);
261
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 /* Traverse locks, blocks and shares of this file
263 * and update file->f_locks count */
Wendy Cheng4373ea82008-01-17 11:10:12 -0500264 if (nlm_inspect_file(data, file, match))
Trond Myklebust01df9c52006-08-10 11:58:57 -0400265 ret = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
Trond Myklebust01df9c52006-08-10 11:58:57 -0400267 mutex_lock(&nlm_file_mutex);
268 file->f_count--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 /* No more references to this file. Let go of it. */
Olaf Kirch68a2d76c2006-10-04 02:15:57 -0700270 if (list_empty(&file->f_blocks) && !file->f_locks
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 && !file->f_shares && !file->f_count) {
Olaf Kirch07ba8062006-10-04 02:15:58 -0700272 hlist_del(&file->f_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 nlmsvc_ops->fclose(file->f_file);
274 kfree(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 }
276 }
277 }
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800278 mutex_unlock(&nlm_file_mutex);
Trond Myklebust01df9c52006-08-10 11:58:57 -0400279 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280}
281
282/*
283 * Release file. If there are no more remote locks on this file,
284 * close it and free the handle.
285 *
286 * Note that we can't do proper reference counting without major
287 * contortions because the code in fs/locks.c creates, deletes and
288 * splits locks without notification. Our only way is to walk the
289 * entire lock list each time we remove a lock.
290 */
291void
292nlm_release_file(struct nlm_file *file)
293{
294 dprintk("lockd: nlm_release_file(%p, ct = %d)\n",
295 file, file->f_count);
296
297 /* Lock file table */
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800298 mutex_lock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 /* If there are no more locks etc, delete the file */
Olaf Kirchf2af7932006-10-04 02:15:59 -0700301 if (--file->f_count == 0 && !nlm_file_inuse(file))
302 nlm_delete_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800304 mutex_unlock(&nlm_file_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305}
306
307/*
Olaf Kirchf2af7932006-10-04 02:15:59 -0700308 * Helpers function for resource traversal
309 *
310 * nlmsvc_mark_host:
Stanislav Kinsburskyb26411f2012-07-25 16:55:54 +0400311 * used by the garbage collector; simply sets h_inuse only for those
312 * hosts, which passed network check.
Olaf Kirchf2af7932006-10-04 02:15:59 -0700313 * Always returns 0.
314 *
315 * nlmsvc_same_host:
316 * returns 1 iff the two hosts match. Used to release
317 * all resources bound to a specific host.
318 *
319 * nlmsvc_is_client:
320 * returns 1 iff the host is a client.
321 * Used by nlmsvc_invalidate_all
322 */
Stanislav Kinsburskyb26411f2012-07-25 16:55:54 +0400323
Olaf Kirchf2af7932006-10-04 02:15:59 -0700324static int
Stanislav Kinsburskyb26411f2012-07-25 16:55:54 +0400325nlmsvc_mark_host(void *data, struct nlm_host *hint)
Olaf Kirchf2af7932006-10-04 02:15:59 -0700326{
Wendy Cheng4373ea82008-01-17 11:10:12 -0500327 struct nlm_host *host = data;
328
Stanislav Kinsburskyb26411f2012-07-25 16:55:54 +0400329 if ((hint->net == NULL) ||
330 (host->net == hint->net))
331 host->h_inuse = 1;
Olaf Kirchf2af7932006-10-04 02:15:59 -0700332 return 0;
333}
334
335static int
Wendy Cheng4373ea82008-01-17 11:10:12 -0500336nlmsvc_same_host(void *data, struct nlm_host *other)
Olaf Kirchf2af7932006-10-04 02:15:59 -0700337{
Wendy Cheng4373ea82008-01-17 11:10:12 -0500338 struct nlm_host *host = data;
339
Olaf Kirchf2af7932006-10-04 02:15:59 -0700340 return host == other;
341}
342
343static int
Wendy Cheng4373ea82008-01-17 11:10:12 -0500344nlmsvc_is_client(void *data, struct nlm_host *dummy)
Olaf Kirchf2af7932006-10-04 02:15:59 -0700345{
Wendy Cheng4373ea82008-01-17 11:10:12 -0500346 struct nlm_host *host = data;
347
NeilBrown4481d102006-10-17 00:10:17 -0700348 if (host->h_server) {
349 /* we are destroying locks even though the client
350 * hasn't asked us too, so don't unmonitor the
351 * client
352 */
353 if (host->h_nsmhandle)
354 host->h_nsmhandle->sm_sticky = 1;
355 return 1;
356 } else
357 return 0;
Olaf Kirchf2af7932006-10-04 02:15:59 -0700358}
359
360/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 * Mark all hosts that still hold resources
362 */
363void
Stanislav Kinsburskyb26411f2012-07-25 16:55:54 +0400364nlmsvc_mark_resources(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
Stanislav Kinsburskyb26411f2012-07-25 16:55:54 +0400366 struct nlm_host hint;
367
368 dprintk("lockd: nlmsvc_mark_resources for net %p\n", net);
369 hint.net = net;
370 nlm_traverse_files(&hint, nlmsvc_mark_host, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372
373/*
374 * Release all resources held by the given client
375 */
376void
377nlmsvc_free_host_resources(struct nlm_host *host)
378{
379 dprintk("lockd: nlmsvc_free_host_resources\n");
380
Wendy Cheng17efa372008-01-17 11:10:12 -0500381 if (nlm_traverse_files(host, nlmsvc_same_host, NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 printk(KERN_WARNING
Olaf Kirchf0737a32006-10-04 02:15:54 -0700383 "lockd: couldn't remove all locks held by %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 host->h_name);
Olaf Kirchf0737a32006-10-04 02:15:54 -0700385 BUG();
386 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387}
388
Chuck Lever367c8c72008-06-30 18:58:14 -0400389/**
390 * nlmsvc_invalidate_all - remove all locks held for clients
391 *
392 * Release all locks held by NFS clients.
393 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 */
395void
396nlmsvc_invalidate_all(void)
397{
Chuck Lever367c8c72008-06-30 18:58:14 -0400398 /*
Olaf Kirchf2af7932006-10-04 02:15:59 -0700399 * Previously, the code would call
400 * nlmsvc_free_host_resources for each client in
401 * turn, which is about as inefficient as it gets.
402 * Now we just do it once in nlm_traverse_files.
403 */
Wendy Cheng17efa372008-01-17 11:10:12 -0500404 nlm_traverse_files(NULL, nlmsvc_is_client, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405}
Wendy Cheng4373ea82008-01-17 11:10:12 -0500406
407static int
Wendy Cheng17efa372008-01-17 11:10:12 -0500408nlmsvc_match_sb(void *datap, struct nlm_file *file)
409{
410 struct super_block *sb = datap;
411
Al Virod8c95842011-12-07 18:16:57 -0500412 return sb == file->f_file->f_path.dentry->d_sb;
Wendy Cheng17efa372008-01-17 11:10:12 -0500413}
414
Chuck Lever367c8c72008-06-30 18:58:14 -0400415/**
416 * nlmsvc_unlock_all_by_sb - release locks held on this file system
417 * @sb: super block
418 *
419 * Release all locks held by clients accessing this file system.
420 */
Wendy Cheng17efa372008-01-17 11:10:12 -0500421int
422nlmsvc_unlock_all_by_sb(struct super_block *sb)
423{
424 int ret;
425
426 ret = nlm_traverse_files(sb, nlmsvc_always_match, nlmsvc_match_sb);
427 return ret ? -EIO : 0;
428}
429EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_sb);
430
431static int
Wendy Cheng4373ea82008-01-17 11:10:12 -0500432nlmsvc_match_ip(void *datap, struct nlm_host *host)
433{
Jeff Layton4516fc02009-08-14 12:57:54 -0400434 return rpc_cmp_addr(nlm_srcaddr(host), datap);
Wendy Cheng4373ea82008-01-17 11:10:12 -0500435}
436
Chuck Lever367c8c72008-06-30 18:58:14 -0400437/**
438 * nlmsvc_unlock_all_by_ip - release local locks by IP address
439 * @server_addr: server's IP address as seen by clients
440 *
441 * Release all locks held by clients accessing this host
442 * via the passed in IP address.
443 */
Wendy Cheng4373ea82008-01-17 11:10:12 -0500444int
Chuck Lever367c8c72008-06-30 18:58:14 -0400445nlmsvc_unlock_all_by_ip(struct sockaddr *server_addr)
Wendy Cheng4373ea82008-01-17 11:10:12 -0500446{
447 int ret;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500448
Chuck Lever367c8c72008-06-30 18:58:14 -0400449 ret = nlm_traverse_files(server_addr, nlmsvc_match_ip, NULL);
450 return ret ? -EIO : 0;
Wendy Cheng4373ea82008-01-17 11:10:12 -0500451}
452EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_ip);