~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/pnfs_dev.c

Version: ~ [ linux-5.7-rc7 ] ~ [ linux-5.6.14 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.42 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.124 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.181 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.224 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.224 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.84 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 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  * 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 
 46 #define PNFS_DEVICE_RETRY_TIMEOUT (120*HZ)
 47 
 48 static struct hlist_head nfs4_deviceid_cache[NFS4_DEVICE_ID_HASH_SIZE];
 49 static DEFINE_SPINLOCK(nfs4_deviceid_lock);
 50 
 51 #ifdef NFS_DEBUG
 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);
 61 #endif
 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 
 77 static 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 
 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);
152         if (d && pdev->nocache)
153                 set_bit(NFS_DEVICEID_NOCACHE, &d->flags);
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 
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  */
171 static struct nfs4_deviceid_node *
172 __nfs4_find_get_deviceid(struct nfs_server *server,
173                 const struct nfs4_deviceid *id, long hash)
174 {
175         struct nfs4_deviceid_node *d;
176 
177         rcu_read_lock();
178         d = _lookup_deviceid(server->pnfs_curr_ld, server->nfs_client, id,
179                         hash);
180         if (d != NULL && !atomic_inc_not_zero(&d->ref))
181                 d = NULL;
182         rcu_read_unlock();
183         return d;
184 }
185 
186 struct nfs4_deviceid_node *
187 nfs4_find_get_deviceid(struct nfs_server *server,
188                 const struct nfs4_deviceid *id, struct rpc_cred *cred,
189                 gfp_t gfp_mask)
190 {
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;
214 }
215 EXPORT_SYMBOL_GPL(nfs4_find_get_deviceid);
216 
217 /*
218  * Remove a deviceid from cache
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  */
225 void
226 nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld,
227                          const struct nfs_client *clp, const struct nfs4_deviceid *id)
228 {
229         struct nfs4_deviceid_node *d;
230 
231         spin_lock(&nfs4_deviceid_lock);
232         rcu_read_lock();
233         d = _lookup_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
234         rcu_read_unlock();
235         if (!d) {
236                 spin_unlock(&nfs4_deviceid_lock);
237                 return;
238         }
239         hlist_del_init_rcu(&d->node);
240         clear_bit(NFS_DEVICEID_NOCACHE, &d->flags);
241         spin_unlock(&nfs4_deviceid_lock);
242 
243         /* balance the initial ref set in pnfs_insert_deviceid */
244         nfs4_put_deviceid_node(d);
245 }
246 EXPORT_SYMBOL_GPL(nfs4_delete_deviceid);
247 
248 void
249 nfs4_init_deviceid_node(struct nfs4_deviceid_node *d, struct nfs_server *server,
250                         const struct nfs4_deviceid *id)
251 {
252         INIT_HLIST_NODE(&d->node);
253         INIT_HLIST_NODE(&d->tmpnode);
254         d->ld = server->pnfs_curr_ld;
255         d->nfs_client = server->nfs_client;
256         d->flags = 0;
257         d->deviceid = *id;
258         atomic_set(&d->ref, 1);
259 }
260 EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node);
261 
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  *
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.
271  */
272 bool
273 nfs4_put_deviceid_node(struct nfs4_deviceid_node *d)
274 {
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         }
280         if (!atomic_dec_and_test(&d->ref))
281                 return false;
282         d->ld->free_deviceid_node(d);
283         return true;
284 }
285 EXPORT_SYMBOL_GPL(nfs4_put_deviceid_node);
286 
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 
311 static void
312 _deviceid_purge_client(const struct nfs_client *clp, long hash)
313 {
314         struct nfs4_deviceid_node *d;
315         HLIST_HEAD(tmp);
316 
317         spin_lock(&nfs4_deviceid_lock);
318         rcu_read_lock();
319         hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node)
320                 if (d->nfs_client == clp && atomic_read(&d->ref)) {
321                         hlist_del_init_rcu(&d->node);
322                         hlist_add_head(&d->tmpnode, &tmp);
323                         clear_bit(NFS_DEVICEID_NOCACHE, &d->flags);
324                 }
325         rcu_read_unlock();
326         spin_unlock(&nfs4_deviceid_lock);
327 
328         if (hlist_empty(&tmp))
329                 return;
330 
331         while (!hlist_empty(&tmp)) {
332                 d = hlist_entry(tmp.first, struct nfs4_deviceid_node, tmpnode);
333                 hlist_del(&d->tmpnode);
334                 nfs4_put_deviceid_node(d);
335         }
336 }
337 
338 void
339 nfs4_deviceid_purge_client(const struct nfs_client *clp)
340 {
341         long h;
342 
343         if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_MDS))
344                 return;
345         for (h = 0; h < NFS4_DEVICE_ID_HASH_SIZE; h++)
346                 _deviceid_purge_client(clp, h);
347 }
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;
356         int i;
357 
358         rcu_read_lock();
359         for (i = 0; i < NFS4_DEVICE_ID_HASH_SIZE; i ++){
360                 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[i], node)
361                         if (d->nfs_client == clp)
362                                 set_bit(NFS_DEVICEID_INVALID, &d->flags);
363         }
364         rcu_read_unlock();
365 }
366 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp