1// SPDX-License-Identifier: GPL-2.0-or-later
2/* AFS cell alias detection
3 *
4 * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/slab.h>
9#include <linux/sched.h>
10#include <linux/namei.h>
11#include <keys/rxrpc-type.h>
12#include "internal.h"
13
14/*
15 * Sample a volume.
16 */
17static struct afs_volume *afs_sample_volume(struct afs_cell *cell, struct key *key,
18					    const char *name, unsigned int namelen)
19{
20	struct afs_volume *volume;
21	struct afs_fs_context fc = {
22		.type		= 0, /* Explicitly leave it to the VLDB */
23		.volnamesz	= namelen,
24		.volname	= name,
25		.net		= cell->net,
26		.cell		= cell,
27		.key		= key, /* This might need to be something */
28	};
29
30	volume = afs_create_volume(&fc);
31	_leave(" = %p", volume);
32	return volume;
33}
34
35/*
36 * Compare the address lists of a pair of fileservers.
37 */
38static int afs_compare_fs_alists(const struct afs_server *server_a,
39				 const struct afs_server *server_b)
40{
41	const struct afs_addr_list *la, *lb;
42	int a = 0, b = 0, addr_matches = 0;
43
44	la = rcu_dereference(server_a->endpoint_state)->addresses;
45	lb = rcu_dereference(server_b->endpoint_state)->addresses;
46
47	while (a < la->nr_addrs && b < lb->nr_addrs) {
48		unsigned long pa = (unsigned long)la->addrs[a].peer;
49		unsigned long pb = (unsigned long)lb->addrs[b].peer;
50		long diff = pa - pb;
51
52		if (diff < 0) {
53			a++;
54		} else if (diff > 0) {
55			b++;
56		} else {
57			addr_matches++;
58			a++;
59			b++;
60		}
61	}
62
63	return addr_matches;
64}
65
66/*
67 * Compare the fileserver lists of two volumes.  The server lists are sorted in
68 * order of ascending UUID.
69 */
70static int afs_compare_volume_slists(const struct afs_volume *vol_a,
71				     const struct afs_volume *vol_b)
72{
73	const struct afs_server_list *la, *lb;
74	int i, a = 0, b = 0, uuid_matches = 0, addr_matches = 0;
75
76	la = rcu_dereference(vol_a->servers);
77	lb = rcu_dereference(vol_b->servers);
78
79	for (i = 0; i < AFS_MAXTYPES; i++)
80		if (vol_a->vids[i] != vol_b->vids[i])
81			return 0;
82
83	while (a < la->nr_servers && b < lb->nr_servers) {
84		const struct afs_server *server_a = la->servers[a].server;
85		const struct afs_server *server_b = lb->servers[b].server;
86		int diff = memcmp(&server_a->uuid, &server_b->uuid, sizeof(uuid_t));
87
88		if (diff < 0) {
89			a++;
90		} else if (diff > 0) {
91			b++;
92		} else {
93			uuid_matches++;
94			addr_matches += afs_compare_fs_alists(server_a, server_b);
95			a++;
96			b++;
97		}
98	}
99
100	_leave(" = %d [um %d]", addr_matches, uuid_matches);
101	return addr_matches;
102}
103
104/*
105 * Compare root.cell volumes.
106 */
107static int afs_compare_cell_roots(struct afs_cell *cell)
108{
109	struct afs_cell *p;
110
111	_enter("");
112
113	rcu_read_lock();
114
115	hlist_for_each_entry_rcu(p, &cell->net->proc_cells, proc_link) {
116		if (p == cell || p->alias_of)
117			continue;
118		if (!p->root_volume)
119			continue; /* Ignore cells that don't have a root.cell volume. */
120
121		if (afs_compare_volume_slists(cell->root_volume, p->root_volume) != 0)
122			goto is_alias;
123	}
124
125	rcu_read_unlock();
126	_leave(" = 0");
127	return 0;
128
129is_alias:
130	rcu_read_unlock();
131	cell->alias_of = afs_use_cell(p, afs_cell_trace_use_alias);
132	return 1;
133}
134
135/*
136 * Query the new cell for a volume from a cell we're already using.
137 */
138static int afs_query_for_alias_one(struct afs_cell *cell, struct key *key,
139				   struct afs_cell *p)
140{
141	struct afs_volume *volume, *pvol = NULL;
142	int ret;
143
144	/* Arbitrarily pick a volume from the list. */
145	read_seqlock_excl(&p->volume_lock);
146	if (!RB_EMPTY_ROOT(&p->volumes))
147		pvol = afs_get_volume(rb_entry(p->volumes.rb_node,
148					       struct afs_volume, cell_node),
149				      afs_volume_trace_get_query_alias);
150	read_sequnlock_excl(&p->volume_lock);
151	if (!pvol)
152		return 0;
153
154	_enter("%s:%s", cell->name, pvol->name);
155
156	/* And see if it's in the new cell. */
157	volume = afs_sample_volume(cell, key, pvol->name, pvol->name_len);
158	if (IS_ERR(volume)) {
159		afs_put_volume(pvol, afs_volume_trace_put_query_alias);
160		if (PTR_ERR(volume) != -ENOMEDIUM)
161			return PTR_ERR(volume);
162		/* That volume is not in the new cell, so not an alias */
163		return 0;
164	}
165
166	/* The new cell has a like-named volume also - compare volume ID,
167	 * server and address lists.
168	 */
169	ret = 0;
170	if (pvol->vid == volume->vid) {
171		rcu_read_lock();
172		if (afs_compare_volume_slists(volume, pvol))
173			ret = 1;
174		rcu_read_unlock();
175	}
176
177	afs_put_volume(volume, afs_volume_trace_put_query_alias);
178	afs_put_volume(pvol, afs_volume_trace_put_query_alias);
179	return ret;
180}
181
182/*
183 * Query the new cell for volumes we know exist in cells we're already using.
184 */
185static int afs_query_for_alias(struct afs_cell *cell, struct key *key)
186{
187	struct afs_cell *p;
188
189	_enter("%s", cell->name);
190
191	if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0)
192		return -ERESTARTSYS;
193
194	hlist_for_each_entry(p, &cell->net->proc_cells, proc_link) {
195		if (p == cell || p->alias_of)
196			continue;
197		if (RB_EMPTY_ROOT(&p->volumes))
198			continue;
199		if (p->root_volume)
200			continue; /* Ignore cells that have a root.cell volume. */
201		afs_use_cell(p, afs_cell_trace_use_check_alias);
202		mutex_unlock(&cell->net->proc_cells_lock);
203
204		if (afs_query_for_alias_one(cell, key, p) != 0)
205			goto is_alias;
206
207		if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0) {
208			afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias);
209			return -ERESTARTSYS;
210		}
211
212		afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias);
213	}
214
215	mutex_unlock(&cell->net->proc_cells_lock);
216	_leave(" = 0");
217	return 0;
218
219is_alias:
220	cell->alias_of = p; /* Transfer our ref */
221	return 1;
222}
223
224/*
225 * Look up a VLDB record for a volume.
226 */
227static char *afs_vl_get_cell_name(struct afs_cell *cell, struct key *key)
228{
229	struct afs_vl_cursor vc;
230	char *cell_name = ERR_PTR(-EDESTADDRREQ);
231	bool skipped = false, not_skipped = false;
232	int ret;
233
234	if (!afs_begin_vlserver_operation(&vc, cell, key))
235		return ERR_PTR(-ERESTARTSYS);
236
237	while (afs_select_vlserver(&vc)) {
238		if (!test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) {
239			vc.call_error = -EOPNOTSUPP;
240			skipped = true;
241			continue;
242		}
243		not_skipped = true;
244		cell_name = afs_yfsvl_get_cell_name(&vc);
245	}
246
247	ret = afs_end_vlserver_operation(&vc);
248	if (skipped && !not_skipped)
249		ret = -EOPNOTSUPP;
250	return ret < 0 ? ERR_PTR(ret) : cell_name;
251}
252
253static int yfs_check_canonical_cell_name(struct afs_cell *cell, struct key *key)
254{
255	struct afs_cell *master;
256	char *cell_name;
257
258	cell_name = afs_vl_get_cell_name(cell, key);
259	if (IS_ERR(cell_name))
260		return PTR_ERR(cell_name);
261
262	if (strcmp(cell_name, cell->name) == 0) {
263		kfree(cell_name);
264		return 0;
265	}
266
267	master = afs_lookup_cell(cell->net, cell_name, strlen(cell_name),
268				 NULL, false);
269	kfree(cell_name);
270	if (IS_ERR(master))
271		return PTR_ERR(master);
272
273	cell->alias_of = master; /* Transfer our ref */
274	return 1;
275}
276
277static int afs_do_cell_detect_alias(struct afs_cell *cell, struct key *key)
278{
279	struct afs_volume *root_volume;
280	int ret;
281
282	_enter("%s", cell->name);
283
284	ret = yfs_check_canonical_cell_name(cell, key);
285	if (ret != -EOPNOTSUPP)
286		return ret;
287
288	/* Try and get the root.cell volume for comparison with other cells */
289	root_volume = afs_sample_volume(cell, key, "root.cell", 9);
290	if (!IS_ERR(root_volume)) {
291		cell->root_volume = root_volume;
292		return afs_compare_cell_roots(cell);
293	}
294
295	if (PTR_ERR(root_volume) != -ENOMEDIUM)
296		return PTR_ERR(root_volume);
297
298	/* Okay, this cell doesn't have an root.cell volume.  We need to
299	 * locate some other random volume and use that to check.
300	 */
301	return afs_query_for_alias(cell, key);
302}
303
304/*
305 * Check to see if a new cell is an alias of a cell we already have.  At this
306 * point we have the cell's volume server list.
307 *
308 * Returns 0 if we didn't detect an alias, 1 if we found an alias and an error
309 * if we had problems gathering the data required.  In the case the we did
310 * detect an alias, cell->alias_of is set to point to the assumed master.
311 */
312int afs_cell_detect_alias(struct afs_cell *cell, struct key *key)
313{
314	struct afs_net *net = cell->net;
315	int ret;
316
317	if (mutex_lock_interruptible(&net->cells_alias_lock) < 0)
318		return -ERESTARTSYS;
319
320	if (test_bit(AFS_CELL_FL_CHECK_ALIAS, &cell->flags)) {
321		ret = afs_do_cell_detect_alias(cell, key);
322		if (ret >= 0)
323			clear_bit_unlock(AFS_CELL_FL_CHECK_ALIAS, &cell->flags);
324	} else {
325		ret = cell->alias_of ? 1 : 0;
326	}
327
328	mutex_unlock(&net->cells_alias_lock);
329
330	if (ret == 1)
331		pr_notice("kAFS: Cell %s is an alias of %s\n",
332			  cell->name, cell->alias_of->name);
333	return ret;
334}
335