1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* AFS cell alias detection
4 * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
8 #include <linux/slab.h>
9 #include <linux/sched.h>
10 #include <linux/namei.h>
11 #include <keys/rxrpc-type.h>
17 static struct afs_volume *afs_sample_volume(struct afs_cell *cell, struct key *key,
18 const char *name, unsigned int namelen)
20 struct afs_volume *volume;
21 struct afs_fs_context fc = {
22 .type = 0, /* Explicitly leave it to the VLDB */
27 .key = key, /* This might need to be something */
30 volume = afs_create_volume(&fc);
31 _leave(" = %p", volume);
36 * Compare two addresses.
38 static int afs_compare_addrs(const struct sockaddr_rxrpc *srx_a,
39 const struct sockaddr_rxrpc *srx_b)
42 int addr_a, addr_b, diff;
44 diff = (short)srx_a->transport_type - (short)srx_b->transport_type;
48 switch (srx_a->transport_type) {
50 const struct sockaddr_in *a = &srx_a->transport.sin;
51 const struct sockaddr_in *b = &srx_b->transport.sin;
52 addr_a = ntohl(a->sin_addr.s_addr);
53 addr_b = ntohl(b->sin_addr.s_addr);
54 diff = addr_a - addr_b;
56 port_a = ntohs(a->sin_port);
57 port_b = ntohs(b->sin_port);
58 diff = port_a - port_b;
64 const struct sockaddr_in6 *a = &srx_a->transport.sin6;
65 const struct sockaddr_in6 *b = &srx_b->transport.sin6;
66 diff = memcmp(&a->sin6_addr, &b->sin6_addr, 16);
68 port_a = ntohs(a->sin6_port);
69 port_b = ntohs(b->sin6_port);
70 diff = port_a - port_b;
85 * Compare the address lists of a pair of fileservers.
87 static int afs_compare_fs_alists(const struct afs_server *server_a,
88 const struct afs_server *server_b)
90 const struct afs_addr_list *la, *lb;
91 int a = 0, b = 0, addr_matches = 0;
93 la = rcu_dereference(server_a->addresses);
94 lb = rcu_dereference(server_b->addresses);
96 while (a < la->nr_addrs && b < lb->nr_addrs) {
97 const struct sockaddr_rxrpc *srx_a = &la->addrs[a];
98 const struct sockaddr_rxrpc *srx_b = &lb->addrs[b];
99 int diff = afs_compare_addrs(srx_a, srx_b);
103 } else if (diff > 0) {
116 * Compare the fileserver lists of two volumes. The server lists are sorted in
117 * order of ascending UUID.
119 static int afs_compare_volume_slists(const struct afs_volume *vol_a,
120 const struct afs_volume *vol_b)
122 const struct afs_server_list *la, *lb;
123 int i, a = 0, b = 0, uuid_matches = 0, addr_matches = 0;
125 la = rcu_dereference(vol_a->servers);
126 lb = rcu_dereference(vol_b->servers);
128 for (i = 0; i < AFS_MAXTYPES; i++)
129 if (la->vids[i] != lb->vids[i])
132 while (a < la->nr_servers && b < lb->nr_servers) {
133 const struct afs_server *server_a = la->servers[a].server;
134 const struct afs_server *server_b = lb->servers[b].server;
135 int diff = memcmp(&server_a->uuid, &server_b->uuid, sizeof(uuid_t));
139 } else if (diff > 0) {
143 addr_matches += afs_compare_fs_alists(server_a, server_b);
149 _leave(" = %d [um %d]", addr_matches, uuid_matches);
154 * Compare root.cell volumes.
156 static int afs_compare_cell_roots(struct afs_cell *cell)
164 hlist_for_each_entry_rcu(p, &cell->net->proc_cells, proc_link) {
165 if (p == cell || p->alias_of)
168 continue; /* Ignore cells that don't have a root.cell volume. */
170 if (afs_compare_volume_slists(cell->root_volume, p->root_volume) != 0)
180 cell->alias_of = afs_use_cell(p, afs_cell_trace_use_alias);
185 * Query the new cell for a volume from a cell we're already using.
187 static int afs_query_for_alias_one(struct afs_cell *cell, struct key *key,
190 struct afs_volume *volume, *pvol = NULL;
193 /* Arbitrarily pick a volume from the list. */
194 read_seqlock_excl(&p->volume_lock);
195 if (!RB_EMPTY_ROOT(&p->volumes))
196 pvol = afs_get_volume(rb_entry(p->volumes.rb_node,
197 struct afs_volume, cell_node),
198 afs_volume_trace_get_query_alias);
199 read_sequnlock_excl(&p->volume_lock);
203 _enter("%s:%s", cell->name, pvol->name);
205 /* And see if it's in the new cell. */
206 volume = afs_sample_volume(cell, key, pvol->name, pvol->name_len);
207 if (IS_ERR(volume)) {
208 afs_put_volume(cell->net, pvol, afs_volume_trace_put_query_alias);
209 if (PTR_ERR(volume) != -ENOMEDIUM)
210 return PTR_ERR(volume);
211 /* That volume is not in the new cell, so not an alias */
215 /* The new cell has a like-named volume also - compare volume ID,
216 * server and address lists.
219 if (pvol->vid == volume->vid) {
221 if (afs_compare_volume_slists(volume, pvol))
226 afs_put_volume(cell->net, volume, afs_volume_trace_put_query_alias);
227 afs_put_volume(cell->net, pvol, afs_volume_trace_put_query_alias);
232 * Query the new cell for volumes we know exist in cells we're already using.
234 static int afs_query_for_alias(struct afs_cell *cell, struct key *key)
238 _enter("%s", cell->name);
240 if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0)
243 hlist_for_each_entry(p, &cell->net->proc_cells, proc_link) {
244 if (p == cell || p->alias_of)
246 if (RB_EMPTY_ROOT(&p->volumes))
249 continue; /* Ignore cells that have a root.cell volume. */
250 afs_use_cell(p, afs_cell_trace_use_check_alias);
251 mutex_unlock(&cell->net->proc_cells_lock);
253 if (afs_query_for_alias_one(cell, key, p) != 0)
256 if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0) {
257 afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias);
261 afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias);
264 mutex_unlock(&cell->net->proc_cells_lock);
269 cell->alias_of = p; /* Transfer our ref */
274 * Look up a VLDB record for a volume.
276 static char *afs_vl_get_cell_name(struct afs_cell *cell, struct key *key)
278 struct afs_vl_cursor vc;
279 char *cell_name = ERR_PTR(-EDESTADDRREQ);
280 bool skipped = false, not_skipped = false;
283 if (!afs_begin_vlserver_operation(&vc, cell, key))
284 return ERR_PTR(-ERESTARTSYS);
286 while (afs_select_vlserver(&vc)) {
287 if (!test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) {
288 vc.ac.error = -EOPNOTSUPP;
293 cell_name = afs_yfsvl_get_cell_name(&vc);
296 ret = afs_end_vlserver_operation(&vc);
297 if (skipped && !not_skipped)
299 return ret < 0 ? ERR_PTR(ret) : cell_name;
302 static int yfs_check_canonical_cell_name(struct afs_cell *cell, struct key *key)
304 struct afs_cell *master;
307 cell_name = afs_vl_get_cell_name(cell, key);
308 if (IS_ERR(cell_name))
309 return PTR_ERR(cell_name);
311 if (strcmp(cell_name, cell->name) == 0) {
316 master = afs_lookup_cell(cell->net, cell_name, strlen(cell_name),
320 return PTR_ERR(master);
322 cell->alias_of = master; /* Transfer our ref */
326 static int afs_do_cell_detect_alias(struct afs_cell *cell, struct key *key)
328 struct afs_volume *root_volume;
331 _enter("%s", cell->name);
333 ret = yfs_check_canonical_cell_name(cell, key);
334 if (ret != -EOPNOTSUPP)
337 /* Try and get the root.cell volume for comparison with other cells */
338 root_volume = afs_sample_volume(cell, key, "root.cell", 9);
339 if (!IS_ERR(root_volume)) {
340 cell->root_volume = root_volume;
341 return afs_compare_cell_roots(cell);
344 if (PTR_ERR(root_volume) != -ENOMEDIUM)
345 return PTR_ERR(root_volume);
347 /* Okay, this cell doesn't have an root.cell volume. We need to
348 * locate some other random volume and use that to check.
350 return afs_query_for_alias(cell, key);
354 * Check to see if a new cell is an alias of a cell we already have. At this
355 * point we have the cell's volume server list.
357 * Returns 0 if we didn't detect an alias, 1 if we found an alias and an error
358 * if we had problems gathering the data required. In the case the we did
359 * detect an alias, cell->alias_of is set to point to the assumed master.
361 int afs_cell_detect_alias(struct afs_cell *cell, struct key *key)
363 struct afs_net *net = cell->net;
366 if (mutex_lock_interruptible(&net->cells_alias_lock) < 0)
369 if (test_bit(AFS_CELL_FL_CHECK_ALIAS, &cell->flags)) {
370 ret = afs_do_cell_detect_alias(cell, key);
372 clear_bit_unlock(AFS_CELL_FL_CHECK_ALIAS, &cell->flags);
374 ret = cell->alias_of ? 1 : 0;
377 mutex_unlock(&net->cells_alias_lock);
380 pr_notice("kAFS: Cell %s is an alias of %s\n",
381 cell->name, cell->alias_of->name);