1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#include <linux/export.h>
32#include <linux/nfs_fs.h>
33#include "nfs4session.h"
34#include "internal.h"
35#include "pnfs.h"
36
37#define NFSDBG_FACILITY NFSDBG_PNFS
38
39
40
41
42#define NFS4_DEVICE_ID_HASH_BITS 5
43#define NFS4_DEVICE_ID_HASH_SIZE (1 << NFS4_DEVICE_ID_HASH_BITS)
44#define NFS4_DEVICE_ID_HASH_MASK (NFS4_DEVICE_ID_HASH_SIZE - 1)
45
46#define PNFS_DEVICE_RETRY_TIMEOUT (120*HZ)
47
48static struct hlist_head nfs4_deviceid_cache[NFS4_DEVICE_ID_HASH_SIZE];
49static DEFINE_SPINLOCK(nfs4_deviceid_lock);
50
51#ifdef NFS_DEBUG
52void
53nfs4_print_deviceid(const struct nfs4_deviceid *id)
54{
55 u32 *p = (u32 *)id;
56
57 dprintk("%s: device id= [%x%x%x%x]\n", __func__,
58 p[0], p[1], p[2], p[3]);
59}
60EXPORT_SYMBOL_GPL(nfs4_print_deviceid);
61#endif
62
63static inline u32
64nfs4_deviceid_hash(const struct nfs4_deviceid *id)
65{
66 unsigned char *cptr = (unsigned char *)id->data;
67 unsigned int nbytes = NFS4_DEVICEID4_SIZE;
68 u32 x = 0;
69
70 while (nbytes--) {
71 x *= 37;
72 x += *cptr++;
73 }
74 return x & NFS4_DEVICE_ID_HASH_MASK;
75}
76
77static struct nfs4_deviceid_node *
78_lookup_deviceid(const struct pnfs_layoutdriver_type *ld,
79 const struct nfs_client *clp, const struct nfs4_deviceid *id,
80 long hash)
81{
82 struct nfs4_deviceid_node *d;
83
84 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node)
85 if (d->ld == ld && d->nfs_client == clp &&
86 !memcmp(&d->deviceid, id, sizeof(*id))) {
87 if (atomic_read(&d->ref))
88 return d;
89 else
90 continue;
91 }
92 return NULL;
93}
94
95static struct nfs4_deviceid_node *
96nfs4_get_device_info(struct nfs_server *server,
97 const struct nfs4_deviceid *dev_id,
98 struct rpc_cred *cred, gfp_t gfp_flags)
99{
100 struct nfs4_deviceid_node *d = NULL;
101 struct pnfs_device *pdev = NULL;
102 struct page **pages = NULL;
103 u32 max_resp_sz;
104 int max_pages;
105 int rc, i;
106
107
108
109
110
111 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
112 if (server->pnfs_curr_ld->max_deviceinfo_size &&
113 server->pnfs_curr_ld->max_deviceinfo_size < max_resp_sz)
114 max_resp_sz = server->pnfs_curr_ld->max_deviceinfo_size;
115 max_pages = nfs_page_array_len(0, max_resp_sz);
116 dprintk("%s: server %p max_resp_sz %u max_pages %d\n",
117 __func__, server, max_resp_sz, max_pages);
118
119 pdev = kzalloc(sizeof(*pdev), gfp_flags);
120 if (!pdev)
121 return NULL;
122
123 pages = kcalloc(max_pages, sizeof(struct page *), gfp_flags);
124 if (!pages)
125 goto out_free_pdev;
126
127 for (i = 0; i < max_pages; i++) {
128 pages[i] = alloc_page(gfp_flags);
129 if (!pages[i])
130 goto out_free_pages;
131 }
132
133 memcpy(&pdev->dev_id, dev_id, sizeof(*dev_id));
134 pdev->layout_type = server->pnfs_curr_ld->id;
135 pdev->pages = pages;
136 pdev->pgbase = 0;
137 pdev->pglen = max_resp_sz;
138 pdev->mincount = 0;
139 pdev->maxcount = max_resp_sz - nfs41_maxgetdevinfo_overhead;
140
141 rc = nfs4_proc_getdeviceinfo(server, pdev, cred);
142 dprintk("%s getdevice info returns %d\n", __func__, rc);
143 if (rc)
144 goto out_free_pages;
145
146
147
148
149
150 d = server->pnfs_curr_ld->alloc_deviceid_node(server, pdev,
151 gfp_flags);
152
153out_free_pages:
154 for (i = 0; i < max_pages; i++)
155 __free_page(pages[i]);
156 kfree(pages);
157out_free_pdev:
158 kfree(pdev);
159 dprintk("<-- %s d %p\n", __func__, d);
160 return d;
161}
162
163
164
165
166
167
168
169static struct nfs4_deviceid_node *
170__nfs4_find_get_deviceid(struct nfs_server *server,
171 const struct nfs4_deviceid *id, long hash)
172{
173 struct nfs4_deviceid_node *d;
174
175 rcu_read_lock();
176 d = _lookup_deviceid(server->pnfs_curr_ld, server->nfs_client, id,
177 hash);
178 if (d != NULL)
179 atomic_inc(&d->ref);
180 rcu_read_unlock();
181 return d;
182}
183
184struct nfs4_deviceid_node *
185nfs4_find_get_deviceid(struct nfs_server *server,
186 const struct nfs4_deviceid *id, struct rpc_cred *cred,
187 gfp_t gfp_mask)
188{
189 long hash = nfs4_deviceid_hash(id);
190 struct nfs4_deviceid_node *d, *new;
191
192 d = __nfs4_find_get_deviceid(server, id, hash);
193 if (d)
194 return d;
195
196 new = nfs4_get_device_info(server, id, cred, gfp_mask);
197 if (!new)
198 return new;
199
200 spin_lock(&nfs4_deviceid_lock);
201 d = __nfs4_find_get_deviceid(server, id, hash);
202 if (d) {
203 spin_unlock(&nfs4_deviceid_lock);
204 server->pnfs_curr_ld->free_deviceid_node(new);
205 return d;
206 }
207 hlist_add_head_rcu(&new->node, &nfs4_deviceid_cache[hash]);
208 atomic_inc(&new->ref);
209 spin_unlock(&nfs4_deviceid_lock);
210
211 return new;
212}
213EXPORT_SYMBOL_GPL(nfs4_find_get_deviceid);
214
215
216
217
218
219
220
221
222
223void
224nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld,
225 const struct nfs_client *clp, const struct nfs4_deviceid *id)
226{
227 struct nfs4_deviceid_node *d;
228
229 spin_lock(&nfs4_deviceid_lock);
230 rcu_read_lock();
231 d = _lookup_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
232 rcu_read_unlock();
233 if (!d) {
234 spin_unlock(&nfs4_deviceid_lock);
235 return;
236 }
237 hlist_del_init_rcu(&d->node);
238 spin_unlock(&nfs4_deviceid_lock);
239 synchronize_rcu();
240
241
242 if (atomic_dec_and_test(&d->ref))
243 d->ld->free_deviceid_node(d);
244}
245EXPORT_SYMBOL_GPL(nfs4_delete_deviceid);
246
247void
248nfs4_init_deviceid_node(struct nfs4_deviceid_node *d, struct nfs_server *server,
249 const struct nfs4_deviceid *id)
250{
251 INIT_HLIST_NODE(&d->node);
252 INIT_HLIST_NODE(&d->tmpnode);
253 d->ld = server->pnfs_curr_ld;
254 d->nfs_client = server->nfs_client;
255 d->flags = 0;
256 d->deviceid = *id;
257 atomic_set(&d->ref, 1);
258}
259EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node);
260
261
262
263
264
265
266
267
268
269
270
271bool
272nfs4_put_deviceid_node(struct nfs4_deviceid_node *d)
273{
274 if (!atomic_dec_and_test(&d->ref))
275 return false;
276 d->ld->free_deviceid_node(d);
277 return true;
278}
279EXPORT_SYMBOL_GPL(nfs4_put_deviceid_node);
280
281void
282nfs4_mark_deviceid_unavailable(struct nfs4_deviceid_node *node)
283{
284 node->timestamp_unavailable = jiffies;
285 set_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags);
286}
287EXPORT_SYMBOL_GPL(nfs4_mark_deviceid_unavailable);
288
289bool
290nfs4_test_deviceid_unavailable(struct nfs4_deviceid_node *node)
291{
292 if (test_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags)) {
293 unsigned long start, end;
294
295 end = jiffies;
296 start = end - PNFS_DEVICE_RETRY_TIMEOUT;
297 if (time_in_range(node->timestamp_unavailable, start, end))
298 return true;
299 clear_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags);
300 }
301 return false;
302}
303EXPORT_SYMBOL_GPL(nfs4_test_deviceid_unavailable);
304
305static void
306_deviceid_purge_client(const struct nfs_client *clp, long hash)
307{
308 struct nfs4_deviceid_node *d;
309 HLIST_HEAD(tmp);
310
311 spin_lock(&nfs4_deviceid_lock);
312 rcu_read_lock();
313 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node)
314 if (d->nfs_client == clp && atomic_read(&d->ref)) {
315 hlist_del_init_rcu(&d->node);
316 hlist_add_head(&d->tmpnode, &tmp);
317 }
318 rcu_read_unlock();
319 spin_unlock(&nfs4_deviceid_lock);
320
321 if (hlist_empty(&tmp))
322 return;
323
324 synchronize_rcu();
325 while (!hlist_empty(&tmp)) {
326 d = hlist_entry(tmp.first, struct nfs4_deviceid_node, tmpnode);
327 hlist_del(&d->tmpnode);
328 if (atomic_dec_and_test(&d->ref))
329 d->ld->free_deviceid_node(d);
330 }
331}
332
333void
334nfs4_deviceid_purge_client(const struct nfs_client *clp)
335{
336 long h;
337
338 if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_MDS))
339 return;
340 for (h = 0; h < NFS4_DEVICE_ID_HASH_SIZE; h++)
341 _deviceid_purge_client(clp, h);
342}
343
344
345
346
347void
348nfs4_deviceid_mark_client_invalid(struct nfs_client *clp)
349{
350 struct nfs4_deviceid_node *d;
351 int i;
352
353 rcu_read_lock();
354 for (i = 0; i < NFS4_DEVICE_ID_HASH_SIZE; i ++){
355 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[i], node)
356 if (d->nfs_client == clp)
357 set_bit(NFS_DEVICEID_INVALID, &d->flags);
358 }
359 rcu_read_unlock();
360}
361