1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* AFS cell alias detection
11 #include <keys/rxrpc-type.h>
17 static struct afs_volume *afs_sample_volume(struct afs_cell *cell, struct key *key,  in afs_sample_volume()  argument
25 		.net		= cell->net,  in afs_sample_volume()
26 		.cell		= cell,  in afs_sample_volume()
44 	la = rcu_dereference(server_a->endpoint_state)->addresses;  in afs_compare_fs_alists()
45 	lb = rcu_dereference(server_b->endpoint_state)->addresses;  in afs_compare_fs_alists()
47 	while (a < la->nr_addrs && b < lb->nr_addrs) {  in afs_compare_fs_alists()
48 		unsigned long pa = (unsigned long)la->addrs[a].peer;  in afs_compare_fs_alists()
49 		unsigned long pb = (unsigned long)lb->addrs[b].peer;  in afs_compare_fs_alists()
50 		long diff = pa - pb;  in afs_compare_fs_alists()
76 	la = rcu_dereference(vol_a->servers);  in afs_compare_volume_slists()
77 	lb = rcu_dereference(vol_b->servers);  in afs_compare_volume_slists()
80 		if (vol_a->vids[i] != vol_b->vids[i])  in afs_compare_volume_slists()
83 	while (a < la->nr_servers && b < lb->nr_servers) {  in afs_compare_volume_slists()
84 		const struct afs_server *server_a = la->servers[a].server;  in afs_compare_volume_slists()
85 		const struct afs_server *server_b = lb->servers[b].server;  in afs_compare_volume_slists()
86 		int diff = memcmp(&server_a->uuid, &server_b->uuid, sizeof(uuid_t));  in afs_compare_volume_slists()
105  * Compare root.cell volumes.
107 static int afs_compare_cell_roots(struct afs_cell *cell)  in afs_compare_cell_roots()  argument
115 	hlist_for_each_entry_rcu(p, &cell->net->proc_cells, proc_link) {  in afs_compare_cell_roots()
116 		if (p == cell || p->alias_of)  in afs_compare_cell_roots()
118 		if (!p->root_volume)  in afs_compare_cell_roots()
119 			continue; /* Ignore cells that don't have a root.cell volume. */  in afs_compare_cell_roots()
121 		if (afs_compare_volume_slists(cell->root_volume, p->root_volume) != 0)  in afs_compare_cell_roots()
131 	cell->alias_of = afs_use_cell(p, afs_cell_trace_use_alias);  in afs_compare_cell_roots()
132 	return 1;  in afs_compare_cell_roots()
136  * Query the new cell for a volume from a cell we're already using.
138 static int afs_query_for_alias_one(struct afs_cell *cell, struct key *key,  in afs_query_for_alias_one()  argument
145 	read_seqlock_excl(&p->volume_lock);  in afs_query_for_alias_one()
146 	if (!RB_EMPTY_ROOT(&p->volumes))  in afs_query_for_alias_one()
147 		pvol = afs_get_volume(rb_entry(p->volumes.rb_node,  in afs_query_for_alias_one()
150 	read_sequnlock_excl(&p->volume_lock);  in afs_query_for_alias_one()
154 	_enter("%s:%s", cell->name, pvol->name);  in afs_query_for_alias_one()
156 	/* And see if it's in the new cell. */  in afs_query_for_alias_one()
157 	volume = afs_sample_volume(cell, key, pvol->name, pvol->name_len);  in afs_query_for_alias_one()
160 		if (PTR_ERR(volume) != -ENOMEDIUM)  in afs_query_for_alias_one()
162 		/* That volume is not in the new cell, so not an alias */  in afs_query_for_alias_one()
166 	/* The new cell has a like-named volume also - compare volume ID,  in afs_query_for_alias_one()
170 	if (pvol->vid == volume->vid) {  in afs_query_for_alias_one()
173 			ret = 1;  in afs_query_for_alias_one()
183  * Query the new cell for volumes we know exist in cells we're already using.
185 static int afs_query_for_alias(struct afs_cell *cell, struct key *key)  in afs_query_for_alias()  argument
189 	_enter("%s", cell->name);  in afs_query_for_alias()
191 	if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0)  in afs_query_for_alias()
192 		return -ERESTARTSYS;  in afs_query_for_alias()
194 	hlist_for_each_entry(p, &cell->net->proc_cells, proc_link) {  in afs_query_for_alias()
195 		if (p == cell || p->alias_of)  in afs_query_for_alias()
197 		if (RB_EMPTY_ROOT(&p->volumes))  in afs_query_for_alias()
199 		if (p->root_volume)  in afs_query_for_alias()
200 			continue; /* Ignore cells that have a root.cell volume. */  in afs_query_for_alias()
202 		mutex_unlock(&cell->net->proc_cells_lock);  in afs_query_for_alias()
204 		if (afs_query_for_alias_one(cell, key, p) != 0)  in afs_query_for_alias()
207 		if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0) {  in afs_query_for_alias()
208 			afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias);  in afs_query_for_alias()
209 			return -ERESTARTSYS;  in afs_query_for_alias()
212 		afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias);  in afs_query_for_alias()
215 	mutex_unlock(&cell->net->proc_cells_lock);  in afs_query_for_alias()
220 	cell->alias_of = p; /* Transfer our ref */  in afs_query_for_alias()
221 	return 1;  in afs_query_for_alias()
227 static char *afs_vl_get_cell_name(struct afs_cell *cell, struct key *key)  in afs_vl_get_cell_name()  argument
230 	char *cell_name = ERR_PTR(-EDESTADDRREQ);  in afs_vl_get_cell_name()
234 	if (!afs_begin_vlserver_operation(&vc, cell, key))  in afs_vl_get_cell_name()
235 		return ERR_PTR(-ERESTARTSYS);  in afs_vl_get_cell_name()
238 		if (!test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) {  in afs_vl_get_cell_name()
239 			vc.call_error = -EOPNOTSUPP;  in afs_vl_get_cell_name()
249 		ret = -EOPNOTSUPP;  in afs_vl_get_cell_name()
253 static int yfs_check_canonical_cell_name(struct afs_cell *cell, struct key *key)  in yfs_check_canonical_cell_name()  argument
259 	cell_name = afs_vl_get_cell_name(cell, key);  in yfs_check_canonical_cell_name()
263 	if (strcmp(cell_name, cell->name) == 0) {  in yfs_check_canonical_cell_name()
270 		master = ERR_PTR(-EOPNOTSUPP);  in yfs_check_canonical_cell_name()
272 		master = afs_lookup_cell(cell->net, cell_name, name_len, NULL, false);  in yfs_check_canonical_cell_name()
277 	cell->alias_of = master; /* Transfer our ref */  in yfs_check_canonical_cell_name()
278 	return 1;  in yfs_check_canonical_cell_name()
281 static int afs_do_cell_detect_alias(struct afs_cell *cell, struct key *key)  in afs_do_cell_detect_alias()  argument
286 	_enter("%s", cell->name);  in afs_do_cell_detect_alias()
288 	ret = yfs_check_canonical_cell_name(cell, key);  in afs_do_cell_detect_alias()
289 	if (ret != -EOPNOTSUPP)  in afs_do_cell_detect_alias()
292 	/* Try and get the root.cell volume for comparison with other cells */  in afs_do_cell_detect_alias()
293 	root_volume = afs_sample_volume(cell, key, "root.cell", 9);  in afs_do_cell_detect_alias()
295 		cell->root_volume = root_volume;  in afs_do_cell_detect_alias()
296 		return afs_compare_cell_roots(cell);  in afs_do_cell_detect_alias()
299 	if (PTR_ERR(root_volume) != -ENOMEDIUM)  in afs_do_cell_detect_alias()
302 	/* Okay, this cell doesn't have an root.cell volume.  We need to  in afs_do_cell_detect_alias()
305 	return afs_query_for_alias(cell, key);  in afs_do_cell_detect_alias()
309  * Check to see if a new cell is an alias of a cell we already have.  At this
310  * point we have the cell's volume server list.
312  * Returns 0 if we didn't detect an alias, 1 if we found an alias and an error
314  * detect an alias, cell->alias_of is set to point to the assumed master.
316 int afs_cell_detect_alias(struct afs_cell *cell, struct key *key)  in afs_cell_detect_alias()  argument
318 	struct afs_net *net = cell->net;  in afs_cell_detect_alias()
321 	if (mutex_lock_interruptible(&net->cells_alias_lock) < 0)  in afs_cell_detect_alias()
322 		return -ERESTARTSYS;  in afs_cell_detect_alias()
324 	if (test_bit(AFS_CELL_FL_CHECK_ALIAS, &cell->flags)) {  in afs_cell_detect_alias()
325 		ret = afs_do_cell_detect_alias(cell, key);  in afs_cell_detect_alias()
327 			clear_bit_unlock(AFS_CELL_FL_CHECK_ALIAS, &cell->flags);  in afs_cell_detect_alias()
329 		ret = cell->alias_of ? 1 : 0;  in afs_cell_detect_alias()
332 	mutex_unlock(&net->cells_alias_lock);  in afs_cell_detect_alias()
334 	if (ret == 1)  in afs_cell_detect_alias()
335 		pr_notice("kAFS: Cell %s is an alias of %s\n",  in afs_cell_detect_alias()
336 			  cell->name, cell->alias_of->name);  in afs_cell_detect_alias()