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 "pnfs.h"
33
34#define NFSDBG_FACILITY NFSDBG_PNFS
35
36
37
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#define PNFS_DEVICE_RETRY_TIMEOUT (120*HZ)
44
45static struct hlist_head nfs4_deviceid_cache[NFS4_DEVICE_ID_HASH_SIZE];
46static DEFINE_SPINLOCK(nfs4_deviceid_lock);
47
48#ifdef NFS_DEBUG
49void
50nfs4_print_deviceid(const struct nfs4_deviceid *id)
51{
52 u32 *p = (u32 *)id;
53
54 dprintk("%s: device id= [%x%x%x%x]\n", __func__,
55 p[0], p[1], p[2], p[3]);
56}
57EXPORT_SYMBOL_GPL(nfs4_print_deviceid);
58#endif
59
60static inline u32
61nfs4_deviceid_hash(const struct nfs4_deviceid *id)
62{
63 unsigned char *cptr = (unsigned char *)id->data;
64 unsigned int nbytes = NFS4_DEVICEID4_SIZE;
65 u32 x = 0;
66
67 while (nbytes--) {
68 x *= 37;
69 x += *cptr++;
70 }
71 return x & NFS4_DEVICE_ID_HASH_MASK;
72}
73
74static struct nfs4_deviceid_node *
75_lookup_deviceid(const struct pnfs_layoutdriver_type *ld,
76 const struct nfs_client *clp, const struct nfs4_deviceid *id,
77 long hash)
78{
79 struct nfs4_deviceid_node *d;
80
81 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node)
82 if (d->ld == ld && d->nfs_client == clp &&
83 !memcmp(&d->deviceid, id, sizeof(*id))) {
84 if (atomic_read(&d->ref))
85 return d;
86 else
87 continue;
88 }
89 return NULL;
90}
91
92
93
94
95
96
97
98static struct nfs4_deviceid_node *
99_find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
100 const struct nfs_client *clp, const struct nfs4_deviceid *id,
101 long hash)
102{
103 struct nfs4_deviceid_node *d;
104
105 rcu_read_lock();
106 d = _lookup_deviceid(ld, clp, id, hash);
107 if (d != NULL)
108 atomic_inc(&d->ref);
109 rcu_read_unlock();
110 return d;
111}
112
113struct nfs4_deviceid_node *
114nfs4_find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
115 const struct nfs_client *clp, const struct nfs4_deviceid *id)
116{
117 return _find_get_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
118}
119EXPORT_SYMBOL_GPL(nfs4_find_get_deviceid);
120
121
122
123
124
125
126
127
128
129void
130nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld,
131 const struct nfs_client *clp, const struct nfs4_deviceid *id)
132{
133 struct nfs4_deviceid_node *d;
134
135 spin_lock(&nfs4_deviceid_lock);
136 rcu_read_lock();
137 d = _lookup_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
138 rcu_read_unlock();
139 if (!d) {
140 spin_unlock(&nfs4_deviceid_lock);
141 return;
142 }
143 hlist_del_init_rcu(&d->node);
144 spin_unlock(&nfs4_deviceid_lock);
145 synchronize_rcu();
146
147
148 if (atomic_dec_and_test(&d->ref))
149 d->ld->free_deviceid_node(d);
150}
151EXPORT_SYMBOL_GPL(nfs4_delete_deviceid);
152
153void
154nfs4_init_deviceid_node(struct nfs4_deviceid_node *d,
155 const struct pnfs_layoutdriver_type *ld,
156 const struct nfs_client *nfs_client,
157 const struct nfs4_deviceid *id)
158{
159 INIT_HLIST_NODE(&d->node);
160 INIT_HLIST_NODE(&d->tmpnode);
161 d->ld = ld;
162 d->nfs_client = nfs_client;
163 d->flags = 0;
164 d->deviceid = *id;
165 atomic_set(&d->ref, 1);
166}
167EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node);
168
169
170
171
172
173
174
175
176
177
178
179
180struct nfs4_deviceid_node *
181nfs4_insert_deviceid_node(struct nfs4_deviceid_node *new)
182{
183 struct nfs4_deviceid_node *d;
184 long hash;
185
186 spin_lock(&nfs4_deviceid_lock);
187 hash = nfs4_deviceid_hash(&new->deviceid);
188 d = _find_get_deviceid(new->ld, new->nfs_client, &new->deviceid, hash);
189 if (d) {
190 spin_unlock(&nfs4_deviceid_lock);
191 return d;
192 }
193
194 hlist_add_head_rcu(&new->node, &nfs4_deviceid_cache[hash]);
195 spin_unlock(&nfs4_deviceid_lock);
196 atomic_inc(&new->ref);
197
198 return new;
199}
200EXPORT_SYMBOL_GPL(nfs4_insert_deviceid_node);
201
202
203
204
205
206
207
208
209
210
211
212bool
213nfs4_put_deviceid_node(struct nfs4_deviceid_node *d)
214{
215 if (!atomic_dec_and_test(&d->ref))
216 return false;
217 d->ld->free_deviceid_node(d);
218 return true;
219}
220EXPORT_SYMBOL_GPL(nfs4_put_deviceid_node);
221
222void
223nfs4_mark_deviceid_unavailable(struct nfs4_deviceid_node *node)
224{
225 node->timestamp_unavailable = jiffies;
226 set_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags);
227}
228EXPORT_SYMBOL_GPL(nfs4_mark_deviceid_unavailable);
229
230bool
231nfs4_test_deviceid_unavailable(struct nfs4_deviceid_node *node)
232{
233 if (test_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags)) {
234 unsigned long start, end;
235
236 end = jiffies;
237 start = end - PNFS_DEVICE_RETRY_TIMEOUT;
238 if (time_in_range(node->timestamp_unavailable, start, end))
239 return true;
240 clear_bit(NFS_DEVICEID_UNAVAILABLE, &node->flags);
241 }
242 return false;
243}
244EXPORT_SYMBOL_GPL(nfs4_test_deviceid_unavailable);
245
246static void
247_deviceid_purge_client(const struct nfs_client *clp, long hash)
248{
249 struct nfs4_deviceid_node *d;
250 HLIST_HEAD(tmp);
251
252 spin_lock(&nfs4_deviceid_lock);
253 rcu_read_lock();
254 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[hash], node)
255 if (d->nfs_client == clp && atomic_read(&d->ref)) {
256 hlist_del_init_rcu(&d->node);
257 hlist_add_head(&d->tmpnode, &tmp);
258 }
259 rcu_read_unlock();
260 spin_unlock(&nfs4_deviceid_lock);
261
262 if (hlist_empty(&tmp))
263 return;
264
265 synchronize_rcu();
266 while (!hlist_empty(&tmp)) {
267 d = hlist_entry(tmp.first, struct nfs4_deviceid_node, tmpnode);
268 hlist_del(&d->tmpnode);
269 if (atomic_dec_and_test(&d->ref))
270 d->ld->free_deviceid_node(d);
271 }
272}
273
274void
275nfs4_deviceid_purge_client(const struct nfs_client *clp)
276{
277 long h;
278
279 if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_USE_PNFS_MDS))
280 return;
281 for (h = 0; h < NFS4_DEVICE_ID_HASH_SIZE; h++)
282 _deviceid_purge_client(clp, h);
283}
284
285
286
287
288void
289nfs4_deviceid_mark_client_invalid(struct nfs_client *clp)
290{
291 struct nfs4_deviceid_node *d;
292 int i;
293
294 rcu_read_lock();
295 for (i = 0; i < NFS4_DEVICE_ID_HASH_SIZE; i ++){
296 hlist_for_each_entry_rcu(d, &nfs4_deviceid_cache[i], node)
297 if (d->nfs_client == clp)
298 set_bit(NFS_DEVICEID_INVALID, &d->flags);
299 }
300 rcu_read_unlock();
301}
302
303