Commit | Line | Data |
---|---|---|
a1eaecbc BH |
1 | /* |
2 | * Device operations for the pnfs client. | |
3 | * | |
4 | * Copyright (c) 2002 | |
5 | * The Regents of the University of Michigan | |
6 | * All Rights Reserved | |
7 | * | |
8 | * Dean Hildebrand <dhildebz@umich.edu> | |
9 | * Garth Goodson <Garth.Goodson@netapp.com> | |
10 | * | |
11 | * Permission is granted to use, copy, create derivative works, and | |
12 | * redistribute this software and such derivative works for any purpose, | |
13 | * so long as the name of the University of Michigan is not used in | |
14 | * any advertising or publicity pertaining to the use or distribution | |
15 | * of this software without specific, written prior authorization. If | |
16 | * the above copyright notice or any other identification of the | |
17 | * University of Michigan is included in any copy of any portion of | |
18 | * this software, then the disclaimer below must also be included. | |
19 | * | |
20 | * This software is provided as is, without representation or warranty | |
21 | * of any kind either express or implied, including without limitation | |
22 | * the implied warranties of merchantability, fitness for a particular | |
23 | * purpose, or noninfringement. The Regents of the University of | |
24 | * Michigan shall not be liable for any damages, including special, | |
25 | * indirect, incidental, or consequential damages, with respect to any | |
26 | * claim arising out of or in connection with the use of the software, | |
27 | * even if it has been or is hereafter advised of the possibility of | |
28 | * such damages. | |
29 | */ | |
30 | ||
afeacc8c | 31 | #include <linux/export.h> |
661373b1 CH |
32 | #include <linux/nfs_fs.h> |
33 | #include "nfs4session.h" | |
34 | #include "internal.h" | |
a1eaecbc BH |
35 | #include "pnfs.h" |
36 | ||
37 | #define NFSDBG_FACILITY NFSDBG_PNFS | |
38 | ||
39 | /* | |
40 | * Device ID RCU cache. A device ID is unique per server and layout type. | |
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 | ||
1dfed273 TM |
46 | #define PNFS_DEVICE_RETRY_TIMEOUT (120*HZ) |
47 | ||
a1eaecbc BH |
48 | static struct hlist_head nfs4_deviceid_cache[NFS4_DEVICE_ID_HASH_SIZE]; |
49 | static DEFINE_SPINLOCK(nfs4_deviceid_lock); | |
50 | ||
6f00866d | 51 | #ifdef NFS_DEBUG |
a1eaecbc BH |
52 | void |
53 | nfs4_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 | } | |
60 | EXPORT_SYMBOL_GPL(nfs4_print_deviceid); | |
6f00866d | 61 | #endif |
a1eaecbc BH |
62 | |
63 | static inline u32 | |
64 | nfs4_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 | ||
1be5683b | 77 | static struct nfs4_deviceid_node * |
35c8bb54 BH |
78 | _lookup_deviceid(const struct pnfs_layoutdriver_type *ld, |
79 | const struct nfs_client *clp, const struct nfs4_deviceid *id, | |
1be5683b ME |
80 | long hash) |
81 | { | |
82 | struct nfs4_deviceid_node *d; | |
1be5683b | 83 | |
b67bfe0d | 84 | hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node) |
35c8bb54 BH |
85 | if (d->ld == ld && d->nfs_client == clp && |
86 | !memcmp(&d->deviceid, id, sizeof(*id))) { | |
1be5683b ME |
87 | if (atomic_read(&d->ref)) |
88 | return d; | |
89 | else | |
90 | continue; | |
91 | } | |
92 | return NULL; | |
93 | } | |
94 | ||
661373b1 CH |
95 | static struct nfs4_deviceid_node * |
96 | nfs4_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 | * Use the session max response size as the basis for setting | |
109 | * GETDEVICEINFO's maxcount | |
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 | * Found new device, need to decode it and then add it to the | |
148 | * list of known devices for this mountpoint. | |
149 | */ | |
150 | d = server->pnfs_curr_ld->alloc_deviceid_node(server, pdev, | |
151 | gfp_flags); | |
df52699e TM |
152 | if (d && pdev->nocache) |
153 | set_bit(NFS_DEVICEID_NOCACHE, &d->flags); | |
661373b1 CH |
154 | |
155 | out_free_pages: | |
156 | for (i = 0; i < max_pages; i++) | |
157 | __free_page(pages[i]); | |
158 | kfree(pages); | |
159 | out_free_pdev: | |
160 | kfree(pdev); | |
161 | dprintk("<-- %s d %p\n", __func__, d); | |
162 | return d; | |
163 | } | |
164 | ||
a1eaecbc BH |
165 | /* |
166 | * Lookup a deviceid in cache and get a reference count on it if found | |
167 | * | |
168 | * @clp nfs_client associated with deviceid | |
169 | * @id deviceid to look up | |
170 | */ | |
17280175 | 171 | static struct nfs4_deviceid_node * |
661373b1 CH |
172 | __nfs4_find_get_deviceid(struct nfs_server *server, |
173 | const struct nfs4_deviceid *id, long hash) | |
1be5683b ME |
174 | { |
175 | struct nfs4_deviceid_node *d; | |
176 | ||
177 | rcu_read_lock(); | |
661373b1 CH |
178 | d = _lookup_deviceid(server->pnfs_curr_ld, server->nfs_client, id, |
179 | hash); | |
84a80f62 TM |
180 | if (d != NULL && !atomic_inc_not_zero(&d->ref)) |
181 | d = NULL; | |
1be5683b ME |
182 | rcu_read_unlock(); |
183 | return d; | |
184 | } | |
185 | ||
a1eaecbc | 186 | struct nfs4_deviceid_node * |
661373b1 CH |
187 | nfs4_find_get_deviceid(struct nfs_server *server, |
188 | const struct nfs4_deviceid *id, struct rpc_cred *cred, | |
189 | gfp_t gfp_mask) | |
1be5683b | 190 | { |
661373b1 CH |
191 | long hash = nfs4_deviceid_hash(id); |
192 | struct nfs4_deviceid_node *d, *new; | |
193 | ||
194 | d = __nfs4_find_get_deviceid(server, id, hash); | |
195 | if (d) | |
196 | return d; | |
197 | ||
198 | new = nfs4_get_device_info(server, id, cred, gfp_mask); | |
199 | if (!new) | |
200 | return new; | |
201 | ||
202 | spin_lock(&nfs4_deviceid_lock); | |
203 | d = __nfs4_find_get_deviceid(server, id, hash); | |
204 | if (d) { | |
205 | spin_unlock(&nfs4_deviceid_lock); | |
206 | server->pnfs_curr_ld->free_deviceid_node(new); | |
207 | return d; | |
208 | } | |
209 | hlist_add_head_rcu(&new->node, &nfs4_deviceid_cache[hash]); | |
210 | atomic_inc(&new->ref); | |
211 | spin_unlock(&nfs4_deviceid_lock); | |
212 | ||
213 | return new; | |
1be5683b ME |
214 | } |
215 | EXPORT_SYMBOL_GPL(nfs4_find_get_deviceid); | |
216 | ||
217 | /* | |
47cb498e | 218 | * Remove a deviceid from cache |
1be5683b ME |
219 | * |
220 | * @clp nfs_client associated with deviceid | |
221 | * @id the deviceid to unhash | |
222 | * | |
223 | * @ret the unhashed node, if found and dereferenced to zero, NULL otherwise. | |
224 | */ | |
47cb498e TM |
225 | void |
226 | nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld, | |
35c8bb54 | 227 | const struct nfs_client *clp, const struct nfs4_deviceid *id) |
a1eaecbc BH |
228 | { |
229 | struct nfs4_deviceid_node *d; | |
a1eaecbc | 230 | |
1be5683b | 231 | spin_lock(&nfs4_deviceid_lock); |
a1eaecbc | 232 | rcu_read_lock(); |
35c8bb54 | 233 | d = _lookup_deviceid(ld, clp, id, nfs4_deviceid_hash(id)); |
a1eaecbc | 234 | rcu_read_unlock(); |
1be5683b ME |
235 | if (!d) { |
236 | spin_unlock(&nfs4_deviceid_lock); | |
47cb498e | 237 | return; |
1be5683b ME |
238 | } |
239 | hlist_del_init_rcu(&d->node); | |
df52699e | 240 | clear_bit(NFS_DEVICEID_NOCACHE, &d->flags); |
1be5683b | 241 | spin_unlock(&nfs4_deviceid_lock); |
1be5683b ME |
242 | |
243 | /* balance the initial ref set in pnfs_insert_deviceid */ | |
fb1458f4 | 244 | nfs4_put_deviceid_node(d); |
1be5683b ME |
245 | } |
246 | EXPORT_SYMBOL_GPL(nfs4_delete_deviceid); | |
a1eaecbc BH |
247 | |
248 | void | |
661373b1 | 249 | nfs4_init_deviceid_node(struct nfs4_deviceid_node *d, struct nfs_server *server, |
a1eaecbc BH |
250 | const struct nfs4_deviceid *id) |
251 | { | |
1775bc34 | 252 | INIT_HLIST_NODE(&d->node); |
9e3bd4e2 | 253 | INIT_HLIST_NODE(&d->tmpnode); |
661373b1 CH |
254 | d->ld = server->pnfs_curr_ld; |
255 | d->nfs_client = server->nfs_client; | |
c47abcf8 | 256 | d->flags = 0; |
a1eaecbc | 257 | d->deviceid = *id; |
1775bc34 | 258 | atomic_set(&d->ref, 1); |
a1eaecbc BH |
259 | } |
260 | EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node); | |
261 | ||
a1eaecbc BH |
262 | /* |
263 | * Dereference a deviceid node and delete it when its reference count drops | |
264 | * to zero. | |
265 | * | |
266 | * @d deviceid node to put | |
267 | * | |
47cb498e TM |
268 | * return true iff the node was deleted |
269 | * Note that since the test for d->ref == 0 is sufficient to establish | |
270 | * that the node is no longer hashed in the global device id cache. | |
a1eaecbc BH |
271 | */ |
272 | bool | |
273 | nfs4_put_deviceid_node(struct nfs4_deviceid_node *d) | |
274 | { | |
df52699e TM |
275 | if (test_bit(NFS_DEVICEID_NOCACHE, &d->flags)) { |
276 | if (atomic_add_unless(&d->ref, -1, 2)) | |
277 | return false; | |
278 | nfs4_delete_deviceid(d->ld, d->nfs_client, &d->deviceid); | |
279 | } | |
47cb498e | 280 | if (!atomic_dec_and_test(&d->ref)) |
a1eaecbc | 281 | return false; |
1775bc34 | 282 | d->ld->free_deviceid_node(d); |
a1eaecbc BH |
283 | return true; |
284 | } | |
285 | EXPORT_SYMBOL_GPL(nfs4_put_deviceid_node); | |
1775bc34 | 286 | |
1dfed273 TM |
287 | void |
288 | nfs4_mark_deviceid_unavailable(struct nfs4_deviceid_node *node) | |
289 | { | |
290 | node->timestamp_unavailable = jiffies; | |
291 | set_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags); | |
292 | } | |
293 | EXPORT_SYMBOL_GPL(nfs4_mark_deviceid_unavailable); | |
294 | ||
295 | bool | |
296 | nfs4_test_deviceid_unavailable(struct nfs4_deviceid_node *node) | |
297 | { | |
298 | if (test_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags)) { | |
299 | unsigned long start, end; | |
300 | ||
301 | end = jiffies; | |
302 | start = end - PNFS_DEVICE_RETRY_TIMEOUT; | |
303 | if (time_in_range(node->timestamp_unavailable, start, end)) | |
304 | return true; | |
305 | clear_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags); | |
306 | } | |
307 | return false; | |
308 | } | |
309 | EXPORT_SYMBOL_GPL(nfs4_test_deviceid_unavailable); | |
310 | ||
1775bc34 BH |
311 | static void |
312 | _deviceid_purge_client(const struct nfs_client *clp, long hash) | |
313 | { | |
314 | struct nfs4_deviceid_node *d; | |
1775bc34 BH |
315 | HLIST_HEAD(tmp); |
316 | ||
9e3bd4e2 | 317 | spin_lock(&nfs4_deviceid_lock); |
1775bc34 | 318 | rcu_read_lock(); |
b67bfe0d | 319 | hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node) |
1775bc34 BH |
320 | if (d->nfs_client == clp && atomic_read(&d->ref)) { |
321 | hlist_del_init_rcu(&d->node); | |
9e3bd4e2 | 322 | hlist_add_head(&d->tmpnode, &tmp); |
df52699e | 323 | clear_bit(NFS_DEVICEID_NOCACHE, &d->flags); |
1775bc34 BH |
324 | } |
325 | rcu_read_unlock(); | |
9e3bd4e2 | 326 | spin_unlock(&nfs4_deviceid_lock); |
1775bc34 BH |
327 | |
328 | if (hlist_empty(&tmp)) | |
329 | return; | |
330 | ||
9e3bd4e2 WAA |
331 | while (!hlist_empty(&tmp)) { |
332 | d = hlist_entry(tmp.first, struct nfs4_deviceid_node, tmpnode); | |
333 | hlist_del(&d->tmpnode); | |
fb1458f4 | 334 | nfs4_put_deviceid_node(d); |
9e3bd4e2 | 335 | } |
1775bc34 BH |
336 | } |
337 | ||
338 | void | |
339 | nfs4_deviceid_purge_client(const struct nfs_client *clp) | |
340 | { | |
341 | long h; | |
342 | ||
9e3bd4e2 WAA |
343 | if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_MDS)) |
344 | return; | |
1775bc34 BH |
345 | for (h = 0; h < NFS4_DEVICE_ID_HASH_SIZE; h++) |
346 | _deviceid_purge_client(clp, h); | |
1775bc34 | 347 | } |
c47abcf8 AA |
348 | |
349 | /* | |
350 | * Stop use of all deviceids associated with an nfs_client | |
351 | */ | |
352 | void | |
353 | nfs4_deviceid_mark_client_invalid(struct nfs_client *clp) | |
354 | { | |
355 | struct nfs4_deviceid_node *d; | |
c47abcf8 AA |
356 | int i; |
357 | ||
358 | rcu_read_lock(); | |
359 | for (i = 0; i < NFS4_DEVICE_ID_HASH_SIZE; i ++){ | |
b67bfe0d | 360 | hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[i], node) |
c47abcf8 AA |
361 | if (d->nfs_client == clp) |
362 | set_bit(NFS_DEVICEID_INVALID, &d->flags); | |
363 | } | |
364 | rcu_read_unlock(); | |
365 | } |