blob: 51855dfd8adb426f44f251b2e382cf493dc53081 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/include/linux/lockd/lockd.h
3 *
4 * General-purpose lockd include file.
5 *
6 * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
7 */
8
9#ifndef LINUX_LOCKD_LOCKD_H
10#define LINUX_LOCKD_LOCKD_H
11
12#ifdef __KERNEL__
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/in.h>
Chuck Lever781b61a2008-09-03 14:36:01 -040015#include <linux/in6.h>
16#include <net/ipv6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/fs.h>
Trond Myklebust6849c0c2006-03-20 13:44:39 -050018#include <linux/kref.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/utsname.h>
20#include <linux/nfsd/nfsfh.h>
21#include <linux/lockd/bind.h>
22#include <linux/lockd/xdr.h>
23#ifdef CONFIG_LOCKD_V4
24#include <linux/lockd/xdr4.h>
25#endif
26#include <linux/lockd/debug.h>
27
28/*
29 * Version string
30 */
31#define LOCKD_VERSION "0.5"
32
33/*
34 * Default timeout for RPC calls (seconds)
35 */
36#define LOCKD_DFLT_TIMEO 10
37
38/*
39 * Lockd host handle (used both by the client and server personality).
40 */
41struct nlm_host {
Olaf Kirch0cea3272006-10-04 02:15:56 -070042 struct hlist_node h_hash; /* doubly linked list */
Chuck Leverb4ed58f2008-09-03 14:35:39 -040043 struct sockaddr_storage h_addr; /* peer address */
44 size_t h_addrlen;
Chuck Lever90151e62008-09-03 14:35:46 -040045 struct sockaddr_storage h_srcaddr; /* our address (optional) */
Chuck Lever7538ce12008-12-04 14:19:45 -050046 struct rpc_clnt *h_rpcclnt; /* RPC client to talk to peer */
47 char *h_name; /* remote hostname */
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 u32 h_version; /* interface version */
49 unsigned short h_proto; /* transport proto */
50 unsigned short h_reclaiming : 1,
51 h_server : 1, /* server side, not client side */
Chuck Lever0cb26592008-12-23 15:21:38 -050052 h_noresvport : 1,
NeilBrown350fce82006-10-04 02:16:00 -070053 h_inuse : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 wait_queue_head_t h_gracewait; /* wait while reclaiming */
Trond Myklebust28df9552006-06-09 09:40:27 -040055 struct rw_semaphore h_rwsem; /* Reboot recovery lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 u32 h_state; /* pseudo-state counter */
57 u32 h_nsmstate; /* true remote NSM state */
58 u32 h_pidcount; /* Pseudopids */
59 atomic_t h_count; /* reference count */
Trond Myklebust50467912006-06-09 09:40:24 -040060 struct mutex h_mutex; /* mutex for pmap binding */
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 unsigned long h_nextrebind; /* next portmap call */
62 unsigned long h_expires; /* eligible for GC */
63 struct list_head h_lockowners; /* Lockowners for the client */
64 spinlock_t h_lock;
Christoph Hellwig26bcbf92006-03-20 13:44:40 -050065 struct list_head h_granted; /* Locks in GRANTED state */
66 struct list_head h_reclaim; /* Locks in RECLAIM state */
Chuck Lever7538ce12008-12-04 14:19:45 -050067 struct nsm_handle *h_nsmhandle; /* NSM status handle */
Chuck Lever1df40b62008-12-04 14:19:53 -050068 char *h_addrbuf; /* address eyecatcher */
Olaf Kirch8dead0d2006-10-04 02:15:53 -070069};
70
Chuck Leverbc995802008-12-04 14:20:08 -050071/*
72 * The largest string sm_addrbuf should hold is a full-size IPv6 address
73 * (no "::" anywhere) with a scope ID. The buffer size is computed to
74 * hold eight groups of colon-separated four-hex-digit numbers, a
75 * percent sign, a scope id (at most 32 bits, in decimal), and NUL.
76 */
77#define NSM_ADDRBUF ((8 * 4 + 7) + (1 + 10) + 1)
78
Olaf Kirch8dead0d2006-10-04 02:15:53 -070079struct nsm_handle {
80 struct list_head sm_link;
81 atomic_t sm_count;
Chuck Lever29ed1402008-12-04 14:20:46 -050082 char *sm_mon_name;
Chuck Leverf47534f2008-12-04 14:20:38 -050083 char *sm_name;
Chuck Lever7e9d77462008-09-03 14:35:54 -040084 struct sockaddr_storage sm_addr;
85 size_t sm_addrlen;
Olaf Kirch8dead0d2006-10-04 02:15:53 -070086 unsigned int sm_monitored : 1,
87 sm_sticky : 1; /* don't unmonitor */
Chuck Lever7e44d3b2008-12-05 19:03:16 -050088 struct nsm_private sm_priv;
Chuck Leverbc995802008-12-04 14:20:08 -050089 char sm_addrbuf[NSM_ADDRBUF];
Linus Torvalds1da177e2005-04-16 15:20:36 -070090};
91
92/*
Chuck Leverb4ed58f2008-09-03 14:35:39 -040093 * Rigorous type checking on sockaddr type conversions
94 */
95static inline struct sockaddr_in *nlm_addr_in(const struct nlm_host *host)
96{
97 return (struct sockaddr_in *)&host->h_addr;
98}
99
100static inline struct sockaddr *nlm_addr(const struct nlm_host *host)
101{
102 return (struct sockaddr *)&host->h_addr;
103}
104
Chuck Lever90151e62008-09-03 14:35:46 -0400105static inline struct sockaddr_in *nlm_srcaddr_in(const struct nlm_host *host)
106{
107 return (struct sockaddr_in *)&host->h_srcaddr;
108}
109
110static inline struct sockaddr *nlm_srcaddr(const struct nlm_host *host)
111{
112 return (struct sockaddr *)&host->h_srcaddr;
113}
114
Chuck Leverb4ed58f2008-09-03 14:35:39 -0400115/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 * Map an fl_owner_t into a unique 32-bit "pid"
117 */
118struct nlm_lockowner {
119 struct list_head list;
120 atomic_t count;
121
122 struct nlm_host *host;
123 fl_owner_t owner;
124 uint32_t pid;
125};
126
Trond Myklebustecdbf762005-06-22 17:16:31 +0000127struct nlm_wait;
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129/*
130 * Memory chunk for NLM client RPC request.
131 */
Chuck Lever511d2e82007-03-29 16:47:47 -0400132#define NLMCLNT_OHSIZE ((__NEW_UTS_LEN) + 10u)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133struct nlm_rqst {
Trond Myklebust5e7f37a2008-04-01 18:58:49 -0400134 atomic_t a_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 unsigned int a_flags; /* initial RPC task flags */
136 struct nlm_host * a_host; /* host handle */
137 struct nlm_args a_args; /* arguments */
138 struct nlm_res a_res; /* result */
Trond Myklebust92737232006-03-20 13:44:45 -0500139 struct nlm_block * a_block;
Trond Myklebustaaaa9942006-02-01 12:18:25 -0500140 unsigned int a_retries; /* Retry count */
Trond Myklebust92737232006-03-20 13:44:45 -0500141 u8 a_owner[NLMCLNT_OHSIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142};
143
144/*
145 * This struct describes a file held open by lockd on behalf of
146 * an NFS client.
147 */
148struct nlm_file {
Olaf Kirch07ba8062006-10-04 02:15:58 -0700149 struct hlist_node f_list; /* linked list */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 struct nfs_fh f_handle; /* NFS file handle */
151 struct file * f_file; /* VFS file pointer */
152 struct nlm_share * f_shares; /* DOS shares */
Olaf Kirch68a2d76c2006-10-04 02:15:57 -0700153 struct list_head f_blocks; /* blocked locks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 unsigned int f_locks; /* guesstimate # of locks */
155 unsigned int f_count; /* reference count */
Neil Brown89e63ef2006-10-04 02:16:06 -0700156 struct mutex f_mutex; /* avoid concurrent access */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157};
158
159/*
160 * This is a server block (i.e. a lock requested by some client which
161 * couldn't be granted because of a conflicting lock).
162 */
163#define NLM_NEVER (~(unsigned long) 0)
Marc Eshel2b36f412006-11-28 16:26:47 -0500164/* timeout on non-blocking call: */
165#define NLM_TIMEOUT (7 * HZ)
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167struct nlm_block {
Trond Myklebust6849c0c2006-03-20 13:44:39 -0500168 struct kref b_count; /* Reference count */
Olaf Kirch68a2d76c2006-10-04 02:15:57 -0700169 struct list_head b_list; /* linked list of all blocks */
170 struct list_head b_flist; /* linked list (per file) */
Trond Myklebust92737232006-03-20 13:44:45 -0500171 struct nlm_rqst * b_call; /* RPC args & callback info */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 struct svc_serv * b_daemon; /* NLM service */
173 struct nlm_host * b_host; /* host handle for RPC clnt */
174 unsigned long b_when; /* next re-xmit */
175 unsigned int b_id; /* block id */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 unsigned char b_granted; /* VFS granted lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 struct nlm_file * b_file; /* file in question */
Marc Eshel2b36f412006-11-28 16:26:47 -0500178 struct cache_req * b_cache_req; /* deferred request handling */
179 struct file_lock * b_fl; /* set for GETLK */
180 struct cache_deferred_req * b_deferred_req;
181 unsigned int b_flags; /* block flags */
182#define B_QUEUED 1 /* lock queued */
183#define B_GOT_CALLBACK 2 /* got lock or conflicting lock */
184#define B_TIMED_OUT 4 /* filesystem too slow to respond */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185};
186
187/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 * Global variables
189 */
190extern struct rpc_program nlm_program;
191extern struct svc_procedure nlmsvc_procedures[];
192#ifdef CONFIG_LOCKD_V4
193extern struct svc_procedure nlmsvc_procedures4[];
194#endif
195extern int nlmsvc_grace_period;
196extern unsigned long nlmsvc_timeout;
Olaf Kirchabd1f502006-10-04 02:16:01 -0700197extern int nsm_use_hostnames;
Chuck Levere6765b82008-12-11 17:56:14 -0500198extern int nsm_local_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
200/*
201 * Lockd client functions
202 */
Trond Myklebust92737232006-03-20 13:44:45 -0500203struct nlm_rqst * nlm_alloc_call(struct nlm_host *host);
204void nlm_release_call(struct nlm_rqst *);
205int nlm_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *);
Trond Myklebustd4716622006-03-20 13:44:45 -0500206int nlm_async_reply(struct nlm_rqst *, u32, const struct rpc_call_ops *);
Trond Myklebust3a649b82006-03-20 13:44:44 -0500207struct nlm_wait * nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl);
208void nlmclnt_finish_block(struct nlm_wait *block);
209int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout);
Chuck Leverdcff09f2008-10-03 12:50:36 -0400210__be32 nlmclnt_grant(const struct sockaddr *addr,
211 const struct nlm_lock *lock);
Olaf Kirch5c8dd292006-10-04 02:15:55 -0700212void nlmclnt_recovery(struct nlm_host *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213int nlmclnt_reclaim(struct nlm_host *, struct file_lock *);
Olaf Kirch031d8692006-10-04 02:16:02 -0700214void nlmclnt_next_cookie(struct nlm_cookie *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216/*
217 * Host cache
218 */
Chuck Leverd7d20442008-10-03 12:50:21 -0400219struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
220 const size_t salen,
221 const unsigned short protocol,
222 const u32 version,
Chuck Lever0cb26592008-12-23 15:21:38 -0500223 const char *hostname,
224 int noresvport);
Chuck Lever6bfbe8a2008-10-03 12:50:29 -0400225struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
226 const char *hostname,
227 const size_t hostname_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228struct rpc_clnt * nlm_bind_host(struct nlm_host *);
229void nlm_rebind_host(struct nlm_host *);
230struct nlm_host * nlm_get_host(struct nlm_host *);
231void nlm_release_host(struct nlm_host *);
232void nlm_shutdown_hosts(void);
Chuck Lever7fefc9c2008-12-05 19:03:31 -0500233void nlm_host_rebooted(const struct nlm_reboot *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Chuck Lever1e49323c2008-12-04 14:21:24 -0500235/*
236 * Host monitoring
237 */
238int nsm_monitor(const struct nlm_host *host);
Chuck Lever356c3eb2008-12-04 14:21:38 -0500239void nsm_unmonitor(const struct nlm_host *host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Chuck Lever92fd91b2008-12-05 19:04:01 -0500241struct nsm_handle *nsm_get_handle(const struct sockaddr *sap,
242 const size_t salen,
Chuck Lever67c6d102008-12-05 19:02:45 -0500243 const char *hostname,
Chuck Lever92fd91b2008-12-05 19:04:01 -0500244 const size_t hostname_len);
Chuck Lever3420a8c2008-12-05 19:03:46 -0500245struct nsm_handle *nsm_reboot_lookup(const struct nlm_reboot *info);
Chuck Lever67c6d102008-12-05 19:02:45 -0500246void nsm_release(struct nsm_handle *nsm);
247
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248/*
Olaf Kirchf2af7932006-10-04 02:15:59 -0700249 * This is used in garbage collection and resource reclaim
250 * A return value != 0 means destroy the lock/block/share
251 */
Wendy Cheng4373ea82008-01-17 11:10:12 -0500252typedef int (*nlm_host_match_fn_t)(void *cur, struct nlm_host *ref);
Olaf Kirchf2af7932006-10-04 02:15:59 -0700253
254/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 * Server-side lock handling
256 */
Al Viro52921e02006-10-19 23:28:46 -0700257__be32 nlmsvc_lock(struct svc_rqst *, struct nlm_file *,
Jeff Layton6cde4de2008-07-15 14:26:17 -0400258 struct nlm_host *, struct nlm_lock *, int,
J. Bruce Fieldsb2b50282008-02-06 13:59:23 -0500259 struct nlm_cookie *, int);
Al Viro52921e02006-10-19 23:28:46 -0700260__be32 nlmsvc_unlock(struct nlm_file *, struct nlm_lock *);
Marc Eshel85f3f1b32006-11-28 16:27:06 -0500261__be32 nlmsvc_testlock(struct svc_rqst *, struct nlm_file *,
Jeff Layton8f920d52008-07-15 14:06:48 -0400262 struct nlm_host *, struct nlm_lock *,
263 struct nlm_lock *, struct nlm_cookie *);
Al Viro52921e02006-10-19 23:28:46 -0700264__be32 nlmsvc_cancel_blocked(struct nlm_file *, struct nlm_lock *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265unsigned long nlmsvc_retry_blocked(void);
J. Bruce Fieldsf3ee439f2006-03-20 23:24:13 -0500266void nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *,
Olaf Kirchf2af7932006-10-04 02:15:59 -0700267 nlm_host_match_fn_t match);
Al Viroe8c5c042006-12-13 00:35:03 -0800268void nlmsvc_grant_reply(struct nlm_cookie *, __be32);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270/*
271 * File handling for the server personality
272 */
Al Viro52921e02006-10-19 23:28:46 -0700273__be32 nlm_lookup_file(struct svc_rqst *, struct nlm_file **,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 struct nfs_fh *);
275void nlm_release_file(struct nlm_file *);
276void nlmsvc_mark_resources(void);
277void nlmsvc_free_host_resources(struct nlm_host *);
278void nlmsvc_invalidate_all(void);
279
Wendy Cheng4373ea82008-01-17 11:10:12 -0500280/*
281 * Cluster failover support
282 */
Wendy Cheng17efa372008-01-17 11:10:12 -0500283int nlmsvc_unlock_all_by_sb(struct super_block *sb);
Chuck Lever367c8c72008-06-30 18:58:14 -0400284int nlmsvc_unlock_all_by_ip(struct sockaddr *server_addr);
Wendy Cheng4373ea82008-01-17 11:10:12 -0500285
Chuck Leverf34ec992008-03-14 14:18:45 -0400286static inline struct inode *nlmsvc_file_inode(struct nlm_file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
Josef Sipek225a7192006-12-08 02:37:18 -0800288 return file->f_file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289}
290
Chuck Leverb85e4672008-10-03 12:50:44 -0400291static inline int __nlm_privileged_request4(const struct sockaddr *sap)
292{
293 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
Chuck Lever57ef6922008-12-11 17:56:52 -0500294
295 if (ntohs(sin->sin_port) > 1023)
296 return 0;
297
298 return ipv4_is_loopback(sin->sin_addr.s_addr);
Chuck Leverb85e4672008-10-03 12:50:44 -0400299}
300
301#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
302static inline int __nlm_privileged_request6(const struct sockaddr *sap)
303{
304 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
Chuck Leverd1208f72008-12-11 17:56:44 -0500305
306 if (ntohs(sin6->sin6_port) > 1023)
307 return 0;
308
309 if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_MAPPED)
310 return ipv4_is_loopback(sin6->sin6_addr.s6_addr32[3]);
311
312 return ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LOOPBACK;
Chuck Leverb85e4672008-10-03 12:50:44 -0400313}
314#else /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
315static inline int __nlm_privileged_request6(const struct sockaddr *sap)
316{
317 return 0;
318}
319#endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
320
321/*
322 * Ensure incoming requests are from local privileged callers.
323 *
324 * Return TRUE if sender is local and is connecting via a privileged port;
325 * otherwise return FALSE.
326 */
327static inline int nlm_privileged_requester(const struct svc_rqst *rqstp)
328{
329 const struct sockaddr *sap = svc_addr(rqstp);
330
331 switch (sap->sa_family) {
332 case AF_INET:
333 return __nlm_privileged_request4(sap);
334 case AF_INET6:
335 return __nlm_privileged_request6(sap);
336 default:
337 return 0;
338 }
339}
340
Chuck Lever781b61a2008-09-03 14:36:01 -0400341static inline int __nlm_cmp_addr4(const struct sockaddr *sap1,
342 const struct sockaddr *sap2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
Chuck Lever781b61a2008-09-03 14:36:01 -0400344 const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sap1;
345 const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sap2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr;
347}
348
Chuck Lever78851e12009-03-10 20:33:19 -0400349#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Chuck Lever781b61a2008-09-03 14:36:01 -0400350static inline int __nlm_cmp_addr6(const struct sockaddr *sap1,
351 const struct sockaddr *sap2)
352{
353 const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sap1;
354 const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sap2;
355 return ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr);
356}
Chuck Lever78851e12009-03-10 20:33:19 -0400357#else /* !(CONFIG_IPV6 || CONFIG_IPV6_MODULE) */
358static inline int __nlm_cmp_addr6(const struct sockaddr *sap1,
359 const struct sockaddr *sap2)
360{
361 return 0;
362}
363#endif /* !(CONFIG_IPV6 || CONFIG_IPV6_MODULE) */
Chuck Lever781b61a2008-09-03 14:36:01 -0400364
365/*
366 * Compare two host addresses
367 *
368 * Return TRUE if the addresses are the same; otherwise FALSE.
369 */
370static inline int nlm_cmp_addr(const struct sockaddr *sap1,
371 const struct sockaddr *sap2)
372{
373 if (sap1->sa_family == sap2->sa_family) {
374 switch (sap1->sa_family) {
375 case AF_INET:
376 return __nlm_cmp_addr4(sap1, sap2);
377 case AF_INET6:
378 return __nlm_cmp_addr6(sap1, sap2);
379 }
380 }
381 return 0;
382}
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384/*
385 * Compare two NLM locks.
386 * When the second lock is of type F_UNLCK, this acts like a wildcard.
387 */
Chuck Leverf34ec992008-03-14 14:18:45 -0400388static inline int nlm_compare_locks(const struct file_lock *fl1,
389 const struct file_lock *fl2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390{
391 return fl1->fl_pid == fl2->fl_pid
Marc Eshel3134cbe2006-06-09 09:40:20 -0400392 && fl1->fl_owner == fl2->fl_owner
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 && fl1->fl_start == fl2->fl_start
394 && fl1->fl_end == fl2->fl_end
395 &&(fl1->fl_type == fl2->fl_type || fl2->fl_type == F_UNLCK);
396}
397
398extern struct lock_manager_operations nlmsvc_lock_operations;
399
400#endif /* __KERNEL__ */
401
402#endif /* LINUX_LOCKD_LOCKD_H */