blob: aa2ec00151839f1519a2c7e0ab65509d9f2cfba3 [file] [log] [blame]
Benny Halevya1eaecb2011-05-19 22:14:47 -04001/*
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
Paul Gortmakerafeacc82011-05-26 16:00:52 -040031#include <linux/export.h>
Christoph Hellwig661373b2014-09-02 21:27:57 -070032#include <linux/nfs_fs.h>
33#include "nfs4session.h"
34#include "internal.h"
Benny Halevya1eaecb2011-05-19 22:14:47 -040035#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
Trond Myklebust1dfed272012-09-18 19:51:12 -040046#define PNFS_DEVICE_RETRY_TIMEOUT (120*HZ)
47
Benny Halevya1eaecb2011-05-19 22:14:47 -040048static struct hlist_head nfs4_deviceid_cache[NFS4_DEVICE_ID_HASH_SIZE];
49static DEFINE_SPINLOCK(nfs4_deviceid_lock);
50
Trond Myklebust6f008662012-03-20 14:12:46 -040051#ifdef NFS_DEBUG
Benny Halevya1eaecb2011-05-19 22:14:47 -040052void
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);
Trond Myklebust6f008662012-03-20 14:12:46 -040061#endif
Benny Halevya1eaecb2011-05-19 22:14:47 -040062
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
Marc Eshel1be56832011-05-22 19:47:09 +030077static struct nfs4_deviceid_node *
Benny Halevy35c8bb52011-05-24 18:04:02 +030078_lookup_deviceid(const struct pnfs_layoutdriver_type *ld,
79 const struct nfs_client *clp, const struct nfs4_deviceid *id,
Marc Eshel1be56832011-05-22 19:47:09 +030080 long hash)
81{
82 struct nfs4_deviceid_node *d;
Marc Eshel1be56832011-05-22 19:47:09 +030083
Sasha Levinb67bfe02013-02-27 17:06:00 -080084 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node)
Benny Halevy35c8bb52011-05-24 18:04:02 +030085 if (d->ld == ld && d->nfs_client == clp &&
86 !memcmp(&d->deviceid, id, sizeof(*id))) {
Marc Eshel1be56832011-05-22 19:47:09 +030087 if (atomic_read(&d->ref))
88 return d;
89 else
90 continue;
91 }
92 return NULL;
93}
94
Christoph Hellwig661373b2014-09-02 21:27:57 -070095static 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 * 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);
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
Benny Halevya1eaecb2011-05-19 22:14:47 -0400163/*
164 * Lookup a deviceid in cache and get a reference count on it if found
165 *
166 * @clp nfs_client associated with deviceid
167 * @id deviceid to look up
168 */
Trond Myklebust17280172012-03-11 13:11:00 -0400169static struct nfs4_deviceid_node *
Christoph Hellwig661373b2014-09-02 21:27:57 -0700170__nfs4_find_get_deviceid(struct nfs_server *server,
171 const struct nfs4_deviceid *id, long hash)
Benny Halevya1eaecb2011-05-19 22:14:47 -0400172{
173 struct nfs4_deviceid_node *d;
Benny Halevya1eaecb2011-05-19 22:14:47 -0400174
175 rcu_read_lock();
Christoph Hellwig661373b2014-09-02 21:27:57 -0700176 d = _lookup_deviceid(server->pnfs_curr_ld, server->nfs_client, id,
177 hash);
Trond Myklebust47cb4982011-06-14 12:18:11 -0400178 if (d != NULL)
179 atomic_inc(&d->ref);
Benny Halevya1eaecb2011-05-19 22:14:47 -0400180 rcu_read_unlock();
Marc Eshel1be56832011-05-22 19:47:09 +0300181 return d;
182}
183
184struct nfs4_deviceid_node *
Christoph Hellwig661373b2014-09-02 21:27:57 -0700185nfs4_find_get_deviceid(struct nfs_server *server,
186 const struct nfs4_deviceid *id, struct rpc_cred *cred,
187 gfp_t gfp_mask)
Marc Eshel1be56832011-05-22 19:47:09 +0300188{
Christoph Hellwig661373b2014-09-02 21:27:57 -0700189 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;
Benny Halevya1eaecb2011-05-19 22:14:47 -0400212}
213EXPORT_SYMBOL_GPL(nfs4_find_get_deviceid);
214
Marc Eshel1be56832011-05-22 19:47:09 +0300215/*
Trond Myklebust47cb4982011-06-14 12:18:11 -0400216 * Remove a deviceid from cache
Marc Eshel1be56832011-05-22 19:47:09 +0300217 *
218 * @clp nfs_client associated with deviceid
219 * @id the deviceid to unhash
220 *
221 * @ret the unhashed node, if found and dereferenced to zero, NULL otherwise.
222 */
Trond Myklebust47cb4982011-06-14 12:18:11 -0400223void
224nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld,
Benny Halevy35c8bb52011-05-24 18:04:02 +0300225 const struct nfs_client *clp, const struct nfs4_deviceid *id)
Marc Eshel1be56832011-05-22 19:47:09 +0300226{
227 struct nfs4_deviceid_node *d;
228
229 spin_lock(&nfs4_deviceid_lock);
230 rcu_read_lock();
Benny Halevy35c8bb52011-05-24 18:04:02 +0300231 d = _lookup_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
Marc Eshel1be56832011-05-22 19:47:09 +0300232 rcu_read_unlock();
233 if (!d) {
234 spin_unlock(&nfs4_deviceid_lock);
Trond Myklebust47cb4982011-06-14 12:18:11 -0400235 return;
Marc Eshel1be56832011-05-22 19:47:09 +0300236 }
237 hlist_del_init_rcu(&d->node);
238 spin_unlock(&nfs4_deviceid_lock);
239 synchronize_rcu();
240
241 /* balance the initial ref set in pnfs_insert_deviceid */
242 if (atomic_dec_and_test(&d->ref))
Trond Myklebust47cb4982011-06-14 12:18:11 -0400243 d->ld->free_deviceid_node(d);
Marc Eshel1be56832011-05-22 19:47:09 +0300244}
245EXPORT_SYMBOL_GPL(nfs4_delete_deviceid);
246
Benny Halevya1eaecb2011-05-19 22:14:47 -0400247void
Christoph Hellwig661373b2014-09-02 21:27:57 -0700248nfs4_init_deviceid_node(struct nfs4_deviceid_node *d, struct nfs_server *server,
Benny Halevya1eaecb2011-05-19 22:14:47 -0400249 const struct nfs4_deviceid *id)
250{
Benny Halevy1775bc32011-05-20 13:47:33 +0200251 INIT_HLIST_NODE(&d->node);
Weston Andros Adamson9e3bd4e2011-05-31 21:46:50 -0400252 INIT_HLIST_NODE(&d->tmpnode);
Christoph Hellwig661373b2014-09-02 21:27:57 -0700253 d->ld = server->pnfs_curr_ld;
254 d->nfs_client = server->nfs_client;
Andy Adamsonc47abcf2011-06-15 17:52:40 -0400255 d->flags = 0;
Benny Halevya1eaecb2011-05-19 22:14:47 -0400256 d->deviceid = *id;
Benny Halevy1775bc32011-05-20 13:47:33 +0200257 atomic_set(&d->ref, 1);
Benny Halevya1eaecb2011-05-19 22:14:47 -0400258}
259EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node);
260
261/*
Benny Halevya1eaecb2011-05-19 22:14:47 -0400262 * Dereference a deviceid node and delete it when its reference count drops
263 * to zero.
264 *
265 * @d deviceid node to put
266 *
Trond Myklebust47cb4982011-06-14 12:18:11 -0400267 * return true iff the node was deleted
268 * Note that since the test for d->ref == 0 is sufficient to establish
269 * that the node is no longer hashed in the global device id cache.
Benny Halevya1eaecb2011-05-19 22:14:47 -0400270 */
271bool
272nfs4_put_deviceid_node(struct nfs4_deviceid_node *d)
273{
Trond Myklebust47cb4982011-06-14 12:18:11 -0400274 if (!atomic_dec_and_test(&d->ref))
Benny Halevya1eaecb2011-05-19 22:14:47 -0400275 return false;
Benny Halevy1775bc32011-05-20 13:47:33 +0200276 d->ld->free_deviceid_node(d);
Benny Halevya1eaecb2011-05-19 22:14:47 -0400277 return true;
278}
279EXPORT_SYMBOL_GPL(nfs4_put_deviceid_node);
Benny Halevy1775bc32011-05-20 13:47:33 +0200280
Trond Myklebust1dfed272012-09-18 19:51:12 -0400281void
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
Benny Halevy1775bc32011-05-20 13:47:33 +0200305static void
306_deviceid_purge_client(const struct nfs_client *clp, long hash)
307{
308 struct nfs4_deviceid_node *d;
Benny Halevy1775bc32011-05-20 13:47:33 +0200309 HLIST_HEAD(tmp);
310
Weston Andros Adamson9e3bd4e2011-05-31 21:46:50 -0400311 spin_lock(&nfs4_deviceid_lock);
Benny Halevy1775bc32011-05-20 13:47:33 +0200312 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800313 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node)
Benny Halevy1775bc32011-05-20 13:47:33 +0200314 if (d->nfs_client == clp && atomic_read(&d->ref)) {
315 hlist_del_init_rcu(&d->node);
Weston Andros Adamson9e3bd4e2011-05-31 21:46:50 -0400316 hlist_add_head(&d->tmpnode, &tmp);
Benny Halevy1775bc32011-05-20 13:47:33 +0200317 }
318 rcu_read_unlock();
Weston Andros Adamson9e3bd4e2011-05-31 21:46:50 -0400319 spin_unlock(&nfs4_deviceid_lock);
Benny Halevy1775bc32011-05-20 13:47:33 +0200320
321 if (hlist_empty(&tmp))
322 return;
323
324 synchronize_rcu();
Weston Andros Adamson9e3bd4e2011-05-31 21:46:50 -0400325 while (!hlist_empty(&tmp)) {
326 d = hlist_entry(tmp.first, struct nfs4_deviceid_node, tmpnode);
327 hlist_del(&d->tmpnode);
Benny Halevy1775bc32011-05-20 13:47:33 +0200328 if (atomic_dec_and_test(&d->ref))
329 d->ld->free_deviceid_node(d);
Weston Andros Adamson9e3bd4e2011-05-31 21:46:50 -0400330 }
Benny Halevy1775bc32011-05-20 13:47:33 +0200331}
332
333void
334nfs4_deviceid_purge_client(const struct nfs_client *clp)
335{
336 long h;
337
Weston Andros Adamson9e3bd4e2011-05-31 21:46:50 -0400338 if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_MDS))
339 return;
Benny Halevy1775bc32011-05-20 13:47:33 +0200340 for (h = 0; h < NFS4_DEVICE_ID_HASH_SIZE; h++)
341 _deviceid_purge_client(clp, h);
Benny Halevy1775bc32011-05-20 13:47:33 +0200342}
Andy Adamsonc47abcf2011-06-15 17:52:40 -0400343
344/*
345 * Stop use of all deviceids associated with an nfs_client
346 */
347void
348nfs4_deviceid_mark_client_invalid(struct nfs_client *clp)
349{
350 struct nfs4_deviceid_node *d;
Andy Adamsonc47abcf2011-06-15 17:52:40 -0400351 int i;
352
353 rcu_read_lock();
354 for (i = 0; i < NFS4_DEVICE_ID_HASH_SIZE; i ++){
Sasha Levinb67bfe02013-02-27 17:06:00 -0800355 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[i], node)
Andy Adamsonc47abcf2011-06-15 17:52:40 -0400356 if (d->nfs_client == clp)
357 set_bit(NFS_DEVICEID_INVALID, &d->flags);
358 }
359 rcu_read_unlock();
360}