Loading...
1/* AFS fileserver list management.
2 *
3 * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12#include <linux/kernel.h>
13#include <linux/slab.h>
14#include "internal.h"
15
16void afs_put_serverlist(struct afs_net *net, struct afs_server_list *slist)
17{
18 int i;
19
20 if (slist && refcount_dec_and_test(&slist->usage)) {
21 for (i = 0; i < slist->nr_servers; i++) {
22 afs_put_cb_interest(net, slist->servers[i].cb_interest);
23 afs_put_server(net, slist->servers[i].server);
24 }
25 kfree(slist);
26 }
27}
28
29/*
30 * Build a server list from a VLDB record.
31 */
32struct afs_server_list *afs_alloc_server_list(struct afs_cell *cell,
33 struct key *key,
34 struct afs_vldb_entry *vldb,
35 u8 type_mask)
36{
37 struct afs_server_list *slist;
38 struct afs_server *server;
39 int ret = -ENOMEM, nr_servers = 0, i, j;
40
41 for (i = 0; i < vldb->nr_servers; i++)
42 if (vldb->fs_mask[i] & type_mask)
43 nr_servers++;
44
45 slist = kzalloc(sizeof(struct afs_server_list) +
46 sizeof(struct afs_server_entry) * nr_servers,
47 GFP_KERNEL);
48 if (!slist)
49 goto error;
50
51 refcount_set(&slist->usage, 1);
52 rwlock_init(&slist->lock);
53
54 /* Make sure a records exists for each server in the list. */
55 for (i = 0; i < vldb->nr_servers; i++) {
56 if (!(vldb->fs_mask[i] & type_mask))
57 continue;
58
59 server = afs_lookup_server(cell, key, &vldb->fs_server[i]);
60 if (IS_ERR(server)) {
61 ret = PTR_ERR(server);
62 if (ret == -ENOENT ||
63 ret == -ENOMEDIUM)
64 continue;
65 goto error_2;
66 }
67
68 /* Insertion-sort by UUID */
69 for (j = 0; j < slist->nr_servers; j++)
70 if (memcmp(&slist->servers[j].server->uuid,
71 &server->uuid,
72 sizeof(server->uuid)) >= 0)
73 break;
74 if (j < slist->nr_servers) {
75 if (slist->servers[j].server == server) {
76 afs_put_server(cell->net, server);
77 continue;
78 }
79
80 memmove(slist->servers + j + 1,
81 slist->servers + j,
82 (slist->nr_servers - j) * sizeof(struct afs_server_entry));
83 }
84
85 slist->servers[j].server = server;
86 slist->nr_servers++;
87 }
88
89 if (slist->nr_servers == 0) {
90 ret = -EDESTADDRREQ;
91 goto error_2;
92 }
93
94 return slist;
95
96error_2:
97 afs_put_serverlist(cell->net, slist);
98error:
99 return ERR_PTR(ret);
100}
101
102/*
103 * Copy the annotations from an old server list to its potential replacement.
104 */
105bool afs_annotate_server_list(struct afs_server_list *new,
106 struct afs_server_list *old)
107{
108 struct afs_server *cur;
109 int i, j;
110
111 if (old->nr_servers != new->nr_servers)
112 goto changed;
113
114 for (i = 0; i < old->nr_servers; i++)
115 if (old->servers[i].server != new->servers[i].server)
116 goto changed;
117
118 return false;
119
120changed:
121 /* Maintain the same current server as before if possible. */
122 cur = old->servers[old->index].server;
123 for (j = 0; j < new->nr_servers; j++) {
124 if (new->servers[j].server == cur) {
125 new->index = j;
126 break;
127 }
128 }
129
130 /* Keep the old callback interest records where possible so that we
131 * maintain callback interception.
132 */
133 i = 0;
134 j = 0;
135 while (i < old->nr_servers && j < new->nr_servers) {
136 if (new->servers[j].server == old->servers[i].server) {
137 struct afs_cb_interest *cbi = old->servers[i].cb_interest;
138 if (cbi) {
139 new->servers[j].cb_interest = cbi;
140 refcount_inc(&cbi->usage);
141 }
142 i++;
143 j++;
144 continue;
145 }
146
147 if (new->servers[j].server < old->servers[i].server) {
148 j++;
149 continue;
150 }
151
152 i++;
153 continue;
154 }
155
156 return true;
157}
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
12void afs_put_serverlist(struct afs_net *net, struct afs_server_list *slist)
13{
14 int i;
15
16 if (slist && refcount_dec_and_test(&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 */
27struct 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(&slist->usage, 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(server)) {
85 ret = PTR_ERR(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(&slist->servers[j].server->uuid,
95 &server->uuid,
96 sizeof(server->uuid)) >= 0)
97 break;
98 if (j < slist->nr_servers) {
99 if (slist->servers[j].server == server) {
100 afs_unuse_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
124error_2:
125 afs_put_serverlist(volume->cell->net, slist);
126error:
127 return ERR_PTR(ret);
128}
129
130/*
131 * Copy the annotations from an old server list to its potential replacement.
132 */
133bool 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;
150changed:
151 return true;
152}
153
154/*
155 * Attach a volume to the servers it is going to use.
156 */
157void 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(&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(&se->slink, p);
176 }
177
178 slist->attached = true;
179 up_write(&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 */
187void 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(&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(&po->slink, &pn->slink);
204 n++;
205 o++;
206 continue;
207 }
208
209 if (pn && po)
210 diff = memcmp(&pn->server->uuid, &po->server->uuid,
211 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(&pn->slink, p);
222 n++;
223 } else {
224 list_del(&po->slink);
225 o++;
226 }
227 }
228
229 up_write(&volume->cell->vs_lock);
230}
231
232/*
233 * Detach a volume from the servers it has been using.
234 */
235void 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(&volume->cell->vs_lock);
243
244 for (i = 0; i < slist->nr_servers; i++)
245 list_del(&slist->servers[i].slink);
246
247 slist->attached = false;
248 up_write(&volume->cell->vs_lock);
249}