Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* AFS volume management
3 *
4 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/kernel.h>
9#include <linux/slab.h>
10#include "internal.h"
11
12static unsigned __read_mostly afs_volume_record_life = 60 * 60;
13
14static void afs_destroy_volume(struct work_struct *work);
15
16/*
17 * Insert a volume into a cell. If there's an existing volume record, that is
18 * returned instead with a ref held.
19 */
20static struct afs_volume *afs_insert_volume_into_cell(struct afs_cell *cell,
21 struct afs_volume *volume)
22{
23 struct afs_volume *p;
24 struct rb_node *parent = NULL, **pp;
25
26 write_seqlock(&cell->volume_lock);
27
28 pp = &cell->volumes.rb_node;
29 while (*pp) {
30 parent = *pp;
31 p = rb_entry(parent, struct afs_volume, cell_node);
32 if (p->vid < volume->vid) {
33 pp = &(*pp)->rb_left;
34 } else if (p->vid > volume->vid) {
35 pp = &(*pp)->rb_right;
36 } else {
37 if (afs_try_get_volume(p, afs_volume_trace_get_cell_insert)) {
38 volume = p;
39 goto found;
40 }
41
42 set_bit(AFS_VOLUME_RM_TREE, &volume->flags);
43 rb_replace_node_rcu(&p->cell_node, &volume->cell_node, &cell->volumes);
44 }
45 }
46
47 rb_link_node_rcu(&volume->cell_node, parent, pp);
48 rb_insert_color(&volume->cell_node, &cell->volumes);
49 hlist_add_head_rcu(&volume->proc_link, &cell->proc_volumes);
50
51found:
52 write_sequnlock(&cell->volume_lock);
53 return volume;
54
55}
56
57static void afs_remove_volume_from_cell(struct afs_volume *volume)
58{
59 struct afs_cell *cell = volume->cell;
60
61 if (!hlist_unhashed(&volume->proc_link)) {
62 trace_afs_volume(volume->vid, refcount_read(&cell->ref),
63 afs_volume_trace_remove);
64 write_seqlock(&cell->volume_lock);
65 hlist_del_rcu(&volume->proc_link);
66 if (!test_and_set_bit(AFS_VOLUME_RM_TREE, &volume->flags))
67 rb_erase(&volume->cell_node, &cell->volumes);
68 write_sequnlock(&cell->volume_lock);
69 }
70}
71
72/*
73 * Allocate a volume record and load it up from a vldb record.
74 */
75static struct afs_volume *afs_alloc_volume(struct afs_fs_context *params,
76 struct afs_vldb_entry *vldb,
77 struct afs_server_list **_slist)
78{
79 struct afs_server_list *slist;
80 struct afs_volume *volume;
81 int ret = -ENOMEM, i;
82
83 volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL);
84 if (!volume)
85 goto error_0;
86
87 volume->vid = vldb->vid[params->type];
88 volume->update_at = ktime_get_real_seconds() + afs_volume_record_life;
89 volume->cell = afs_get_cell(params->cell, afs_cell_trace_get_vol);
90 volume->type = params->type;
91 volume->type_force = params->force;
92 volume->name_len = vldb->name_len;
93 volume->creation_time = TIME64_MIN;
94 volume->update_time = TIME64_MIN;
95
96 refcount_set(&volume->ref, 1);
97 INIT_HLIST_NODE(&volume->proc_link);
98 INIT_WORK(&volume->destructor, afs_destroy_volume);
99 rwlock_init(&volume->servers_lock);
100 mutex_init(&volume->volsync_lock);
101 mutex_init(&volume->cb_check_lock);
102 rwlock_init(&volume->cb_v_break_lock);
103 INIT_LIST_HEAD(&volume->open_mmaps);
104 init_rwsem(&volume->open_mmaps_lock);
105 memcpy(volume->name, vldb->name, vldb->name_len + 1);
106
107 for (i = 0; i < AFS_MAXTYPES; i++)
108 volume->vids[i] = vldb->vid[i];
109
110 slist = afs_alloc_server_list(volume, params->key, vldb);
111 if (IS_ERR(slist)) {
112 ret = PTR_ERR(slist);
113 goto error_1;
114 }
115
116 *_slist = slist;
117 rcu_assign_pointer(volume->servers, slist);
118 trace_afs_volume(volume->vid, 1, afs_volume_trace_alloc);
119 return volume;
120
121error_1:
122 afs_put_cell(volume->cell, afs_cell_trace_put_vol);
123 kfree(volume);
124error_0:
125 return ERR_PTR(ret);
126}
127
128/*
129 * Look up or allocate a volume record.
130 */
131static struct afs_volume *afs_lookup_volume(struct afs_fs_context *params,
132 struct afs_vldb_entry *vldb)
133{
134 struct afs_server_list *slist;
135 struct afs_volume *candidate, *volume;
136
137 candidate = afs_alloc_volume(params, vldb, &slist);
138 if (IS_ERR(candidate))
139 return candidate;
140
141 volume = afs_insert_volume_into_cell(params->cell, candidate);
142 if (volume == candidate)
143 afs_attach_volume_to_servers(volume, slist);
144 else
145 afs_put_volume(candidate, afs_volume_trace_put_cell_dup);
146 return volume;
147}
148
149/*
150 * Look up a VLDB record for a volume.
151 */
152static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell,
153 struct key *key,
154 const char *volname,
155 size_t volnamesz)
156{
157 struct afs_vldb_entry *vldb = ERR_PTR(-EDESTADDRREQ);
158 struct afs_vl_cursor vc;
159 int ret;
160
161 if (!afs_begin_vlserver_operation(&vc, cell, key))
162 return ERR_PTR(-ERESTARTSYS);
163
164 while (afs_select_vlserver(&vc)) {
165 vldb = afs_vl_get_entry_by_name_u(&vc, volname, volnamesz);
166 }
167
168 ret = afs_end_vlserver_operation(&vc);
169 return ret < 0 ? ERR_PTR(ret) : vldb;
170}
171
172/*
173 * Look up a volume in the VL server and create a candidate volume record for
174 * it.
175 *
176 * The volume name can be one of the following:
177 * "%[cell:]volume[.]" R/W volume
178 * "#[cell:]volume[.]" R/O or R/W volume (rwparent=0),
179 * or R/W (rwparent=1) volume
180 * "%[cell:]volume.readonly" R/O volume
181 * "#[cell:]volume.readonly" R/O volume
182 * "%[cell:]volume.backup" Backup volume
183 * "#[cell:]volume.backup" Backup volume
184 *
185 * The cell name is optional, and defaults to the current cell.
186 *
187 * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin
188 * Guide
189 * - Rule 1: Explicit type suffix forces access of that type or nothing
190 * (no suffix, then use Rule 2 & 3)
191 * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W
192 * if not available
193 * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
194 * explicitly told otherwise
195 */
196struct afs_volume *afs_create_volume(struct afs_fs_context *params)
197{
198 struct afs_vldb_entry *vldb;
199 struct afs_volume *volume;
200 unsigned long type_mask = 1UL << params->type;
201
202 vldb = afs_vl_lookup_vldb(params->cell, params->key,
203 params->volname, params->volnamesz);
204 if (IS_ERR(vldb))
205 return ERR_CAST(vldb);
206
207 if (test_bit(AFS_VLDB_QUERY_ERROR, &vldb->flags)) {
208 volume = ERR_PTR(vldb->error);
209 goto error;
210 }
211
212 /* Make the final decision on the type we want */
213 volume = ERR_PTR(-ENOMEDIUM);
214 if (params->force) {
215 if (!(vldb->flags & type_mask))
216 goto error;
217 } else if (test_bit(AFS_VLDB_HAS_RO, &vldb->flags)) {
218 params->type = AFSVL_ROVOL;
219 } else if (test_bit(AFS_VLDB_HAS_RW, &vldb->flags)) {
220 params->type = AFSVL_RWVOL;
221 } else {
222 goto error;
223 }
224
225 volume = afs_lookup_volume(params, vldb);
226
227error:
228 kfree(vldb);
229 return volume;
230}
231
232/*
233 * Destroy a volume record
234 */
235static void afs_destroy_volume(struct work_struct *work)
236{
237 struct afs_volume *volume = container_of(work, struct afs_volume, destructor);
238 struct afs_server_list *slist = rcu_access_pointer(volume->servers);
239
240 _enter("%p", volume);
241
242#ifdef CONFIG_AFS_FSCACHE
243 ASSERTCMP(volume->cache, ==, NULL);
244#endif
245
246 afs_detach_volume_from_servers(volume, slist);
247 afs_remove_volume_from_cell(volume);
248 afs_put_serverlist(volume->cell->net, slist);
249 afs_put_cell(volume->cell, afs_cell_trace_put_vol);
250 trace_afs_volume(volume->vid, refcount_read(&volume->ref),
251 afs_volume_trace_free);
252 kfree_rcu(volume, rcu);
253
254 _leave(" [destroyed]");
255}
256
257/*
258 * Try to get a reference on a volume record.
259 */
260bool afs_try_get_volume(struct afs_volume *volume, enum afs_volume_trace reason)
261{
262 int r;
263
264 if (__refcount_inc_not_zero(&volume->ref, &r)) {
265 trace_afs_volume(volume->vid, r + 1, reason);
266 return true;
267 }
268 return false;
269}
270
271/*
272 * Get a reference on a volume record.
273 */
274struct afs_volume *afs_get_volume(struct afs_volume *volume,
275 enum afs_volume_trace reason)
276{
277 if (volume) {
278 int r;
279
280 __refcount_inc(&volume->ref, &r);
281 trace_afs_volume(volume->vid, r + 1, reason);
282 }
283 return volume;
284}
285
286
287/*
288 * Drop a reference on a volume record.
289 */
290void afs_put_volume(struct afs_volume *volume, enum afs_volume_trace reason)
291{
292 if (volume) {
293 afs_volid_t vid = volume->vid;
294 bool zero;
295 int r;
296
297 zero = __refcount_dec_and_test(&volume->ref, &r);
298 trace_afs_volume(vid, r - 1, reason);
299 if (zero)
300 schedule_work(&volume->destructor);
301 }
302}
303
304/*
305 * Activate a volume.
306 */
307int afs_activate_volume(struct afs_volume *volume)
308{
309#ifdef CONFIG_AFS_FSCACHE
310 struct fscache_volume *vcookie;
311 char *name;
312
313 name = kasprintf(GFP_KERNEL, "afs,%s,%llx",
314 volume->cell->name, volume->vid);
315 if (!name)
316 return -ENOMEM;
317
318 vcookie = fscache_acquire_volume(name, NULL, NULL, 0);
319 if (IS_ERR(vcookie)) {
320 if (vcookie != ERR_PTR(-EBUSY)) {
321 kfree(name);
322 return PTR_ERR(vcookie);
323 }
324 pr_err("AFS: Cache volume key already in use (%s)\n", name);
325 vcookie = NULL;
326 }
327 volume->cache = vcookie;
328 kfree(name);
329#endif
330 return 0;
331}
332
333/*
334 * Deactivate a volume.
335 */
336void afs_deactivate_volume(struct afs_volume *volume)
337{
338 _enter("%s", volume->name);
339
340#ifdef CONFIG_AFS_FSCACHE
341 fscache_relinquish_volume(volume->cache, NULL,
342 test_bit(AFS_VOLUME_DELETED, &volume->flags));
343 volume->cache = NULL;
344#endif
345
346 _leave("");
347}
348
349/*
350 * Query the VL service to update the volume status.
351 */
352static int afs_update_volume_status(struct afs_volume *volume, struct key *key)
353{
354 struct afs_server_list *new, *old, *discard;
355 struct afs_vldb_entry *vldb;
356 char idbuf[24];
357 int ret, idsz;
358
359 _enter("");
360
361 /* We look up an ID by passing it as a decimal string in the
362 * operation's name parameter.
363 */
364 idsz = snprintf(idbuf, sizeof(idbuf), "%llu", volume->vid);
365
366 vldb = afs_vl_lookup_vldb(volume->cell, key, idbuf, idsz);
367 if (IS_ERR(vldb)) {
368 ret = PTR_ERR(vldb);
369 goto error;
370 }
371
372 /* See if the volume got renamed. */
373 if (vldb->name_len != volume->name_len ||
374 memcmp(vldb->name, volume->name, vldb->name_len) != 0) {
375 /* TODO: Use RCU'd string. */
376 memcpy(volume->name, vldb->name, AFS_MAXVOLNAME);
377 volume->name_len = vldb->name_len;
378 }
379
380 /* See if the volume's server list got updated. */
381 new = afs_alloc_server_list(volume, key, vldb);
382 if (IS_ERR(new)) {
383 ret = PTR_ERR(new);
384 goto error_vldb;
385 }
386
387 write_lock(&volume->servers_lock);
388
389 discard = new;
390 old = rcu_dereference_protected(volume->servers,
391 lockdep_is_held(&volume->servers_lock));
392 if (afs_annotate_server_list(new, old)) {
393 new->seq = volume->servers_seq + 1;
394 rcu_assign_pointer(volume->servers, new);
395 smp_wmb();
396 volume->servers_seq++;
397 discard = old;
398 }
399
400 /* Check more often if replication is ongoing. */
401 if (new->ro_replicating)
402 volume->update_at = ktime_get_real_seconds() + 10 * 60;
403 else
404 volume->update_at = ktime_get_real_seconds() + afs_volume_record_life;
405 write_unlock(&volume->servers_lock);
406
407 if (discard == old)
408 afs_reattach_volume_to_servers(volume, new, old);
409 afs_put_serverlist(volume->cell->net, discard);
410 ret = 0;
411error_vldb:
412 kfree(vldb);
413error:
414 _leave(" = %d", ret);
415 return ret;
416}
417
418/*
419 * Make sure the volume record is up to date.
420 */
421int afs_check_volume_status(struct afs_volume *volume, struct afs_operation *op)
422{
423 int ret, retries = 0;
424
425 _enter("");
426
427retry:
428 if (test_bit(AFS_VOLUME_WAIT, &volume->flags))
429 goto wait;
430 if (volume->update_at <= ktime_get_real_seconds() ||
431 test_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags))
432 goto update;
433 _leave(" = 0");
434 return 0;
435
436update:
437 if (!test_and_set_bit_lock(AFS_VOLUME_UPDATING, &volume->flags)) {
438 clear_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);
439 ret = afs_update_volume_status(volume, op->key);
440 if (ret < 0)
441 set_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);
442 clear_bit_unlock(AFS_VOLUME_WAIT, &volume->flags);
443 clear_bit_unlock(AFS_VOLUME_UPDATING, &volume->flags);
444 wake_up_bit(&volume->flags, AFS_VOLUME_WAIT);
445 _leave(" = %d", ret);
446 return ret;
447 }
448
449wait:
450 if (!test_bit(AFS_VOLUME_WAIT, &volume->flags)) {
451 _leave(" = 0 [no wait]");
452 return 0;
453 }
454
455 ret = wait_on_bit(&volume->flags, AFS_VOLUME_WAIT,
456 (op->flags & AFS_OPERATION_UNINTR) ?
457 TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE);
458 if (ret == -ERESTARTSYS) {
459 _leave(" = %d", ret);
460 return ret;
461 }
462
463 retries++;
464 if (retries == 4) {
465 _leave(" = -ESTALE");
466 return -ESTALE;
467 }
468 goto retry;
469}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* AFS volume management
3 *
4 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/kernel.h>
9#include <linux/slab.h>
10#include "internal.h"
11
12unsigned __read_mostly afs_volume_gc_delay = 10;
13unsigned __read_mostly afs_volume_record_life = 60 * 60;
14
15/*
16 * Insert a volume into a cell. If there's an existing volume record, that is
17 * returned instead with a ref held.
18 */
19static struct afs_volume *afs_insert_volume_into_cell(struct afs_cell *cell,
20 struct afs_volume *volume)
21{
22 struct afs_volume *p;
23 struct rb_node *parent = NULL, **pp;
24
25 write_seqlock(&cell->volume_lock);
26
27 pp = &cell->volumes.rb_node;
28 while (*pp) {
29 parent = *pp;
30 p = rb_entry(parent, struct afs_volume, cell_node);
31 if (p->vid < volume->vid) {
32 pp = &(*pp)->rb_left;
33 } else if (p->vid > volume->vid) {
34 pp = &(*pp)->rb_right;
35 } else {
36 volume = afs_get_volume(p, afs_volume_trace_get_cell_insert);
37 goto found;
38 }
39 }
40
41 rb_link_node_rcu(&volume->cell_node, parent, pp);
42 rb_insert_color(&volume->cell_node, &cell->volumes);
43 hlist_add_head_rcu(&volume->proc_link, &cell->proc_volumes);
44
45found:
46 write_sequnlock(&cell->volume_lock);
47 return volume;
48
49}
50
51static void afs_remove_volume_from_cell(struct afs_volume *volume)
52{
53 struct afs_cell *cell = volume->cell;
54
55 if (!hlist_unhashed(&volume->proc_link)) {
56 trace_afs_volume(volume->vid, atomic_read(&volume->usage),
57 afs_volume_trace_remove);
58 write_seqlock(&cell->volume_lock);
59 hlist_del_rcu(&volume->proc_link);
60 rb_erase(&volume->cell_node, &cell->volumes);
61 write_sequnlock(&cell->volume_lock);
62 }
63}
64
65/*
66 * Allocate a volume record and load it up from a vldb record.
67 */
68static struct afs_volume *afs_alloc_volume(struct afs_fs_context *params,
69 struct afs_vldb_entry *vldb,
70 unsigned long type_mask)
71{
72 struct afs_server_list *slist;
73 struct afs_volume *volume;
74 int ret = -ENOMEM, nr_servers = 0, i;
75
76 for (i = 0; i < vldb->nr_servers; i++)
77 if (vldb->fs_mask[i] & type_mask)
78 nr_servers++;
79
80 volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL);
81 if (!volume)
82 goto error_0;
83
84 volume->vid = vldb->vid[params->type];
85 volume->update_at = ktime_get_real_seconds() + afs_volume_record_life;
86 volume->cell = afs_get_cell(params->cell);
87 volume->type = params->type;
88 volume->type_force = params->force;
89 volume->name_len = vldb->name_len;
90
91 atomic_set(&volume->usage, 1);
92 INIT_HLIST_NODE(&volume->proc_link);
93 rwlock_init(&volume->servers_lock);
94 rwlock_init(&volume->cb_v_break_lock);
95 memcpy(volume->name, vldb->name, vldb->name_len + 1);
96
97 slist = afs_alloc_server_list(params->cell, params->key, vldb, type_mask);
98 if (IS_ERR(slist)) {
99 ret = PTR_ERR(slist);
100 goto error_1;
101 }
102
103 refcount_set(&slist->usage, 1);
104 rcu_assign_pointer(volume->servers, slist);
105 trace_afs_volume(volume->vid, 1, afs_volume_trace_alloc);
106 return volume;
107
108error_1:
109 afs_put_cell(params->net, volume->cell);
110 kfree(volume);
111error_0:
112 return ERR_PTR(ret);
113}
114
115/*
116 * Look up or allocate a volume record.
117 */
118static struct afs_volume *afs_lookup_volume(struct afs_fs_context *params,
119 struct afs_vldb_entry *vldb,
120 unsigned long type_mask)
121{
122 struct afs_volume *candidate, *volume;
123
124 candidate = afs_alloc_volume(params, vldb, type_mask);
125 if (IS_ERR(candidate))
126 return candidate;
127
128 volume = afs_insert_volume_into_cell(params->cell, candidate);
129 if (volume != candidate)
130 afs_put_volume(params->net, candidate, afs_volume_trace_put_cell_dup);
131 return volume;
132}
133
134/*
135 * Look up a VLDB record for a volume.
136 */
137static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell,
138 struct key *key,
139 const char *volname,
140 size_t volnamesz)
141{
142 struct afs_vldb_entry *vldb = ERR_PTR(-EDESTADDRREQ);
143 struct afs_vl_cursor vc;
144 int ret;
145
146 if (!afs_begin_vlserver_operation(&vc, cell, key))
147 return ERR_PTR(-ERESTARTSYS);
148
149 while (afs_select_vlserver(&vc)) {
150 vldb = afs_vl_get_entry_by_name_u(&vc, volname, volnamesz);
151 }
152
153 ret = afs_end_vlserver_operation(&vc);
154 return ret < 0 ? ERR_PTR(ret) : vldb;
155}
156
157/*
158 * Look up a volume in the VL server and create a candidate volume record for
159 * it.
160 *
161 * The volume name can be one of the following:
162 * "%[cell:]volume[.]" R/W volume
163 * "#[cell:]volume[.]" R/O or R/W volume (rwparent=0),
164 * or R/W (rwparent=1) volume
165 * "%[cell:]volume.readonly" R/O volume
166 * "#[cell:]volume.readonly" R/O volume
167 * "%[cell:]volume.backup" Backup volume
168 * "#[cell:]volume.backup" Backup volume
169 *
170 * The cell name is optional, and defaults to the current cell.
171 *
172 * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin
173 * Guide
174 * - Rule 1: Explicit type suffix forces access of that type or nothing
175 * (no suffix, then use Rule 2 & 3)
176 * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W
177 * if not available
178 * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
179 * explicitly told otherwise
180 */
181struct afs_volume *afs_create_volume(struct afs_fs_context *params)
182{
183 struct afs_vldb_entry *vldb;
184 struct afs_volume *volume;
185 unsigned long type_mask = 1UL << params->type;
186
187 vldb = afs_vl_lookup_vldb(params->cell, params->key,
188 params->volname, params->volnamesz);
189 if (IS_ERR(vldb))
190 return ERR_CAST(vldb);
191
192 if (test_bit(AFS_VLDB_QUERY_ERROR, &vldb->flags)) {
193 volume = ERR_PTR(vldb->error);
194 goto error;
195 }
196
197 /* Make the final decision on the type we want */
198 volume = ERR_PTR(-ENOMEDIUM);
199 if (params->force) {
200 if (!(vldb->flags & type_mask))
201 goto error;
202 } else if (test_bit(AFS_VLDB_HAS_RO, &vldb->flags)) {
203 params->type = AFSVL_ROVOL;
204 } else if (test_bit(AFS_VLDB_HAS_RW, &vldb->flags)) {
205 params->type = AFSVL_RWVOL;
206 } else {
207 goto error;
208 }
209
210 type_mask = 1UL << params->type;
211 volume = afs_lookup_volume(params, vldb, type_mask);
212
213error:
214 kfree(vldb);
215 return volume;
216}
217
218/*
219 * Destroy a volume record
220 */
221static void afs_destroy_volume(struct afs_net *net, struct afs_volume *volume)
222{
223 _enter("%p", volume);
224
225#ifdef CONFIG_AFS_FSCACHE
226 ASSERTCMP(volume->cache, ==, NULL);
227#endif
228
229 afs_remove_volume_from_cell(volume);
230 afs_put_serverlist(net, rcu_access_pointer(volume->servers));
231 afs_put_cell(net, volume->cell);
232 trace_afs_volume(volume->vid, atomic_read(&volume->usage),
233 afs_volume_trace_free);
234 kfree_rcu(volume, rcu);
235
236 _leave(" [destroyed]");
237}
238
239/*
240 * Get a reference on a volume record.
241 */
242struct afs_volume *afs_get_volume(struct afs_volume *volume,
243 enum afs_volume_trace reason)
244{
245 if (volume) {
246 int u = atomic_inc_return(&volume->usage);
247 trace_afs_volume(volume->vid, u, reason);
248 }
249 return volume;
250}
251
252
253/*
254 * Drop a reference on a volume record.
255 */
256void afs_put_volume(struct afs_net *net, struct afs_volume *volume,
257 enum afs_volume_trace reason)
258{
259 if (volume) {
260 afs_volid_t vid = volume->vid;
261 int u = atomic_dec_return(&volume->usage);
262 trace_afs_volume(vid, u, reason);
263 if (u == 0)
264 afs_destroy_volume(net, volume);
265 }
266}
267
268/*
269 * Activate a volume.
270 */
271void afs_activate_volume(struct afs_volume *volume)
272{
273#ifdef CONFIG_AFS_FSCACHE
274 volume->cache = fscache_acquire_cookie(volume->cell->cache,
275 &afs_volume_cache_index_def,
276 &volume->vid, sizeof(volume->vid),
277 NULL, 0,
278 volume, 0, true);
279#endif
280}
281
282/*
283 * Deactivate a volume.
284 */
285void afs_deactivate_volume(struct afs_volume *volume)
286{
287 _enter("%s", volume->name);
288
289#ifdef CONFIG_AFS_FSCACHE
290 fscache_relinquish_cookie(volume->cache, NULL,
291 test_bit(AFS_VOLUME_DELETED, &volume->flags));
292 volume->cache = NULL;
293#endif
294
295 _leave("");
296}
297
298/*
299 * Query the VL service to update the volume status.
300 */
301static int afs_update_volume_status(struct afs_volume *volume, struct key *key)
302{
303 struct afs_server_list *new, *old, *discard;
304 struct afs_vldb_entry *vldb;
305 char idbuf[16];
306 int ret, idsz;
307
308 _enter("");
309
310 /* We look up an ID by passing it as a decimal string in the
311 * operation's name parameter.
312 */
313 idsz = sprintf(idbuf, "%llu", volume->vid);
314
315 vldb = afs_vl_lookup_vldb(volume->cell, key, idbuf, idsz);
316 if (IS_ERR(vldb)) {
317 ret = PTR_ERR(vldb);
318 goto error;
319 }
320
321 /* See if the volume got renamed. */
322 if (vldb->name_len != volume->name_len ||
323 memcmp(vldb->name, volume->name, vldb->name_len) != 0) {
324 /* TODO: Use RCU'd string. */
325 memcpy(volume->name, vldb->name, AFS_MAXVOLNAME);
326 volume->name_len = vldb->name_len;
327 }
328
329 /* See if the volume's server list got updated. */
330 new = afs_alloc_server_list(volume->cell, key,
331 vldb, (1 << volume->type));
332 if (IS_ERR(new)) {
333 ret = PTR_ERR(new);
334 goto error_vldb;
335 }
336
337 write_lock(&volume->servers_lock);
338
339 discard = new;
340 old = rcu_dereference_protected(volume->servers,
341 lockdep_is_held(&volume->servers_lock));
342 if (afs_annotate_server_list(new, old)) {
343 new->seq = volume->servers_seq + 1;
344 rcu_assign_pointer(volume->servers, new);
345 smp_wmb();
346 volume->servers_seq++;
347 discard = old;
348 }
349
350 volume->update_at = ktime_get_real_seconds() + afs_volume_record_life;
351 write_unlock(&volume->servers_lock);
352 ret = 0;
353
354 afs_put_serverlist(volume->cell->net, discard);
355error_vldb:
356 kfree(vldb);
357error:
358 _leave(" = %d", ret);
359 return ret;
360}
361
362/*
363 * Make sure the volume record is up to date.
364 */
365int afs_check_volume_status(struct afs_volume *volume, struct afs_operation *op)
366{
367 int ret, retries = 0;
368
369 _enter("");
370
371retry:
372 if (test_bit(AFS_VOLUME_WAIT, &volume->flags))
373 goto wait;
374 if (volume->update_at <= ktime_get_real_seconds() ||
375 test_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags))
376 goto update;
377 _leave(" = 0");
378 return 0;
379
380update:
381 if (!test_and_set_bit_lock(AFS_VOLUME_UPDATING, &volume->flags)) {
382 clear_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);
383 ret = afs_update_volume_status(volume, op->key);
384 if (ret < 0)
385 set_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);
386 clear_bit_unlock(AFS_VOLUME_WAIT, &volume->flags);
387 clear_bit_unlock(AFS_VOLUME_UPDATING, &volume->flags);
388 wake_up_bit(&volume->flags, AFS_VOLUME_WAIT);
389 _leave(" = %d", ret);
390 return ret;
391 }
392
393wait:
394 if (!test_bit(AFS_VOLUME_WAIT, &volume->flags)) {
395 _leave(" = 0 [no wait]");
396 return 0;
397 }
398
399 ret = wait_on_bit(&volume->flags, AFS_VOLUME_WAIT,
400 (op->flags & AFS_OPERATION_UNINTR) ?
401 TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE);
402 if (ret == -ERESTARTSYS) {
403 _leave(" = %d", ret);
404 return ret;
405 }
406
407 retries++;
408 if (retries == 4) {
409 _leave(" = -ESTALE");
410 return -ESTALE;
411 }
412 goto retry;
413}