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 "pnfs.h"
33 
34 #define NFSDBG_FACILITY		NFSDBG_PNFS
35 
36 /*
37  * Device ID RCU cache. A device ID is unique per server and layout type.
38  */
39 #define NFS4_DEVICE_ID_HASH_BITS	5
40 #define NFS4_DEVICE_ID_HASH_SIZE	(1 << NFS4_DEVICE_ID_HASH_BITS)
41 #define NFS4_DEVICE_ID_HASH_MASK	(NFS4_DEVICE_ID_HASH_SIZE - 1)
42 
43 static struct hlist_head nfs4_deviceid_cache[NFS4_DEVICE_ID_HASH_SIZE];
44 static DEFINE_SPINLOCK(nfs4_deviceid_lock);
45 
46 #ifdef NFS_DEBUG
47 void
nfs4_print_deviceid(const struct nfs4_deviceid * id)48 nfs4_print_deviceid(const struct nfs4_deviceid *id)
49 {
50 	u32 *p = (u32 *)id;
51 
52 	dprintk("%s: device id= [%x%x%x%x]\n", __func__,
53 		p[0], p[1], p[2], p[3]);
54 }
55 EXPORT_SYMBOL_GPL(nfs4_print_deviceid);
56 #endif
57 
58 static inline u32
nfs4_deviceid_hash(const struct nfs4_deviceid * id)59 nfs4_deviceid_hash(const struct nfs4_deviceid *id)
60 {
61 	unsigned char *cptr = (unsigned char *)id->data;
62 	unsigned int nbytes = NFS4_DEVICEID4_SIZE;
63 	u32 x = 0;
64 
65 	while (nbytes--) {
66 		x *= 37;
67 		x += *cptr++;
68 	}
69 	return x & NFS4_DEVICE_ID_HASH_MASK;
70 }
71 
72 static struct nfs4_deviceid_node *
_lookup_deviceid(const struct pnfs_layoutdriver_type * ld,const struct nfs_client * clp,const struct nfs4_deviceid * id,long hash)73 _lookup_deviceid(const struct pnfs_layoutdriver_type *ld,
74 		 const struct nfs_client *clp, const struct nfs4_deviceid *id,
75 		 long hash)
76 {
77 	struct nfs4_deviceid_node *d;
78 	struct hlist_node *n;
79 
80 	hlist_for_each_entry_rcu(d, n, &nfs4_deviceid_cache[hash], node)
81 		if (d->ld == ld && d->nfs_client == clp &&
82 		    !memcmp(&d->deviceid, id, sizeof(*id))) {
83 			if (atomic_read(&d->ref))
84 				return d;
85 			else
86 				continue;
87 		}
88 	return NULL;
89 }
90 
91 /*
92  * Lookup a deviceid in cache and get a reference count on it if found
93  *
94  * @clp nfs_client associated with deviceid
95  * @id deviceid to look up
96  */
97 static struct nfs4_deviceid_node *
_find_get_deviceid(const struct pnfs_layoutdriver_type * ld,const struct nfs_client * clp,const struct nfs4_deviceid * id,long hash)98 _find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
99 		   const struct nfs_client *clp, const struct nfs4_deviceid *id,
100 		   long hash)
101 {
102 	struct nfs4_deviceid_node *d;
103 
104 	rcu_read_lock();
105 	d = _lookup_deviceid(ld, clp, id, hash);
106 	if (d != NULL)
107 		atomic_inc(&d->ref);
108 	rcu_read_unlock();
109 	return d;
110 }
111 
112 struct nfs4_deviceid_node *
nfs4_find_get_deviceid(const struct pnfs_layoutdriver_type * ld,const struct nfs_client * clp,const struct nfs4_deviceid * id)113 nfs4_find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
114 		       const struct nfs_client *clp, const struct nfs4_deviceid *id)
115 {
116 	return _find_get_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
117 }
118 EXPORT_SYMBOL_GPL(nfs4_find_get_deviceid);
119 
120 /*
121  * Remove a deviceid from cache
122  *
123  * @clp nfs_client associated with deviceid
124  * @id the deviceid to unhash
125  *
126  * @ret the unhashed node, if found and dereferenced to zero, NULL otherwise.
127  */
128 void
nfs4_delete_deviceid(const struct pnfs_layoutdriver_type * ld,const struct nfs_client * clp,const struct nfs4_deviceid * id)129 nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld,
130 			 const struct nfs_client *clp, const struct nfs4_deviceid *id)
131 {
132 	struct nfs4_deviceid_node *d;
133 
134 	spin_lock(&nfs4_deviceid_lock);
135 	rcu_read_lock();
136 	d = _lookup_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
137 	rcu_read_unlock();
138 	if (!d) {
139 		spin_unlock(&nfs4_deviceid_lock);
140 		return;
141 	}
142 	hlist_del_init_rcu(&d->node);
143 	spin_unlock(&nfs4_deviceid_lock);
144 	synchronize_rcu();
145 
146 	/* balance the initial ref set in pnfs_insert_deviceid */
147 	if (atomic_dec_and_test(&d->ref))
148 		d->ld->free_deviceid_node(d);
149 }
150 EXPORT_SYMBOL_GPL(nfs4_delete_deviceid);
151 
152 void
nfs4_init_deviceid_node(struct nfs4_deviceid_node * d,const struct pnfs_layoutdriver_type * ld,const struct nfs_client * nfs_client,const struct nfs4_deviceid * id)153 nfs4_init_deviceid_node(struct nfs4_deviceid_node *d,
154 			const struct pnfs_layoutdriver_type *ld,
155 			const struct nfs_client *nfs_client,
156 			const struct nfs4_deviceid *id)
157 {
158 	INIT_HLIST_NODE(&d->node);
159 	INIT_HLIST_NODE(&d->tmpnode);
160 	d->ld = ld;
161 	d->nfs_client = nfs_client;
162 	d->flags = 0;
163 	d->deviceid = *id;
164 	atomic_set(&d->ref, 1);
165 }
166 EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node);
167 
168 /*
169  * Uniquely initialize and insert a deviceid node into cache
170  *
171  * @new new deviceid node
172  *      Note that the caller must set up the following members:
173  *        new->ld
174  *        new->nfs_client
175  *        new->deviceid
176  *
177  * @ret the inserted node, if none found, otherwise, the found entry.
178  */
179 struct nfs4_deviceid_node *
nfs4_insert_deviceid_node(struct nfs4_deviceid_node * new)180 nfs4_insert_deviceid_node(struct nfs4_deviceid_node *new)
181 {
182 	struct nfs4_deviceid_node *d;
183 	long hash;
184 
185 	spin_lock(&nfs4_deviceid_lock);
186 	hash = nfs4_deviceid_hash(&new->deviceid);
187 	d = _find_get_deviceid(new->ld, new->nfs_client, &new->deviceid, hash);
188 	if (d) {
189 		spin_unlock(&nfs4_deviceid_lock);
190 		return d;
191 	}
192 
193 	hlist_add_head_rcu(&new->node, &nfs4_deviceid_cache[hash]);
194 	spin_unlock(&nfs4_deviceid_lock);
195 	atomic_inc(&new->ref);
196 
197 	return new;
198 }
199 EXPORT_SYMBOL_GPL(nfs4_insert_deviceid_node);
200 
201 /*
202  * Dereference a deviceid node and delete it when its reference count drops
203  * to zero.
204  *
205  * @d deviceid node to put
206  *
207  * return true iff the node was deleted
208  * Note that since the test for d->ref == 0 is sufficient to establish
209  * that the node is no longer hashed in the global device id cache.
210  */
211 bool
nfs4_put_deviceid_node(struct nfs4_deviceid_node * d)212 nfs4_put_deviceid_node(struct nfs4_deviceid_node *d)
213 {
214 	if (!atomic_dec_and_test(&d->ref))
215 		return false;
216 	d->ld->free_deviceid_node(d);
217 	return true;
218 }
219 EXPORT_SYMBOL_GPL(nfs4_put_deviceid_node);
220 
221 static void
_deviceid_purge_client(const struct nfs_client * clp,long hash)222 _deviceid_purge_client(const struct nfs_client *clp, long hash)
223 {
224 	struct nfs4_deviceid_node *d;
225 	struct hlist_node *n;
226 	HLIST_HEAD(tmp);
227 
228 	spin_lock(&nfs4_deviceid_lock);
229 	rcu_read_lock();
230 	hlist_for_each_entry_rcu(d, n, &nfs4_deviceid_cache[hash], node)
231 		if (d->nfs_client == clp && atomic_read(&d->ref)) {
232 			hlist_del_init_rcu(&d->node);
233 			hlist_add_head(&d->tmpnode, &tmp);
234 		}
235 	rcu_read_unlock();
236 	spin_unlock(&nfs4_deviceid_lock);
237 
238 	if (hlist_empty(&tmp))
239 		return;
240 
241 	synchronize_rcu();
242 	while (!hlist_empty(&tmp)) {
243 		d = hlist_entry(tmp.first, struct nfs4_deviceid_node, tmpnode);
244 		hlist_del(&d->tmpnode);
245 		if (atomic_dec_and_test(&d->ref))
246 			d->ld->free_deviceid_node(d);
247 	}
248 }
249 
250 void
nfs4_deviceid_purge_client(const struct nfs_client * clp)251 nfs4_deviceid_purge_client(const struct nfs_client *clp)
252 {
253 	long h;
254 
255 	if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_MDS))
256 		return;
257 	for (h = 0; h < NFS4_DEVICE_ID_HASH_SIZE; h++)
258 		_deviceid_purge_client(clp, h);
259 }
260 
261 /*
262  * Stop use of all deviceids associated with an nfs_client
263  */
264 void
nfs4_deviceid_mark_client_invalid(struct nfs_client * clp)265 nfs4_deviceid_mark_client_invalid(struct nfs_client *clp)
266 {
267 	struct nfs4_deviceid_node *d;
268 	struct hlist_node *n;
269 	int i;
270 
271 	rcu_read_lock();
272 	for (i = 0; i < NFS4_DEVICE_ID_HASH_SIZE; i ++){
273 		hlist_for_each_entry_rcu(d, n, &nfs4_deviceid_cache[i], node)
274 			if (d->nfs_client == clp)
275 				set_bit(NFS_DEVICEID_INVALID, &d->flags);
276 	}
277 	rcu_read_unlock();
278 }
279