1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* AFS fileserver list management. |
3 | * |
4 | * Copyright (C) 2017 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 | |
12 | void afs_put_serverlist(struct afs_net *net, struct afs_server_list *slist) |
13 | { |
14 | int i; |
15 | |
16 | if (slist && refcount_dec_and_test(r: &slist->usage)) { |
17 | for (i = 0; i < slist->nr_servers; i++) |
18 | afs_unuse_server(net, slist->servers[i].server, |
19 | afs_server_trace_put_slist); |
20 | kfree_rcu(slist, rcu); |
21 | } |
22 | } |
23 | |
24 | /* |
25 | * Build a server list from a VLDB record. |
26 | */ |
27 | struct afs_server_list *afs_alloc_server_list(struct afs_volume *volume, |
28 | struct key *key, |
29 | struct afs_vldb_entry *vldb) |
30 | { |
31 | struct afs_server_list *slist; |
32 | struct afs_server *server; |
33 | unsigned int type_mask = 1 << volume->type; |
34 | bool use_newrepsites = false; |
35 | int ret = -ENOMEM, nr_servers = 0, newrep = 0, i, j, usable = 0; |
36 | |
37 | /* Work out if we're going to restrict to NEWREPSITE-marked servers or |
38 | * not. If at least one site is marked as NEWREPSITE, then it's likely |
39 | * that "vos release" is busy updating RO sites. We cut over from one |
40 | * to the other when >=50% of the sites have been updated. Sites that |
41 | * are in the process of being updated are marked DONTUSE. |
42 | */ |
43 | for (i = 0; i < vldb->nr_servers; i++) { |
44 | if (!(vldb->fs_mask[i] & type_mask)) |
45 | continue; |
46 | nr_servers++; |
47 | if (vldb->vlsf_flags[i] & AFS_VLSF_DONTUSE) |
48 | continue; |
49 | usable++; |
50 | if (vldb->vlsf_flags[i] & AFS_VLSF_NEWREPSITE) |
51 | newrep++; |
52 | } |
53 | |
54 | slist = kzalloc(struct_size(slist, servers, nr_servers), GFP_KERNEL); |
55 | if (!slist) |
56 | goto error; |
57 | |
58 | if (newrep) { |
59 | if (newrep < usable / 2) { |
60 | slist->ro_replicating = AFS_RO_REPLICATING_USE_OLD; |
61 | } else { |
62 | slist->ro_replicating = AFS_RO_REPLICATING_USE_NEW; |
63 | use_newrepsites = true; |
64 | } |
65 | } |
66 | |
67 | refcount_set(r: &slist->usage, n: 1); |
68 | rwlock_init(&slist->lock); |
69 | |
70 | /* Make sure a records exists for each server in the list. */ |
71 | for (i = 0; i < vldb->nr_servers; i++) { |
72 | unsigned long se_flags = 0; |
73 | bool newrepsite = vldb->vlsf_flags[i] & AFS_VLSF_NEWREPSITE; |
74 | |
75 | if (!(vldb->fs_mask[i] & type_mask)) |
76 | continue; |
77 | if (vldb->vlsf_flags[i] & AFS_VLSF_DONTUSE) |
78 | __set_bit(AFS_SE_EXCLUDED, &se_flags); |
79 | if (newrep && (newrepsite ^ use_newrepsites)) |
80 | __set_bit(AFS_SE_EXCLUDED, &se_flags); |
81 | |
82 | server = afs_lookup_server(volume->cell, key, &vldb->fs_server[i], |
83 | vldb->addr_version[i]); |
84 | if (IS_ERR(ptr: server)) { |
85 | ret = PTR_ERR(ptr: server); |
86 | if (ret == -ENOENT || |
87 | ret == -ENOMEDIUM) |
88 | continue; |
89 | goto error_2; |
90 | } |
91 | |
92 | /* Insertion-sort by UUID */ |
93 | for (j = 0; j < slist->nr_servers; j++) |
94 | if (memcmp(p: &slist->servers[j].server->uuid, |
95 | q: &server->uuid, |
96 | size: sizeof(server->uuid)) >= 0) |
97 | break; |
98 | if (j < slist->nr_servers) { |
99 | if (slist->servers[j].server == server) { |
100 | afs_put_server(volume->cell->net, server, |
101 | afs_server_trace_put_slist_isort); |
102 | continue; |
103 | } |
104 | |
105 | memmove(slist->servers + j + 1, |
106 | slist->servers + j, |
107 | (slist->nr_servers - j) * sizeof(struct afs_server_entry)); |
108 | } |
109 | |
110 | slist->servers[j].server = server; |
111 | slist->servers[j].volume = volume; |
112 | slist->servers[j].flags = se_flags; |
113 | slist->servers[j].cb_expires_at = AFS_NO_CB_PROMISE; |
114 | slist->nr_servers++; |
115 | } |
116 | |
117 | if (slist->nr_servers == 0) { |
118 | ret = -EDESTADDRREQ; |
119 | goto error_2; |
120 | } |
121 | |
122 | return slist; |
123 | |
124 | error_2: |
125 | afs_put_serverlist(net: volume->cell->net, slist); |
126 | error: |
127 | return ERR_PTR(error: ret); |
128 | } |
129 | |
130 | /* |
131 | * Copy the annotations from an old server list to its potential replacement. |
132 | */ |
133 | bool afs_annotate_server_list(struct afs_server_list *new, |
134 | struct afs_server_list *old) |
135 | { |
136 | unsigned long mask = 1UL << AFS_SE_EXCLUDED; |
137 | int i; |
138 | |
139 | if (old->nr_servers != new->nr_servers || |
140 | old->ro_replicating != new->ro_replicating) |
141 | goto changed; |
142 | |
143 | for (i = 0; i < old->nr_servers; i++) { |
144 | if (old->servers[i].server != new->servers[i].server) |
145 | goto changed; |
146 | if ((old->servers[i].flags & mask) != (new->servers[i].flags & mask)) |
147 | goto changed; |
148 | } |
149 | return false; |
150 | changed: |
151 | return true; |
152 | } |
153 | |
154 | /* |
155 | * Attach a volume to the servers it is going to use. |
156 | */ |
157 | void afs_attach_volume_to_servers(struct afs_volume *volume, struct afs_server_list *slist) |
158 | { |
159 | struct afs_server_entry *se, *pe; |
160 | struct afs_server *server; |
161 | struct list_head *p; |
162 | unsigned int i; |
163 | |
164 | down_write(sem: &volume->cell->vs_lock); |
165 | |
166 | for (i = 0; i < slist->nr_servers; i++) { |
167 | se = &slist->servers[i]; |
168 | server = se->server; |
169 | |
170 | list_for_each(p, &server->volumes) { |
171 | pe = list_entry(p, struct afs_server_entry, slink); |
172 | if (volume->vid <= pe->volume->vid) |
173 | break; |
174 | } |
175 | list_add_tail(new: &se->slink, head: p); |
176 | } |
177 | |
178 | slist->attached = true; |
179 | up_write(sem: &volume->cell->vs_lock); |
180 | } |
181 | |
182 | /* |
183 | * Reattach a volume to the servers it is going to use when server list is |
184 | * replaced. We try to switch the attachment points to avoid rewalking the |
185 | * lists. |
186 | */ |
187 | void afs_reattach_volume_to_servers(struct afs_volume *volume, struct afs_server_list *new, |
188 | struct afs_server_list *old) |
189 | { |
190 | unsigned int n = 0, o = 0; |
191 | |
192 | down_write(sem: &volume->cell->vs_lock); |
193 | |
194 | while (n < new->nr_servers || o < old->nr_servers) { |
195 | struct afs_server_entry *pn = n < new->nr_servers ? &new->servers[n] : NULL; |
196 | struct afs_server_entry *po = o < old->nr_servers ? &old->servers[o] : NULL; |
197 | struct afs_server_entry *s; |
198 | struct list_head *p; |
199 | int diff; |
200 | |
201 | if (pn && po && pn->server == po->server) { |
202 | pn->cb_expires_at = po->cb_expires_at; |
203 | list_replace(old: &po->slink, new: &pn->slink); |
204 | n++; |
205 | o++; |
206 | continue; |
207 | } |
208 | |
209 | if (pn && po) |
210 | diff = memcmp(p: &pn->server->uuid, q: &po->server->uuid, |
211 | size: sizeof(pn->server->uuid)); |
212 | else |
213 | diff = pn ? -1 : 1; |
214 | |
215 | if (diff < 0) { |
216 | list_for_each(p, &pn->server->volumes) { |
217 | s = list_entry(p, struct afs_server_entry, slink); |
218 | if (volume->vid <= s->volume->vid) |
219 | break; |
220 | } |
221 | list_add_tail(new: &pn->slink, head: p); |
222 | n++; |
223 | } else { |
224 | list_del(entry: &po->slink); |
225 | o++; |
226 | } |
227 | } |
228 | |
229 | up_write(sem: &volume->cell->vs_lock); |
230 | } |
231 | |
232 | /* |
233 | * Detach a volume from the servers it has been using. |
234 | */ |
235 | void afs_detach_volume_from_servers(struct afs_volume *volume, struct afs_server_list *slist) |
236 | { |
237 | unsigned int i; |
238 | |
239 | if (!slist->attached) |
240 | return; |
241 | |
242 | down_write(sem: &volume->cell->vs_lock); |
243 | |
244 | for (i = 0; i < slist->nr_servers; i++) |
245 | list_del(entry: &slist->servers[i].slink); |
246 | |
247 | slist->attached = false; |
248 | up_write(sem: &volume->cell->vs_lock); |
249 | } |
250 | |