1 /*
2  * linux/fs/lockd/clntlock.c
3  *
4  * Lock handling for the client side NLM implementation
5  *
6  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
7  */
8 
9 #include <linux/module.h>
10 #include <linux/types.h>
11 #include <linux/slab.h>
12 #include <linux/time.h>
13 #include <linux/nfs_fs.h>
14 #include <linux/sunrpc/addr.h>
15 #include <linux/sunrpc/svc.h>
16 #include <linux/lockd/lockd.h>
17 #include <linux/kthread.h>
18 
19 #define NLMDBG_FACILITY		NLMDBG_CLIENT
20 
21 /*
22  * Local function prototypes
23  */
24 static int			reclaimer(void *ptr);
25 
26 /*
27  * The following functions handle blocking and granting from the
28  * client perspective.
29  */
30 
31 /*
32  * This is the representation of a blocked client lock.
33  */
34 struct nlm_wait {
35 	struct list_head	b_list;		/* linked list */
36 	wait_queue_head_t	b_wait;		/* where to wait on */
37 	struct nlm_host *	b_host;
38 	struct file_lock *	b_lock;		/* local file lock */
39 	unsigned short		b_reclaim;	/* got to reclaim lock */
40 	__be32			b_status;	/* grant callback status */
41 };
42 
43 static LIST_HEAD(nlm_blocked);
44 static DEFINE_SPINLOCK(nlm_blocked_lock);
45 
46 /**
47  * nlmclnt_init - Set up per-NFS mount point lockd data structures
48  * @nlm_init: pointer to arguments structure
49  *
50  * Returns pointer to an appropriate nlm_host struct,
51  * or an ERR_PTR value.
52  */
nlmclnt_init(const struct nlmclnt_initdata * nlm_init)53 struct nlm_host *nlmclnt_init(const struct nlmclnt_initdata *nlm_init)
54 {
55 	struct nlm_host *host;
56 	u32 nlm_version = (nlm_init->nfs_version == 2) ? 1 : 4;
57 	int status;
58 
59 	status = lockd_up(nlm_init->net);
60 	if (status < 0)
61 		return ERR_PTR(status);
62 
63 	host = nlmclnt_lookup_host(nlm_init->address, nlm_init->addrlen,
64 				   nlm_init->protocol, nlm_version,
65 				   nlm_init->hostname, nlm_init->noresvport,
66 				   nlm_init->net);
67 	if (host == NULL)
68 		goto out_nohost;
69 	if (host->h_rpcclnt == NULL && nlm_bind_host(host) == NULL)
70 		goto out_nobind;
71 
72 	host->h_nlmclnt_ops = nlm_init->nlmclnt_ops;
73 	return host;
74 out_nobind:
75 	nlmclnt_release_host(host);
76 out_nohost:
77 	lockd_down(nlm_init->net);
78 	return ERR_PTR(-ENOLCK);
79 }
80 EXPORT_SYMBOL_GPL(nlmclnt_init);
81 
82 /**
83  * nlmclnt_done - Release resources allocated by nlmclnt_init()
84  * @host: nlm_host structure reserved by nlmclnt_init()
85  *
86  */
nlmclnt_done(struct nlm_host * host)87 void nlmclnt_done(struct nlm_host *host)
88 {
89 	struct net *net = host->net;
90 
91 	nlmclnt_release_host(host);
92 	lockd_down(net);
93 }
94 EXPORT_SYMBOL_GPL(nlmclnt_done);
95 
96 /*
97  * Queue up a lock for blocking so that the GRANTED request can see it
98  */
nlmclnt_prepare_block(struct nlm_host * host,struct file_lock * fl)99 struct nlm_wait *nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl)
100 {
101 	struct nlm_wait *block;
102 
103 	block = kmalloc(sizeof(*block), GFP_KERNEL);
104 	if (block != NULL) {
105 		block->b_host = host;
106 		block->b_lock = fl;
107 		init_waitqueue_head(&block->b_wait);
108 		block->b_status = nlm_lck_blocked;
109 
110 		spin_lock(&nlm_blocked_lock);
111 		list_add(&block->b_list, &nlm_blocked);
112 		spin_unlock(&nlm_blocked_lock);
113 	}
114 	return block;
115 }
116 
nlmclnt_finish_block(struct nlm_wait * block)117 void nlmclnt_finish_block(struct nlm_wait *block)
118 {
119 	if (block == NULL)
120 		return;
121 	spin_lock(&nlm_blocked_lock);
122 	list_del(&block->b_list);
123 	spin_unlock(&nlm_blocked_lock);
124 	kfree(block);
125 }
126 
127 /*
128  * Block on a lock
129  */
nlmclnt_block(struct nlm_wait * block,struct nlm_rqst * req,long timeout)130 int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout)
131 {
132 	long ret;
133 
134 	/* A borken server might ask us to block even if we didn't
135 	 * request it. Just say no!
136 	 */
137 	if (block == NULL)
138 		return -EAGAIN;
139 
140 	/* Go to sleep waiting for GRANT callback. Some servers seem
141 	 * to lose callbacks, however, so we're going to poll from
142 	 * time to time just to make sure.
143 	 *
144 	 * For now, the retry frequency is pretty high; normally
145 	 * a 1 minute timeout would do. See the comment before
146 	 * nlmclnt_lock for an explanation.
147 	 */
148 	ret = wait_event_interruptible_timeout(block->b_wait,
149 			block->b_status != nlm_lck_blocked,
150 			timeout);
151 	if (ret < 0)
152 		return -ERESTARTSYS;
153 	/* Reset the lock status after a server reboot so we resend */
154 	if (block->b_status == nlm_lck_denied_grace_period)
155 		block->b_status = nlm_lck_blocked;
156 	req->a_res.status = block->b_status;
157 	return 0;
158 }
159 
160 /*
161  * The server lockd has called us back to tell us the lock was granted
162  */
nlmclnt_grant(const struct sockaddr * addr,const struct nlm_lock * lock)163 __be32 nlmclnt_grant(const struct sockaddr *addr, const struct nlm_lock *lock)
164 {
165 	const struct file_lock *fl = &lock->fl;
166 	const struct nfs_fh *fh = &lock->fh;
167 	struct nlm_wait	*block;
168 	__be32 res = nlm_lck_denied;
169 
170 	/*
171 	 * Look up blocked request based on arguments.
172 	 * Warning: must not use cookie to match it!
173 	 */
174 	spin_lock(&nlm_blocked_lock);
175 	list_for_each_entry(block, &nlm_blocked, b_list) {
176 		struct file_lock *fl_blocked = block->b_lock;
177 
178 		if (fl_blocked->fl_start != fl->fl_start)
179 			continue;
180 		if (fl_blocked->fl_end != fl->fl_end)
181 			continue;
182 		/*
183 		 * Careful! The NLM server will return the 32-bit "pid" that
184 		 * we put on the wire: in this case the lockowner "pid".
185 		 */
186 		if (fl_blocked->fl_u.nfs_fl.owner->pid != lock->svid)
187 			continue;
188 		if (!rpc_cmp_addr(nlm_addr(block->b_host), addr))
189 			continue;
190 		if (nfs_compare_fh(NFS_FH(locks_inode(fl_blocked->fl_file)), fh) != 0)
191 			continue;
192 		/* Alright, we found a lock. Set the return status
193 		 * and wake up the caller
194 		 */
195 		block->b_status = nlm_granted;
196 		wake_up(&block->b_wait);
197 		res = nlm_granted;
198 	}
199 	spin_unlock(&nlm_blocked_lock);
200 	return res;
201 }
202 
203 /*
204  * The following procedures deal with the recovery of locks after a
205  * server crash.
206  */
207 
208 /*
209  * Reclaim all locks on server host. We do this by spawning a separate
210  * reclaimer thread.
211  */
212 void
nlmclnt_recovery(struct nlm_host * host)213 nlmclnt_recovery(struct nlm_host *host)
214 {
215 	struct task_struct *task;
216 
217 	if (!host->h_reclaiming++) {
218 		nlm_get_host(host);
219 		task = kthread_run(reclaimer, host, "%s-reclaim", host->h_name);
220 		if (IS_ERR(task))
221 			printk(KERN_ERR "lockd: unable to spawn reclaimer "
222 				"thread. Locks for %s won't be reclaimed! "
223 				"(%ld)\n", host->h_name, PTR_ERR(task));
224 	}
225 }
226 
227 static int
reclaimer(void * ptr)228 reclaimer(void *ptr)
229 {
230 	struct nlm_host	  *host = (struct nlm_host *) ptr;
231 	struct nlm_wait	  *block;
232 	struct nlm_rqst   *req;
233 	struct file_lock *fl, *next;
234 	u32 nsmstate;
235 	struct net *net = host->net;
236 
237 	req = kmalloc(sizeof(*req), GFP_KERNEL);
238 	if (!req)
239 		return 0;
240 
241 	allow_signal(SIGKILL);
242 
243 	down_write(&host->h_rwsem);
244 	lockd_up(net);	/* note: this cannot fail as lockd is already running */
245 
246 	dprintk("lockd: reclaiming locks for host %s\n", host->h_name);
247 
248 restart:
249 	nsmstate = host->h_nsmstate;
250 
251 	/* Force a portmap getport - the peer's lockd will
252 	 * most likely end up on a different port.
253 	 */
254 	host->h_nextrebind = jiffies;
255 	nlm_rebind_host(host);
256 
257 	/* First, reclaim all locks that have been granted. */
258 	list_splice_init(&host->h_granted, &host->h_reclaim);
259 	list_for_each_entry_safe(fl, next, &host->h_reclaim, fl_u.nfs_fl.list) {
260 		list_del_init(&fl->fl_u.nfs_fl.list);
261 
262 		/*
263 		 * sending this thread a SIGKILL will result in any unreclaimed
264 		 * locks being removed from the h_granted list. This means that
265 		 * the kernel will not attempt to reclaim them again if a new
266 		 * reclaimer thread is spawned for this host.
267 		 */
268 		if (signalled())
269 			continue;
270 		if (nlmclnt_reclaim(host, fl, req) != 0)
271 			continue;
272 		list_add_tail(&fl->fl_u.nfs_fl.list, &host->h_granted);
273 		if (host->h_nsmstate != nsmstate) {
274 			/* Argh! The server rebooted again! */
275 			goto restart;
276 		}
277 	}
278 
279 	host->h_reclaiming = 0;
280 	up_write(&host->h_rwsem);
281 	dprintk("NLM: done reclaiming locks for host %s\n", host->h_name);
282 
283 	/* Now, wake up all processes that sleep on a blocked lock */
284 	spin_lock(&nlm_blocked_lock);
285 	list_for_each_entry(block, &nlm_blocked, b_list) {
286 		if (block->b_host == host) {
287 			block->b_status = nlm_lck_denied_grace_period;
288 			wake_up(&block->b_wait);
289 		}
290 	}
291 	spin_unlock(&nlm_blocked_lock);
292 
293 	/* Release host handle after use */
294 	nlmclnt_release_host(host);
295 	lockd_down(net);
296 	kfree(req);
297 	return 0;
298 }
299