1
2
3
4
5
6
7
8
9#include <linux/module.h>
10#include <linux/types.h>
11#include <linux/time.h>
12#include <linux/nfs_fs.h>
13#include <linux/sunrpc/clnt.h>
14#include <linux/sunrpc/svc.h>
15#include <linux/lockd/lockd.h>
16#include <linux/smp_lock.h>
17#include <linux/kthread.h>
18
19#define NLMDBG_FACILITY NLMDBG_CLIENT
20
21
22
23
24static int reclaimer(void *ptr);
25
26
27
28
29
30
31
32
33
34struct nlm_wait {
35 struct list_head b_list;
36 wait_queue_head_t b_wait;
37 struct nlm_host * b_host;
38 struct file_lock * b_lock;
39 unsigned short b_reclaim;
40 __be32 b_status;
41};
42
43static LIST_HEAD(nlm_blocked);
44
45
46
47
48
49
50
51
52struct nlm_host *nlmclnt_init(const struct nlmclnt_initdata *nlm_init)
53{
54 struct nlm_host *host;
55 u32 nlm_version = (nlm_init->nfs_version == 2) ? 1 : 4;
56 int status;
57
58 status = lockd_up();
59 if (status < 0)
60 return ERR_PTR(status);
61
62 host = nlmclnt_lookup_host(nlm_init->address, nlm_init->addrlen,
63 nlm_init->protocol, nlm_version,
64 nlm_init->hostname, nlm_init->noresvport);
65 if (host == NULL) {
66 lockd_down();
67 return ERR_PTR(-ENOLCK);
68 }
69
70 return host;
71}
72EXPORT_SYMBOL_GPL(nlmclnt_init);
73
74
75
76
77
78
79void nlmclnt_done(struct nlm_host *host)
80{
81 nlm_release_host(host);
82 lockd_down();
83}
84EXPORT_SYMBOL_GPL(nlmclnt_done);
85
86
87
88
89struct nlm_wait *nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl)
90{
91 struct nlm_wait *block;
92
93 block = kmalloc(sizeof(*block), GFP_KERNEL);
94 if (block != NULL) {
95 block->b_host = host;
96 block->b_lock = fl;
97 init_waitqueue_head(&block->b_wait);
98 block->b_status = nlm_lck_blocked;
99 list_add(&block->b_list, &nlm_blocked);
100 }
101 return block;
102}
103
104void nlmclnt_finish_block(struct nlm_wait *block)
105{
106 if (block == NULL)
107 return;
108 list_del(&block->b_list);
109 kfree(block);
110}
111
112
113
114
115int nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout)
116{
117 long ret;
118
119
120
121
122 if (block == NULL)
123 return -EAGAIN;
124
125
126
127
128
129
130
131
132
133 ret = wait_event_interruptible_timeout(block->b_wait,
134 block->b_status != nlm_lck_blocked,
135 timeout);
136 if (ret < 0)
137 return -ERESTARTSYS;
138 req->a_res.status = block->b_status;
139 return 0;
140}
141
142
143
144
145__be32 nlmclnt_grant(const struct sockaddr *addr, const struct nlm_lock *lock)
146{
147 const struct file_lock *fl = &lock->fl;
148 const struct nfs_fh *fh = &lock->fh;
149 struct nlm_wait *block;
150 __be32 res = nlm_lck_denied;
151
152
153
154
155
156 list_for_each_entry(block, &nlm_blocked, b_list) {
157 struct file_lock *fl_blocked = block->b_lock;
158
159 if (fl_blocked->fl_start != fl->fl_start)
160 continue;
161 if (fl_blocked->fl_end != fl->fl_end)
162 continue;
163
164
165
166
167 if (fl_blocked->fl_u.nfs_fl.owner->pid != lock->svid)
168 continue;
169 if (!rpc_cmp_addr(nlm_addr(block->b_host), addr))
170 continue;
171 if (nfs_compare_fh(NFS_FH(fl_blocked->fl_file->f_path.dentry->d_inode) ,fh) != 0)
172 continue;
173
174
175
176 block->b_status = nlm_granted;
177 wake_up(&block->b_wait);
178 res = nlm_granted;
179 }
180 return res;
181}
182
183
184
185
186
187
188
189
190
191
192void
193nlmclnt_recovery(struct nlm_host *host)
194{
195 struct task_struct *task;
196
197 if (!host->h_reclaiming++) {
198 nlm_get_host(host);
199 task = kthread_run(reclaimer, host, "%s-reclaim", host->h_name);
200 if (IS_ERR(task))
201 printk(KERN_ERR "lockd: unable to spawn reclaimer "
202 "thread. Locks for %s won't be reclaimed! "
203 "(%ld)\n", host->h_name, PTR_ERR(task));
204 }
205}
206
207static int
208reclaimer(void *ptr)
209{
210 struct nlm_host *host = (struct nlm_host *) ptr;
211 struct nlm_wait *block;
212 struct file_lock *fl, *next;
213 u32 nsmstate;
214
215 allow_signal(SIGKILL);
216
217 down_write(&host->h_rwsem);
218
219
220
221 lock_kernel();
222 lockd_up();
223
224 dprintk("lockd: reclaiming locks for host %s\n", host->h_name);
225
226restart:
227 nsmstate = host->h_nsmstate;
228
229
230
231
232 host->h_nextrebind = jiffies;
233 nlm_rebind_host(host);
234
235
236 list_splice_init(&host->h_granted, &host->h_reclaim);
237 list_for_each_entry_safe(fl, next, &host->h_reclaim, fl_u.nfs_fl.list) {
238 list_del_init(&fl->fl_u.nfs_fl.list);
239
240
241
242
243
244
245
246 if (signalled())
247 continue;
248 if (nlmclnt_reclaim(host, fl) != 0)
249 continue;
250 list_add_tail(&fl->fl_u.nfs_fl.list, &host->h_granted);
251 if (host->h_nsmstate != nsmstate) {
252
253 goto restart;
254 }
255 }
256
257 host->h_reclaiming = 0;
258 up_write(&host->h_rwsem);
259 dprintk("NLM: done reclaiming locks for host %s\n", host->h_name);
260
261
262 list_for_each_entry(block, &nlm_blocked, b_list) {
263 if (block->b_host == host) {
264 block->b_status = nlm_lck_denied_grace_period;
265 wake_up(&block->b_wait);
266 }
267 }
268
269
270 nlm_release_host(host);
271 lockd_down();
272 unlock_kernel();
273 return 0;
274}
275