2 * linux/include/linux/lockd/lockd.h
4 * General-purpose lockd include file.
6 * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
9 #ifndef LINUX_LOCKD_LOCKD_H
10 #define LINUX_LOCKD_LOCKD_H
15 #include <linux/in6.h>
18 #include <linux/kref.h>
19 #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>
26 #include <linux/lockd/debug.h>
31 #define LOCKD_VERSION "0.5"
34 * Default timeout for RPC calls (seconds)
36 #define LOCKD_DFLT_TIMEO 10
39 * Lockd host handle (used both by the client and server personality).
42 struct hlist_node h_hash
; /* doubly linked list */
43 struct sockaddr_storage h_addr
; /* peer address */
45 struct sockaddr_storage h_srcaddr
; /* our address (optional) */
46 struct rpc_clnt
* h_rpcclnt
; /* RPC client to talk to peer */
47 char * h_name
; /* remote hostname */
48 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 */
53 wait_queue_head_t h_gracewait
; /* wait while reclaiming */
54 struct rw_semaphore h_rwsem
; /* Reboot recovery lock */
55 u32 h_state
; /* pseudo-state counter */
56 u32 h_nsmstate
; /* true remote NSM state */
57 u32 h_pidcount
; /* Pseudopids */
58 atomic_t h_count
; /* reference count */
59 struct mutex h_mutex
; /* mutex for pmap binding */
60 unsigned long h_nextrebind
; /* next portmap call */
61 unsigned long h_expires
; /* eligible for GC */
62 struct list_head h_lockowners
; /* Lockowners for the client */
64 struct list_head h_granted
; /* Locks in GRANTED state */
65 struct list_head h_reclaim
; /* Locks in RECLAIM state */
66 struct nsm_handle
* h_nsmhandle
; /* NSM status handle */
68 char h_addrbuf
[48], /* address eyecatchers */
73 struct list_head sm_link
;
76 struct sockaddr_storage sm_addr
;
78 unsigned int sm_monitored
: 1,
79 sm_sticky
: 1; /* don't unmonitor */
80 char sm_addrbuf
[48]; /* address eyecatcher */
84 * Rigorous type checking on sockaddr type conversions
86 static inline struct sockaddr_in
*nlm_addr_in(const struct nlm_host
*host
)
88 return (struct sockaddr_in
*)&host
->h_addr
;
91 static inline struct sockaddr
*nlm_addr(const struct nlm_host
*host
)
93 return (struct sockaddr
*)&host
->h_addr
;
96 static inline struct sockaddr_in
*nlm_srcaddr_in(const struct nlm_host
*host
)
98 return (struct sockaddr_in
*)&host
->h_srcaddr
;
101 static inline struct sockaddr
*nlm_srcaddr(const struct nlm_host
*host
)
103 return (struct sockaddr
*)&host
->h_srcaddr
;
106 static inline struct sockaddr_in
*nsm_addr_in(const struct nsm_handle
*handle
)
108 return (struct sockaddr_in
*)&handle
->sm_addr
;
111 static inline struct sockaddr
*nsm_addr(const struct nsm_handle
*handle
)
113 return (struct sockaddr
*)&handle
->sm_addr
;
117 * Map an fl_owner_t into a unique 32-bit "pid"
119 struct nlm_lockowner
{
120 struct list_head list
;
123 struct nlm_host
*host
;
131 * Memory chunk for NLM client RPC request.
133 #define NLMCLNT_OHSIZE ((__NEW_UTS_LEN) + 10u)
136 unsigned int a_flags
; /* initial RPC task flags */
137 struct nlm_host
* a_host
; /* host handle */
138 struct nlm_args a_args
; /* arguments */
139 struct nlm_res a_res
; /* result */
140 struct nlm_block
* a_block
;
141 unsigned int a_retries
; /* Retry count */
142 u8 a_owner
[NLMCLNT_OHSIZE
];
146 * This struct describes a file held open by lockd on behalf of
150 struct hlist_node f_list
; /* linked list */
151 struct nfs_fh f_handle
; /* NFS file handle */
152 struct file
* f_file
; /* VFS file pointer */
153 struct nlm_share
* f_shares
; /* DOS shares */
154 struct list_head f_blocks
; /* blocked locks */
155 unsigned int f_locks
; /* guesstimate # of locks */
156 unsigned int f_count
; /* reference count */
157 struct mutex f_mutex
; /* avoid concurrent access */
161 * This is a server block (i.e. a lock requested by some client which
162 * couldn't be granted because of a conflicting lock).
164 #define NLM_NEVER (~(unsigned long) 0)
165 /* timeout on non-blocking call: */
166 #define NLM_TIMEOUT (7 * HZ)
169 struct kref b_count
; /* Reference count */
170 struct list_head b_list
; /* linked list of all blocks */
171 struct list_head b_flist
; /* linked list (per file) */
172 struct nlm_rqst
* b_call
; /* RPC args & callback info */
173 struct svc_serv
* b_daemon
; /* NLM service */
174 struct nlm_host
* b_host
; /* host handle for RPC clnt */
175 unsigned long b_when
; /* next re-xmit */
176 unsigned int b_id
; /* block id */
177 unsigned char b_granted
; /* VFS granted lock */
178 struct nlm_file
* b_file
; /* file in question */
179 struct cache_req
* b_cache_req
; /* deferred request handling */
180 struct file_lock
* b_fl
; /* set for GETLK */
181 struct cache_deferred_req
* b_deferred_req
;
182 unsigned int b_flags
; /* block flags */
183 #define B_QUEUED 1 /* lock queued */
184 #define B_GOT_CALLBACK 2 /* got lock or conflicting lock */
185 #define B_TIMED_OUT 4 /* filesystem too slow to respond */
191 extern struct rpc_program nlm_program
;
192 extern struct svc_procedure nlmsvc_procedures
[];
193 #ifdef CONFIG_LOCKD_V4
194 extern struct svc_procedure nlmsvc_procedures4
[];
196 extern int nlmsvc_grace_period
;
197 extern unsigned long nlmsvc_timeout
;
198 extern int nsm_use_hostnames
;
201 * Lockd client functions
203 struct nlm_rqst
* nlm_alloc_call(struct nlm_host
*host
);
204 void nlm_release_call(struct nlm_rqst
*);
205 int nlm_async_call(struct nlm_rqst
*, u32
, const struct rpc_call_ops
*);
206 int nlm_async_reply(struct nlm_rqst
*, u32
, const struct rpc_call_ops
*);
207 struct nlm_wait
* nlmclnt_prepare_block(struct nlm_host
*host
, struct file_lock
*fl
);
208 void nlmclnt_finish_block(struct nlm_wait
*block
);
209 int nlmclnt_block(struct nlm_wait
*block
, struct nlm_rqst
*req
, long timeout
);
210 __be32
nlmclnt_grant(const struct sockaddr
*addr
,
211 const struct nlm_lock
*lock
);
212 void nlmclnt_recovery(struct nlm_host
*);
213 int nlmclnt_reclaim(struct nlm_host
*, struct file_lock
*);
214 void nlmclnt_next_cookie(struct nlm_cookie
*);
219 struct nlm_host
*nlmclnt_lookup_host(const struct sockaddr
*sap
,
221 const unsigned short protocol
,
223 const char *hostname
);
224 struct nlm_host
*nlmsvc_lookup_host(const struct svc_rqst
*rqstp
,
225 const char *hostname
,
226 const size_t hostname_len
);
227 struct rpc_clnt
* nlm_bind_host(struct nlm_host
*);
228 void nlm_rebind_host(struct nlm_host
*);
229 struct nlm_host
* nlm_get_host(struct nlm_host
*);
230 void nlm_release_host(struct nlm_host
*);
231 void nlm_shutdown_hosts(void);
232 extern void nlm_host_rebooted(const struct sockaddr_in
*, const char *,
234 void nsm_release(struct nsm_handle
*);
238 * This is used in garbage collection and resource reclaim
239 * A return value != 0 means destroy the lock/block/share
241 typedef int (*nlm_host_match_fn_t
)(void *cur
, struct nlm_host
*ref
);
244 * Server-side lock handling
246 __be32
nlmsvc_lock(struct svc_rqst
*, struct nlm_file
*,
247 struct nlm_host
*, struct nlm_lock
*, int,
248 struct nlm_cookie
*, int);
249 __be32
nlmsvc_unlock(struct nlm_file
*, struct nlm_lock
*);
250 __be32
nlmsvc_testlock(struct svc_rqst
*, struct nlm_file
*,
251 struct nlm_host
*, struct nlm_lock
*,
252 struct nlm_lock
*, struct nlm_cookie
*);
253 __be32
nlmsvc_cancel_blocked(struct nlm_file
*, struct nlm_lock
*);
254 unsigned long nlmsvc_retry_blocked(void);
255 void nlmsvc_traverse_blocks(struct nlm_host
*, struct nlm_file
*,
256 nlm_host_match_fn_t match
);
257 void nlmsvc_grant_reply(struct nlm_cookie
*, __be32
);
260 * File handling for the server personality
262 __be32
nlm_lookup_file(struct svc_rqst
*, struct nlm_file
**,
264 void nlm_release_file(struct nlm_file
*);
265 void nlmsvc_mark_resources(void);
266 void nlmsvc_free_host_resources(struct nlm_host
*);
267 void nlmsvc_invalidate_all(void);
270 * Cluster failover support
272 int nlmsvc_unlock_all_by_sb(struct super_block
*sb
);
273 int nlmsvc_unlock_all_by_ip(struct sockaddr
*server_addr
);
275 static inline struct inode
*nlmsvc_file_inode(struct nlm_file
*file
)
277 return file
->f_file
->f_path
.dentry
->d_inode
;
280 static inline int __nlm_privileged_request4(const struct sockaddr
*sap
)
282 const struct sockaddr_in
*sin
= (struct sockaddr_in
*)sap
;
283 return (sin
->sin_addr
.s_addr
== htonl(INADDR_LOOPBACK
)) &&
284 (ntohs(sin
->sin_port
) < 1024);
287 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
288 static inline int __nlm_privileged_request6(const struct sockaddr
*sap
)
290 const struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)sap
;
291 return (ipv6_addr_type(&sin6
->sin6_addr
) & IPV6_ADDR_LOOPBACK
) &&
292 (ntohs(sin6
->sin6_port
) < 1024);
294 #else /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
295 static inline int __nlm_privileged_request6(const struct sockaddr
*sap
)
299 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
302 * Ensure incoming requests are from local privileged callers.
304 * Return TRUE if sender is local and is connecting via a privileged port;
305 * otherwise return FALSE.
307 static inline int nlm_privileged_requester(const struct svc_rqst
*rqstp
)
309 const struct sockaddr
*sap
= svc_addr(rqstp
);
311 switch (sap
->sa_family
) {
313 return __nlm_privileged_request4(sap
);
315 return __nlm_privileged_request6(sap
);
321 static inline int __nlm_cmp_addr4(const struct sockaddr
*sap1
,
322 const struct sockaddr
*sap2
)
324 const struct sockaddr_in
*sin1
= (const struct sockaddr_in
*)sap1
;
325 const struct sockaddr_in
*sin2
= (const struct sockaddr_in
*)sap2
;
326 return sin1
->sin_addr
.s_addr
== sin2
->sin_addr
.s_addr
;
329 static inline int __nlm_cmp_addr6(const struct sockaddr
*sap1
,
330 const struct sockaddr
*sap2
)
332 const struct sockaddr_in6
*sin1
= (const struct sockaddr_in6
*)sap1
;
333 const struct sockaddr_in6
*sin2
= (const struct sockaddr_in6
*)sap2
;
334 return ipv6_addr_equal(&sin1
->sin6_addr
, &sin2
->sin6_addr
);
338 * Compare two host addresses
340 * Return TRUE if the addresses are the same; otherwise FALSE.
342 static inline int nlm_cmp_addr(const struct sockaddr
*sap1
,
343 const struct sockaddr
*sap2
)
345 if (sap1
->sa_family
== sap2
->sa_family
) {
346 switch (sap1
->sa_family
) {
348 return __nlm_cmp_addr4(sap1
, sap2
);
350 return __nlm_cmp_addr6(sap1
, sap2
);
357 * Compare two NLM locks.
358 * When the second lock is of type F_UNLCK, this acts like a wildcard.
360 static inline int nlm_compare_locks(const struct file_lock
*fl1
,
361 const struct file_lock
*fl2
)
363 return fl1
->fl_pid
== fl2
->fl_pid
364 && fl1
->fl_owner
== fl2
->fl_owner
365 && fl1
->fl_start
== fl2
->fl_start
366 && fl1
->fl_end
== fl2
->fl_end
367 &&(fl1
->fl_type
== fl2
->fl_type
|| fl2
->fl_type
== F_UNLCK
);
370 extern struct lock_manager_operations nlmsvc_lock_operations
;
372 #endif /* __KERNEL__ */
374 #endif /* LINUX_LOCKD_LOCKD_H */