]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
ec26815a | 2 | /* AFS volume management |
1da177e4 | 3 | * |
08e0e7c8 | 4 | * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. |
1da177e4 | 5 | * Written by David Howells (dhowells@redhat.com) |
1da177e4 LT |
6 | */ |
7 | ||
8 | #include <linux/kernel.h> | |
1da177e4 | 9 | #include <linux/slab.h> |
1da177e4 LT |
10 | #include "internal.h" |
11 | ||
d2ddc776 DH |
12 | unsigned __read_mostly afs_volume_gc_delay = 10; |
13 | unsigned __read_mostly afs_volume_record_life = 60 * 60; | |
14 | ||
1da177e4 | 15 | /* |
d2ddc776 DH |
16 | * Allocate a volume record and load it up from a vldb record. |
17 | */ | |
13fcc683 | 18 | static struct afs_volume *afs_alloc_volume(struct afs_fs_context *params, |
d2ddc776 DH |
19 | struct afs_vldb_entry *vldb, |
20 | unsigned long type_mask) | |
21 | { | |
22 | struct afs_server_list *slist; | |
d2ddc776 | 23 | struct afs_volume *volume; |
45df8462 | 24 | int ret = -ENOMEM, nr_servers = 0, i; |
d2ddc776 DH |
25 | |
26 | for (i = 0; i < vldb->nr_servers; i++) | |
27 | if (vldb->fs_mask[i] & type_mask) | |
28 | nr_servers++; | |
29 | ||
30 | volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL); | |
31 | if (!volume) | |
32 | goto error_0; | |
33 | ||
34 | volume->vid = vldb->vid[params->type]; | |
35 | volume->update_at = ktime_get_real_seconds() + afs_volume_record_life; | |
36 | volume->cell = afs_get_cell(params->cell); | |
37 | volume->type = params->type; | |
38 | volume->type_force = params->force; | |
39 | volume->name_len = vldb->name_len; | |
40 | ||
41 | atomic_set(&volume->usage, 1); | |
42 | INIT_LIST_HEAD(&volume->proc_link); | |
43 | rwlock_init(&volume->servers_lock); | |
90fa9b64 | 44 | rwlock_init(&volume->cb_v_break_lock); |
d2ddc776 DH |
45 | memcpy(volume->name, vldb->name, vldb->name_len + 1); |
46 | ||
47 | slist = afs_alloc_server_list(params->cell, params->key, vldb, type_mask); | |
48 | if (IS_ERR(slist)) { | |
49 | ret = PTR_ERR(slist); | |
50 | goto error_1; | |
51 | } | |
52 | ||
53 | refcount_set(&slist->usage, 1); | |
54 | volume->servers = slist; | |
d2ddc776 DH |
55 | return volume; |
56 | ||
d2ddc776 | 57 | error_1: |
e4415015 | 58 | afs_put_cell(params->net, volume->cell); |
d2ddc776 DH |
59 | kfree(volume); |
60 | error_0: | |
61 | return ERR_PTR(ret); | |
62 | } | |
63 | ||
64 | /* | |
65 | * Look up a VLDB record for a volume. | |
66 | */ | |
67 | static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell, | |
68 | struct key *key, | |
69 | const char *volname, | |
70 | size_t volnamesz) | |
71 | { | |
0a5143f2 DH |
72 | struct afs_vldb_entry *vldb = ERR_PTR(-EDESTADDRREQ); |
73 | struct afs_vl_cursor vc; | |
d2ddc776 DH |
74 | int ret; |
75 | ||
0a5143f2 DH |
76 | if (!afs_begin_vlserver_operation(&vc, cell, key)) |
77 | return ERR_PTR(-ERESTARTSYS); | |
d2ddc776 | 78 | |
0a5143f2 | 79 | while (afs_select_vlserver(&vc)) { |
0a5143f2 | 80 | vldb = afs_vl_get_entry_by_name_u(&vc, volname, volnamesz); |
d2ddc776 DH |
81 | } |
82 | ||
0a5143f2 DH |
83 | ret = afs_end_vlserver_operation(&vc); |
84 | return ret < 0 ? ERR_PTR(ret) : vldb; | |
d2ddc776 DH |
85 | } |
86 | ||
87 | /* | |
88 | * Look up a volume in the VL server and create a candidate volume record for | |
89 | * it. | |
90 | * | |
91 | * The volume name can be one of the following: | |
1da177e4 LT |
92 | * "%[cell:]volume[.]" R/W volume |
93 | * "#[cell:]volume[.]" R/O or R/W volume (rwparent=0), | |
94 | * or R/W (rwparent=1) volume | |
95 | * "%[cell:]volume.readonly" R/O volume | |
96 | * "#[cell:]volume.readonly" R/O volume | |
97 | * "%[cell:]volume.backup" Backup volume | |
98 | * "#[cell:]volume.backup" Backup volume | |
99 | * | |
100 | * The cell name is optional, and defaults to the current cell. | |
101 | * | |
102 | * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin | |
103 | * Guide | |
104 | * - Rule 1: Explicit type suffix forces access of that type or nothing | |
105 | * (no suffix, then use Rule 2 & 3) | |
106 | * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W | |
107 | * if not available | |
108 | * - Rule 3: If parent volume is R/W, then only mount R/W volume unless | |
109 | * explicitly told otherwise | |
110 | */ | |
13fcc683 | 111 | struct afs_volume *afs_create_volume(struct afs_fs_context *params) |
1da177e4 | 112 | { |
d2ddc776 DH |
113 | struct afs_vldb_entry *vldb; |
114 | struct afs_volume *volume; | |
115 | unsigned long type_mask = 1UL << params->type; | |
1da177e4 | 116 | |
d2ddc776 DH |
117 | vldb = afs_vl_lookup_vldb(params->cell, params->key, |
118 | params->volname, params->volnamesz); | |
119 | if (IS_ERR(vldb)) | |
120 | return ERR_CAST(vldb); | |
1da177e4 | 121 | |
d2ddc776 DH |
122 | if (test_bit(AFS_VLDB_QUERY_ERROR, &vldb->flags)) { |
123 | volume = ERR_PTR(vldb->error); | |
124 | goto error; | |
125 | } | |
1da177e4 | 126 | |
d2ddc776 DH |
127 | /* Make the final decision on the type we want */ |
128 | volume = ERR_PTR(-ENOMEDIUM); | |
00d3b7a4 | 129 | if (params->force) { |
d2ddc776 | 130 | if (!(vldb->flags & type_mask)) |
1da177e4 | 131 | goto error; |
d2ddc776 | 132 | } else if (test_bit(AFS_VLDB_HAS_RO, &vldb->flags)) { |
00d3b7a4 | 133 | params->type = AFSVL_ROVOL; |
d2ddc776 | 134 | } else if (test_bit(AFS_VLDB_HAS_RW, &vldb->flags)) { |
00d3b7a4 | 135 | params->type = AFSVL_RWVOL; |
ec26815a | 136 | } else { |
1da177e4 LT |
137 | goto error; |
138 | } | |
139 | ||
d2ddc776 DH |
140 | type_mask = 1UL << params->type; |
141 | volume = afs_alloc_volume(params, vldb, type_mask); | |
1da177e4 | 142 | |
d2ddc776 DH |
143 | error: |
144 | kfree(vldb); | |
145 | return volume; | |
146 | } | |
1da177e4 | 147 | |
d2ddc776 DH |
148 | /* |
149 | * Destroy a volume record | |
150 | */ | |
151 | static void afs_destroy_volume(struct afs_net *net, struct afs_volume *volume) | |
152 | { | |
153 | _enter("%p", volume); | |
1da177e4 | 154 | |
d2ddc776 DH |
155 | #ifdef CONFIG_AFS_FSCACHE |
156 | ASSERTCMP(volume->cache, ==, NULL); | |
157 | #endif | |
1da177e4 | 158 | |
d2ddc776 DH |
159 | afs_put_serverlist(net, volume->servers); |
160 | afs_put_cell(net, volume->cell); | |
161 | kfree(volume); | |
1da177e4 | 162 | |
d2ddc776 DH |
163 | _leave(" [destroyed]"); |
164 | } | |
165 | ||
166 | /* | |
167 | * Drop a reference on a volume record. | |
168 | */ | |
169 | void afs_put_volume(struct afs_cell *cell, struct afs_volume *volume) | |
170 | { | |
171 | if (volume) { | |
172 | _enter("%s", volume->name); | |
173 | ||
174 | if (atomic_dec_and_test(&volume->usage)) | |
175 | afs_destroy_volume(cell->net, volume); | |
1da177e4 | 176 | } |
d2ddc776 | 177 | } |
1da177e4 | 178 | |
d2ddc776 DH |
179 | /* |
180 | * Activate a volume. | |
181 | */ | |
182 | void afs_activate_volume(struct afs_volume *volume) | |
183 | { | |
9b3f26c9 | 184 | #ifdef CONFIG_AFS_FSCACHE |
ad6a942a | 185 | volume->cache = fscache_acquire_cookie(volume->cell->cache, |
9b3f26c9 | 186 | &afs_volume_cache_index_def, |
402cb8dd DH |
187 | &volume->vid, sizeof(volume->vid), |
188 | NULL, 0, | |
ee1235a9 | 189 | volume, 0, true); |
1da177e4 | 190 | #endif |
1da177e4 | 191 | |
d2ddc776 DH |
192 | write_lock(&volume->cell->proc_lock); |
193 | list_add_tail(&volume->proc_link, &volume->cell->proc_volumes); | |
194 | write_unlock(&volume->cell->proc_lock); | |
195 | } | |
1da177e4 | 196 | |
d2ddc776 DH |
197 | /* |
198 | * Deactivate a volume. | |
199 | */ | |
200 | void afs_deactivate_volume(struct afs_volume *volume) | |
201 | { | |
202 | _enter("%s", volume->name); | |
1da177e4 | 203 | |
d2ddc776 DH |
204 | write_lock(&volume->cell->proc_lock); |
205 | list_del_init(&volume->proc_link); | |
206 | write_unlock(&volume->cell->proc_lock); | |
1da177e4 | 207 | |
d2ddc776 | 208 | #ifdef CONFIG_AFS_FSCACHE |
402cb8dd | 209 | fscache_relinquish_cookie(volume->cache, NULL, |
d2ddc776 DH |
210 | test_bit(AFS_VOLUME_DELETED, &volume->flags)); |
211 | volume->cache = NULL; | |
212 | #endif | |
1da177e4 | 213 | |
d2ddc776 | 214 | _leave(""); |
ec26815a | 215 | } |
1da177e4 | 216 | |
1da177e4 | 217 | /* |
d2ddc776 | 218 | * Query the VL service to update the volume status. |
1da177e4 | 219 | */ |
d2ddc776 | 220 | static int afs_update_volume_status(struct afs_volume *volume, struct key *key) |
1da177e4 | 221 | { |
d2ddc776 DH |
222 | struct afs_server_list *new, *old, *discard; |
223 | struct afs_vldb_entry *vldb; | |
224 | char idbuf[16]; | |
225 | int ret, idsz; | |
1da177e4 | 226 | |
d2ddc776 | 227 | _enter(""); |
1da177e4 | 228 | |
d2ddc776 DH |
229 | /* We look up an ID by passing it as a decimal string in the |
230 | * operation's name parameter. | |
231 | */ | |
3b6492df | 232 | idsz = sprintf(idbuf, "%llu", volume->vid); |
1da177e4 | 233 | |
d2ddc776 DH |
234 | vldb = afs_vl_lookup_vldb(volume->cell, key, idbuf, idsz); |
235 | if (IS_ERR(vldb)) { | |
236 | ret = PTR_ERR(vldb); | |
237 | goto error; | |
238 | } | |
1da177e4 | 239 | |
d2ddc776 DH |
240 | /* See if the volume got renamed. */ |
241 | if (vldb->name_len != volume->name_len || | |
242 | memcmp(vldb->name, volume->name, vldb->name_len) != 0) { | |
243 | /* TODO: Use RCU'd string. */ | |
244 | memcpy(volume->name, vldb->name, AFS_MAXVOLNAME); | |
245 | volume->name_len = vldb->name_len; | |
246 | } | |
247 | ||
248 | /* See if the volume's server list got updated. */ | |
249 | new = afs_alloc_server_list(volume->cell, key, | |
45df8462 | 250 | vldb, (1 << volume->type)); |
d2ddc776 DH |
251 | if (IS_ERR(new)) { |
252 | ret = PTR_ERR(new); | |
253 | goto error_vldb; | |
254 | } | |
1da177e4 | 255 | |
d2ddc776 | 256 | write_lock(&volume->servers_lock); |
1da177e4 | 257 | |
d2ddc776 DH |
258 | discard = new; |
259 | old = volume->servers; | |
260 | if (afs_annotate_server_list(new, old)) { | |
261 | new->seq = volume->servers_seq + 1; | |
262 | volume->servers = new; | |
263 | smp_wmb(); | |
264 | volume->servers_seq++; | |
265 | discard = old; | |
1da177e4 LT |
266 | } |
267 | ||
d2ddc776 DH |
268 | volume->update_at = ktime_get_real_seconds() + afs_volume_record_life; |
269 | clear_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags); | |
270 | write_unlock(&volume->servers_lock); | |
271 | ret = 0; | |
1da177e4 | 272 | |
d2ddc776 DH |
273 | afs_put_serverlist(volume->cell->net, discard); |
274 | error_vldb: | |
275 | kfree(vldb); | |
276 | error: | |
277 | _leave(" = %d", ret); | |
278 | return ret; | |
279 | } | |
1da177e4 | 280 | |
d2ddc776 DH |
281 | /* |
282 | * Make sure the volume record is up to date. | |
283 | */ | |
284 | int afs_check_volume_status(struct afs_volume *volume, struct key *key) | |
285 | { | |
286 | time64_t now = ktime_get_real_seconds(); | |
287 | int ret, retries = 0; | |
1da177e4 | 288 | |
d2ddc776 DH |
289 | _enter(""); |
290 | ||
291 | if (volume->update_at <= now) | |
292 | set_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags); | |
293 | ||
294 | retry: | |
295 | if (!test_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags) && | |
296 | !test_bit(AFS_VOLUME_WAIT, &volume->flags)) { | |
297 | _leave(" = 0"); | |
298 | return 0; | |
c435ee34 | 299 | } |
1da177e4 | 300 | |
d2ddc776 DH |
301 | if (!test_and_set_bit_lock(AFS_VOLUME_UPDATING, &volume->flags)) { |
302 | ret = afs_update_volume_status(volume, key); | |
303 | clear_bit_unlock(AFS_VOLUME_WAIT, &volume->flags); | |
304 | clear_bit_unlock(AFS_VOLUME_UPDATING, &volume->flags); | |
305 | wake_up_bit(&volume->flags, AFS_VOLUME_WAIT); | |
306 | _leave(" = %d", ret); | |
307 | return ret; | |
308 | } | |
1da177e4 | 309 | |
d2ddc776 DH |
310 | if (!test_bit(AFS_VOLUME_WAIT, &volume->flags)) { |
311 | _leave(" = 0 [no wait]"); | |
312 | return 0; | |
313 | } | |
314 | ||
315 | ret = wait_on_bit(&volume->flags, AFS_VOLUME_WAIT, TASK_INTERRUPTIBLE); | |
316 | if (ret == -ERESTARTSYS) { | |
317 | _leave(" = %d", ret); | |
318 | return ret; | |
319 | } | |
320 | ||
321 | retries++; | |
322 | if (retries == 4) { | |
323 | _leave(" = -ESTALE"); | |
324 | return -ESTALE; | |
325 | } | |
326 | goto retry; | |
ec26815a | 327 | } |