[linux.git] / fs / afs / addr_prefs.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* Address preferences management
 *
 * Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": addr_prefs: " fmt
#include <linux/slab.h>
#include <linux/ctype.h>
#include <linux/inet.h>
#include <linux/seq_file.h>
#include <keys/rxrpc-type.h>
#include "internal.h"

static inline struct afs_net *afs_seq2net_single(struct seq_file *m)
{
	return afs_net(seq_file_single_net(m));
}

/*
 * Split a NUL-terminated string up to the first newline around spaces.  The
 * source string will be modified to have NUL-terminations inserted.
 */
static int afs_split_string(char **pbuf, char *strv[], unsigned int maxstrv)
{
	unsigned int count = 0;
	char *p = *pbuf;

	maxstrv--; /* Allow for terminal NULL */
	for (;;) {
		/* Skip over spaces */
		while (isspace(*p)) {
			if (*p == '\n') {
				p++;
				break;
			}
			p++;
		}
		if (!*p)
			break;

		/* Mark start of word */
		if (count >= maxstrv) {
			pr_warn("Too many elements in string\n");
			return -EINVAL;
		}
		strv[count++] = p;

		/* Skip over word */
		while (!isspace(*p))
			p++;
		if (!*p)
			break;

		/* Mark end of word */
		if (*p == '\n') {
			*p++ = 0;
			break;
		}
		*p++ = 0;
	}

	*pbuf = p;
	strv[count] = NULL;
	return count;
}

/*
 * Parse an address with an optional subnet mask.
 */
static int afs_parse_address(char *p, struct afs_addr_preference *pref)
{
	const char *stop;
	unsigned long mask, tmp;
	char *end = p + strlen(p);
	bool bracket = false;

	if (*p == '[') {
		p++;
		bracket = true;
	}

#if 0
	if (*p == '[') {
		p++;
		q = memchr(p, ']', end - p);
		if (!q) {
			pr_warn("Can't find closing ']'\n");
			return -EINVAL;
		}
	} else {
		for (q = p; q < end; q++)
			if (*q == '/')
				break;
	}
#endif

	if (in4_pton(p, end - p, (u8 *)&pref->ipv4_addr, -1, &stop)) {
		pref->family = AF_INET;
		mask = 32;
	} else if (in6_pton(p, end - p, (u8 *)&pref->ipv6_addr, -1, &stop)) {
		pref->family = AF_INET6;
		mask = 128;
	} else {
		pr_warn("Can't determine address family\n");
		return -EINVAL;
	}

	p = (char *)stop;
	if (bracket) {
		if (*p != ']') {
			pr_warn("Can't find closing ']'\n");
			return -EINVAL;
		}
		p++;
	}

	if (*p == '/') {
		p++;
		tmp = simple_strtoul(p, &p, 10);
		if (tmp > mask) {
			pr_warn("Subnet mask too large\n");
			return -EINVAL;
		}
		if (tmp == 0) {
			pr_warn("Subnet mask too small\n");
			return -EINVAL;
		}
		mask = tmp;
	}

	if (*p) {
		pr_warn("Invalid address\n");
		return -EINVAL;
	}

	pref->subnet_mask = mask;
	return 0;
}

enum cmp_ret {
	CONTINUE_SEARCH,
	INSERT_HERE,
	EXACT_MATCH,
	SUBNET_MATCH,
};

/*
 * See if a candidate address matches a listed address.
 */
static enum cmp_ret afs_cmp_address_pref(const struct afs_addr_preference *a,
					 const struct afs_addr_preference *b)
{
	int subnet = min(a->subnet_mask, b->subnet_mask);
	const __be32 *pa, *pb;
	u32 mask, na, nb;
	int diff;

	if (a->family != b->family)
		return INSERT_HERE;

	switch (a->family) {
	case AF_INET6:
		pa = a->ipv6_addr.s6_addr32;
		pb = b->ipv6_addr.s6_addr32;
		break;
	case AF_INET:
		pa = &a->ipv4_addr.s_addr;
		pb = &b->ipv4_addr.s_addr;
		break;
	}

	while (subnet > 32) {
		diff = ntohl(*pa++) - ntohl(*pb++);
		if (diff < 0)
			return INSERT_HERE; /* a<b */
		if (diff > 0)
			return CONTINUE_SEARCH; /* a>b */
		subnet -= 32;
	}

	if (subnet == 0)
		return EXACT_MATCH;

	mask = 0xffffffffU << (32 - subnet);
	na = ntohl(*pa);
	nb = ntohl(*pb);
	diff = (na & mask) - (nb & mask);
	//kdebug("diff %08x %08x %08x %d", na, nb, mask, diff);
	if (diff < 0)
		return INSERT_HERE; /* a<b */
	if (diff > 0)
		return CONTINUE_SEARCH; /* a>b */
	if (a->subnet_mask == b->subnet_mask)
		return EXACT_MATCH;
	if (a->subnet_mask > b->subnet_mask)
		return SUBNET_MATCH; /* a binds tighter than b */
	return CONTINUE_SEARCH; /* b binds tighter than a */
}

/*
 * Insert an address preference.
 */
static int afs_insert_address_pref(struct afs_addr_preference_list **_preflist,
				   struct afs_addr_preference *pref,
				   int index)
{
	struct afs_addr_preference_list *preflist = *_preflist, *old = preflist;
	size_t size, max_prefs;

	_enter("{%u/%u/%u},%u", preflist->ipv6_off, preflist->nr, preflist->max_prefs, index);

	if (preflist->nr == 255)
		return -ENOSPC;
	if (preflist->nr >= preflist->max_prefs) {
		max_prefs = preflist->max_prefs + 1;
		size = struct_size(preflist, prefs, max_prefs);
		size = roundup_pow_of_two(size);
		max_prefs = min_t(size_t, (size - sizeof(*preflist)) / sizeof(*pref), 255);
		preflist = kmalloc(size, GFP_KERNEL);
		if (!preflist)
			return -ENOMEM;
		*preflist = **_preflist;
		preflist->max_prefs = max_prefs;
		*_preflist = preflist;

		if (index < preflist->nr)
			memcpy(preflist->prefs + index + 1, old->prefs + index,
			       sizeof(*pref) * (preflist->nr - index));
		if (index > 0)
			memcpy(preflist->prefs, old->prefs, sizeof(*pref) * index);
	} else {
		if (index < preflist->nr)
			memmove(preflist->prefs + index + 1, preflist->prefs + index,
			       sizeof(*pref) * (preflist->nr - index));
	}

	preflist->prefs[index] = *pref;
	preflist->nr++;
	if (pref->family == AF_INET)
		preflist->ipv6_off++;
	return 0;
}

/*
 * Add an address preference.
 *	echo "add <proto> <IP>[/<mask>] <prior>" >/proc/fs/afs/addr_prefs
 */
static int afs_add_address_pref(struct afs_net *net, struct afs_addr_preference_list **_preflist,
				int argc, char **argv)
{
	struct afs_addr_preference_list *preflist = *_preflist;
	struct afs_addr_preference pref;
	enum cmp_ret cmp;
	int ret, i, stop;

	if (argc != 3) {
		pr_warn("Wrong number of params\n");
		return -EINVAL;
	}

	if (strcmp(argv[0], "udp") != 0) {
		pr_warn("Unsupported protocol\n");
		return -EINVAL;
	}

	ret = afs_parse_address(argv[1], &pref);
	if (ret < 0)
		return ret;

	ret = kstrtou16(argv[2], 10, &pref.prio);
	if (ret < 0) {
		pr_warn("Invalid priority\n");
		return ret;
	}

	if (pref.family == AF_INET) {
		i = 0;
		stop = preflist->ipv6_off;
	} else {
		i = preflist->ipv6_off;
		stop = preflist->nr;
	}

	for (; i < stop; i++) {
		cmp = afs_cmp_address_pref(&pref, &preflist->prefs[i]);
		switch (cmp) {
		case CONTINUE_SEARCH:
			continue;
		case INSERT_HERE:
		case SUBNET_MATCH:
			return afs_insert_address_pref(_preflist, &pref, i);
		case EXACT_MATCH:
			preflist->prefs[i].prio = pref.prio;
			return 0;
		}
	}

	return afs_insert_address_pref(_preflist, &pref, i);
}

/*
 * Delete an address preference.
 */
static int afs_delete_address_pref(struct afs_addr_preference_list **_preflist,
				   int index)
{
	struct afs_addr_preference_list *preflist = *_preflist;

	_enter("{%u/%u/%u},%u", preflist->ipv6_off, preflist->nr, preflist->max_prefs, index);

	if (preflist->nr == 0)
		return -ENOENT;

	if (index < preflist->nr - 1)
		memmove(preflist->prefs + index, preflist->prefs + index + 1,
			sizeof(preflist->prefs[0]) * (preflist->nr - index - 1));

	if (index < preflist->ipv6_off)
		preflist->ipv6_off--;
	preflist->nr--;
	return 0;
}

/*
 * Delete an address preference.
 *	echo "del <proto> <IP>[/<mask>]" >/proc/fs/afs/addr_prefs
 */
static int afs_del_address_pref(struct afs_net *net, struct afs_addr_preference_list **_preflist,
				int argc, char **argv)
{
	struct afs_addr_preference_list *preflist = *_preflist;
	struct afs_addr_preference pref;
	enum cmp_ret cmp;
	int ret, i, stop;

	if (argc != 2) {
		pr_warn("Wrong number of params\n");
		return -EINVAL;
	}

	if (strcmp(argv[0], "udp") != 0) {
		pr_warn("Unsupported protocol\n");
		return -EINVAL;
	}

	ret = afs_parse_address(argv[1], &pref);
	if (ret < 0)
		return ret;

	if (pref.family == AF_INET) {
		i = 0;
		stop = preflist->ipv6_off;
	} else {
		i = preflist->ipv6_off;
		stop = preflist->nr;
	}

	for (; i < stop; i++) {
		cmp = afs_cmp_address_pref(&pref, &preflist->prefs[i]);
		switch (cmp) {
		case CONTINUE_SEARCH:
			continue;
		case INSERT_HERE:
		case SUBNET_MATCH:
			return 0;
		case EXACT_MATCH:
			return afs_delete_address_pref(_preflist, i);
		}
	}

	return -ENOANO;
}

/*
 * Handle writes to /proc/fs/afs/addr_prefs
 */
int afs_proc_addr_prefs_write(struct file *file, char *buf, size_t size)
{
	struct afs_addr_preference_list *preflist, *old;
	struct seq_file *m = file->private_data;
	struct afs_net *net = afs_seq2net_single(m);
	size_t psize;
	char *argv[5];
	int ret, argc, max_prefs;

	inode_lock(file_inode(file));

	/* Allocate a candidate new list and initialise it from the old. */
	old = rcu_dereference_protected(net->address_prefs,
					lockdep_is_held(&file_inode(file)->i_rwsem));

	if (old)
		max_prefs = old->nr + 1;
	else
		max_prefs = 1;

	psize = struct_size(old, prefs, max_prefs);
	psize = roundup_pow_of_two(psize);
	max_prefs = min_t(size_t, (psize - sizeof(*old)) / sizeof(old->prefs[0]), 255);

	ret = -ENOMEM;
	preflist = kmalloc(struct_size(preflist, prefs, max_prefs), GFP_KERNEL);
	if (!preflist)
		goto done;

	if (old)
		memcpy(preflist, old, struct_size(preflist, prefs, old->nr));
	else
		memset(preflist, 0, sizeof(*preflist));
	preflist->max_prefs = max_prefs;

	do {
		argc = afs_split_string(&buf, argv, ARRAY_SIZE(argv));
		if (argc < 0)
			return argc;
		if (argc < 2)
			goto inval;

		if (strcmp(argv[0], "add") == 0)
			ret = afs_add_address_pref(net, &preflist, argc - 1, argv + 1);
		else if (strcmp(argv[0], "del") == 0)
			ret = afs_del_address_pref(net, &preflist, argc - 1, argv + 1);
		else
			goto inval;
		if (ret < 0)
			goto done;
	} while (*buf);

	preflist->version++;
	rcu_assign_pointer(net->address_prefs, preflist);
	/* Store prefs before version */
	smp_store_release(&net->address_pref_version, preflist->version);
	kfree_rcu(old, rcu);
	preflist = NULL;
	ret = 0;

done:
	kfree(preflist);
	inode_unlock(file_inode(file));
	_leave(" = %d", ret);
	return ret;

inval:
	pr_warn("Invalid Command\n");
	ret = -EINVAL;
	goto done;
}

/*
 * Mark the priorities on an address list if the address preferences table has
 * changed.  The caller must hold the RCU read lock.
 */
void afs_get_address_preferences_rcu(struct afs_net *net, struct afs_addr_list *alist)
{
	const struct afs_addr_preference_list *preflist =
		rcu_dereference(net->address_prefs);
	const struct sockaddr_in6 *sin6;
	const struct sockaddr_in *sin;
	const struct sockaddr *sa;
	struct afs_addr_preference test;
	enum cmp_ret cmp;
	int i, j;

	if (!preflist || !preflist->nr || !alist->nr_addrs ||
	    smp_load_acquire(&alist->addr_pref_version) == preflist->version)
		return;

	test.family = AF_INET;
	test.subnet_mask = 32;
	test.prio = 0;
	for (i = 0; i < alist->nr_ipv4; i++) {
		sa = rxrpc_kernel_remote_addr(alist->addrs[i].peer);
		sin = (const struct sockaddr_in *)sa;
		test.ipv4_addr = sin->sin_addr;
		for (j = 0; j < preflist->ipv6_off; j++) {
			cmp = afs_cmp_address_pref(&test, &preflist->prefs[j]);
			switch (cmp) {
			case CONTINUE_SEARCH:
				continue;
			case INSERT_HERE:
				break;
			case EXACT_MATCH:
			case SUBNET_MATCH:
				WRITE_ONCE(alist->addrs[i].prio, preflist->prefs[j].prio);
				break;
			}
		}
	}

	test.family = AF_INET6;
	test.subnet_mask = 128;
	test.prio = 0;
	for (; i < alist->nr_addrs; i++) {
		sa = rxrpc_kernel_remote_addr(alist->addrs[i].peer);
		sin6 = (const struct sockaddr_in6 *)sa;
		test.ipv6_addr = sin6->sin6_addr;
		for (j = preflist->ipv6_off; j < preflist->nr; j++) {
			cmp = afs_cmp_address_pref(&test, &preflist->prefs[j]);
			switch (cmp) {
			case CONTINUE_SEARCH:
				continue;
			case INSERT_HERE:
				break;
			case EXACT_MATCH:
			case SUBNET_MATCH:
				WRITE_ONCE(alist->addrs[i].prio, preflist->prefs[j].prio);
				break;
			}
		}
	}

	smp_store_release(&alist->addr_pref_version, preflist->version);
}

/*
 * Mark the priorities on an address list if the address preferences table has
 * changed.  Avoid taking the RCU read lock if we can.
 */
void afs_get_address_preferences(struct afs_net *net, struct afs_addr_list *alist)
{
	if (!net->address_prefs ||
	    /* Load version before prefs */
	    smp_load_acquire(&net->address_pref_version) == alist->addr_pref_version)
		return;

	rcu_read_lock();
	afs_get_address_preferences_rcu(net, alist);
	rcu_read_unlock();
}
Commit	Line	Data
f94f70d3 DH	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/* Address preferences management
	3	*
	4	* Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells ([email protected])
	6	*/
	7
	8	#define pr_fmt(fmt) KBUILD_MODNAME ": addr_prefs: " fmt
	9	#include <linux/slab.h>
	10	#include <linux/ctype.h>
	11	#include <linux/inet.h>
	12	#include <linux/seq_file.h>
	13	#include <keys/rxrpc-type.h>
	14	#include "internal.h"
	15
	16	static inline struct afs_net afs_seq2net_single(struct seq_file m)
	17	{
	18	return afs_net(seq_file_single_net(m));
	19	}
	20
	21	/*
	22	* Split a NUL-terminated string up to the first newline around spaces. The
	23	* source string will be modified to have NUL-terminations inserted.
	24	*/
	25	static int afs_split_string(char *pbuf, char strv[], unsigned int maxstrv)
	26	{
	27	unsigned int count = 0;
	28	char p = pbuf;
	29
	30	maxstrv--; /* Allow for terminal NULL */
	31	for (;;) {
	32	/* Skip over spaces */
	33	while (isspace(*p)) {
	34	if (*p == '\n') {
	35	p++;
	36	break;
	37	}
	38	p++;
	39	}
	40	if (!*p)
	41	break;
	42
	43	/* Mark start of word */
	44	if (count >= maxstrv) {
	45	pr_warn("Too many elements in string\n");
	46	return -EINVAL;
	47	}
	48	strv[count++] = p;
	49
	50	/* Skip over word */
	51	while (!isspace(*p))
	52	p++;
	53	if (!*p)
	54	break;
	55
	56	/* Mark end of word */
	57	if (*p == '\n') {
	58	*p++ = 0;
	59	break;
	60	}
	61	*p++ = 0;
	62	}
	63
	64	*pbuf = p;
65	strv[count] = NULL;
66	return count;
67	}
68
69	/*
70	* Parse an address with an optional subnet mask.
71	*/
72	static int afs_parse_address(char p, struct afs_addr_preference pref)
73	{
74	const char *stop;
75	unsigned long mask, tmp;
76	char *end = p + strlen(p);
77	bool bracket = false;
78
79	if (*p == '[') {
80	p++;
81	bracket = true;
82	}
83
84	#if 0
85	if (*p == '[') {
86	p++;
87	q = memchr(p, ']', end - p);
88	if (!q) {
89	pr_warn("Can't find closing ']'\n");
90	return -EINVAL;
91	}
92	} else {
93	for (q = p; q < end; q++)
94	if (*q == '/')
95	break;
96	}
97	#endif
98
99	if (in4_pton(p, end - p, (u8 *)&pref->ipv4_addr, -1, &stop)) {
100	pref->family = AF_INET;
101	mask = 32;
102	} else if (in6_pton(p, end - p, (u8 *)&pref->ipv6_addr, -1, &stop)) {
103	pref->family = AF_INET6;
104	mask = 128;
105	} else {
106	pr_warn("Can't determine address family\n");
107	return -EINVAL;
108	}
109
110	p = (char *)stop;
111	if (bracket) {
112	if (*p != ']') {
113	pr_warn("Can't find closing ']'\n");
114	return -EINVAL;
115	}
116	p++;
117	}
118
119	if (*p == '/') {
120	p++;
121	tmp = simple_strtoul(p, &p, 10);
122	if (tmp > mask) {
123	pr_warn("Subnet mask too large\n");
124	return -EINVAL;
125	}
126	if (tmp == 0) {
127	pr_warn("Subnet mask too small\n");
128	return -EINVAL;
129	}
130	mask = tmp;
131	}
132
133	if (*p) {
134	pr_warn("Invalid address\n");
135	return -EINVAL;
136	}
137
138	pref->subnet_mask = mask;
139	return 0;
140	}
141
142	enum cmp_ret {
143	CONTINUE_SEARCH,
144	INSERT_HERE,
145	EXACT_MATCH,
146	SUBNET_MATCH,
147	};
148
149	/*
150	* See if a candidate address matches a listed address.
151	*/
152	static enum cmp_ret afs_cmp_address_pref(const struct afs_addr_preference *a,
153	const struct afs_addr_preference *b)
154	{
155	int subnet = min(a->subnet_mask, b->subnet_mask);
156	const __be32 pa, pb;
157	u32 mask, na, nb;
158	int diff;
159
160	if (a->family != b->family)
161	return INSERT_HERE;
162
163	switch (a->family) {
164	case AF_INET6:
165	pa = a->ipv6_addr.s6_addr32;
166	pb = b->ipv6_addr.s6_addr32;
167	break;
168	case AF_INET:
169	pa = &a->ipv4_addr.s_addr;
170	pb = &b->ipv4_addr.s_addr;
171	break;
172	}
173
174	while (subnet > 32) {
175	diff = ntohl(pa++) - ntohl(pb++);
176	if (diff < 0)
177	return INSERT_HERE; /* a<b */
178	if (diff > 0)
179	return CONTINUE_SEARCH; /* a>b */
180	subnet -= 32;
181	}
182
183	if (subnet == 0)
184	return EXACT_MATCH;
185
186	mask = 0xffffffffU << (32 - subnet);
187	na = ntohl(*pa);
188	nb = ntohl(*pb);
189	diff = (na & mask) - (nb & mask);
190	//kdebug("diff %08x %08x %08x %d", na, nb, mask, diff);
191	if (diff < 0)
192	return INSERT_HERE; /* a<b */
193	if (diff > 0)
194	return CONTINUE_SEARCH; /* a>b */
195	if (a->subnet_mask == b->subnet_mask)
196	return EXACT_MATCH;
197	if (a->subnet_mask > b->subnet_mask)
198	return SUBNET_MATCH; /* a binds tighter than b */
199	return CONTINUE_SEARCH; /* b binds tighter than a */
200	}
201
202	/*
203	* Insert an address preference.
204	*/
205	static int afs_insert_address_pref(struct afs_addr_preference_list **_preflist,
206	struct afs_addr_preference *pref,
207	int index)
208	{
209	struct afs_addr_preference_list preflist = _preflist, *old = preflist;
210	size_t size, max_prefs;
211
212	_enter("{%u/%u/%u},%u", preflist->ipv6_off, preflist->nr, preflist->max_prefs, index);
213
214	if (preflist->nr == 255)
215	return -ENOSPC;
216	if (preflist->nr >= preflist->max_prefs) {
217	max_prefs = preflist->max_prefs + 1;
218	size = struct_size(preflist, prefs, max_prefs);
219	size = roundup_pow_of_two(size);
220	max_prefs = min_t(size_t, (size - sizeof(preflist)) / sizeof(pref), 255);
221	preflist = kmalloc(size, GFP_KERNEL);
222	if (!preflist)
223	return -ENOMEM;
224	preflist = *_preflist;
225	preflist->max_prefs = max_prefs;
226	*_preflist = preflist;
227
228	if (index < preflist->nr)
229	memcpy(preflist->prefs + index + 1, old->prefs + index,
230	sizeof(pref) (preflist->nr - index));
231	if (index > 0)
232	memcpy(preflist->prefs, old->prefs, sizeof(pref) index);
233	} else {
234	if (index < preflist->nr)
235	memmove(preflist->prefs + index + 1, preflist->prefs + index,
236	sizeof(pref) (preflist->nr - index));
237	}
238
239	preflist->prefs[index] = *pref;
240	preflist->nr++;
241	if (pref->family == AF_INET)
242	preflist->ipv6_off++;
243	return 0;
244	}
245
246	/*
247	* Add an address preference.
248	* echo "add <proto> <IP>[/<mask>] <prior>" >/proc/fs/afs/addr_prefs
249	*/
250	static int afs_add_address_pref(struct afs_net net, struct afs_addr_preference_list *_preflist,
251	int argc, char **argv)
252	{
253	struct afs_addr_preference_list preflist = _preflist;
254	struct afs_addr_preference pref;
255	enum cmp_ret cmp;
256	int ret, i, stop;
257
258	if (argc != 3) {
259	pr_warn("Wrong number of params\n");
260	return -EINVAL;
261	}
262
263	if (strcmp(argv[0], "udp") != 0) {
264	pr_warn("Unsupported protocol\n");
265	return -EINVAL;
266	}
267
268	ret = afs_parse_address(argv[1], &pref);
269	if (ret < 0)
270	return ret;
271
272	ret = kstrtou16(argv[2], 10, &pref.prio);
273	if (ret < 0) {
274	pr_warn("Invalid priority\n");
275	return ret;
276	}
277
278	if (pref.family == AF_INET) {
279	i = 0;
280	stop = preflist->ipv6_off;
281	} else {
282	i = preflist->ipv6_off;
283	stop = preflist->nr;
284	}
285
286	for (; i < stop; i++) {
287	cmp = afs_cmp_address_pref(&pref, &preflist->prefs[i]);
288	switch (cmp) {
289	case CONTINUE_SEARCH:
290	continue;
291	case INSERT_HERE:
292	case SUBNET_MATCH:
293	return afs_insert_address_pref(_preflist, &pref, i);
294	case EXACT_MATCH:
295	preflist->prefs[i].prio = pref.prio;
296	return 0;
297	}
298	}
299
300	return afs_insert_address_pref(_preflist, &pref, i);
301	}
302
303	/*
304	* Delete an address preference.
305	*/
306	static int afs_delete_address_pref(struct afs_addr_preference_list **_preflist,
307	int index)
308	{
309	struct afs_addr_preference_list preflist = _preflist;
310
311	_enter("{%u/%u/%u},%u", preflist->ipv6_off, preflist->nr, preflist->max_prefs, index);
312
313	if (preflist->nr == 0)
314	return -ENOENT;
315
316	if (index < preflist->nr - 1)
317	memmove(preflist->prefs + index, preflist->prefs + index + 1,
318	sizeof(preflist->prefs[0]) * (preflist->nr - index - 1));
319
320	if (index < preflist->ipv6_off)
321	preflist->ipv6_off--;
322	preflist->nr--;
323	return 0;
324	}
325
326	/*
327	* Delete an address preference.
328	* echo "del <proto> <IP>[/<mask>]" >/proc/fs/afs/addr_prefs
329	*/
330	static int afs_del_address_pref(struct afs_net net, struct afs_addr_preference_list *_preflist,
331	int argc, char **argv)
332	{
333	struct afs_addr_preference_list preflist = _preflist;
334	struct afs_addr_preference pref;
335	enum cmp_ret cmp;
336	int ret, i, stop;
337
338	if (argc != 2) {
339	pr_warn("Wrong number of params\n");
340	return -EINVAL;
341	}
342
343	if (strcmp(argv[0], "udp") != 0) {
344	pr_warn("Unsupported protocol\n");
345	return -EINVAL;
346	}
347
348	ret = afs_parse_address(argv[1], &pref);
349	if (ret < 0)
350	return ret;
351
352	if (pref.family == AF_INET) {
353	i = 0;
354	stop = preflist->ipv6_off;
355	} else {
356	i = preflist->ipv6_off;
357	stop = preflist->nr;
358	}
359
360	for (; i < stop; i++) {
361	cmp = afs_cmp_address_pref(&pref, &preflist->prefs[i]);
362	switch (cmp) {
363	case CONTINUE_SEARCH:
364	continue;
365	case INSERT_HERE:
366	case SUBNET_MATCH:
367	return 0;
368	case EXACT_MATCH:
369	return afs_delete_address_pref(_preflist, i);
370	}
371	}
372
373	return -ENOANO;
374	}
375
376	/*
377	* Handle writes to /proc/fs/afs/addr_prefs
378	*/
379	int afs_proc_addr_prefs_write(struct file file, char buf, size_t size)
380	{
381	struct afs_addr_preference_list preflist, old;
382	struct seq_file *m = file->private_data;
383	struct afs_net *net = afs_seq2net_single(m);
384	size_t psize;
385	char *argv[5];
386	int ret, argc, max_prefs;
387
388	inode_lock(file_inode(file));
389
390	/* Allocate a candidate new list and initialise it from the old. */
391	old = rcu_dereference_protected(net->address_prefs,
392	lockdep_is_held(&file_inode(file)->i_rwsem));
393
394	if (old)
395	max_prefs = old->nr + 1;
396	else
397	max_prefs = 1;
398
399	psize = struct_size(old, prefs, max_prefs);
400	psize = roundup_pow_of_two(psize);
401	max_prefs = min_t(size_t, (psize - sizeof(*old)) / sizeof(old->prefs[0]), 255);
402
403	ret = -ENOMEM;
404	preflist = kmalloc(struct_size(preflist, prefs, max_prefs), GFP_KERNEL);
405	if (!preflist)
406	goto done;
407
408	if (old)
409	memcpy(preflist, old, struct_size(preflist, prefs, old->nr));
410	else
411	memset(preflist, 0, sizeof(*preflist));
412	preflist->max_prefs = max_prefs;
413
414	do {
415	argc = afs_split_string(&buf, argv, ARRAY_SIZE(argv));
416	if (argc < 0)
417	return argc;
418	if (argc < 2)
419	goto inval;
420
421	if (strcmp(argv[0], "add") == 0)
422	ret = afs_add_address_pref(net, &preflist, argc - 1, argv + 1);
423	else if (strcmp(argv[0], "del") == 0)
424	ret = afs_del_address_pref(net, &preflist, argc - 1, argv + 1);
425	else
426	goto inval;
427	if (ret < 0)
428	goto done;
429	} while (*buf);
430
431	preflist->version++;
432	rcu_assign_pointer(net->address_prefs, preflist);
433	/* Store prefs before version */
434	smp_store_release(&net->address_pref_version, preflist->version);
435	kfree_rcu(old, rcu);
436	preflist = NULL;
437	ret = 0;
438
439	done:
440	kfree(preflist);
441	inode_unlock(file_inode(file));
442	_leave(" = %d", ret);
443	return ret;
444
445	inval:
446	pr_warn("Invalid Command\n");
447	ret = -EINVAL;
448	goto done;
449	}
d14cf8ed DH	450
	451	/*
	452	* Mark the priorities on an address list if the address preferences table has
	453	* changed. The caller must hold the RCU read lock.
	454	*/
	455	void afs_get_address_preferences_rcu(struct afs_net net, struct afs_addr_list alist)
	456	{
	457	const struct afs_addr_preference_list *preflist =
	458	rcu_dereference(net->address_prefs);
	459	const struct sockaddr_in6 *sin6;
	460	const struct sockaddr_in *sin;
	461	const struct sockaddr *sa;
	462	struct afs_addr_preference test;
	463	enum cmp_ret cmp;
	464	int i, j;
	465
	466	if (!preflist \|\| !preflist->nr \|\| !alist->nr_addrs \|\|
	467	smp_load_acquire(&alist->addr_pref_version) == preflist->version)
	468	return;
	469
	470	test.family = AF_INET;
	471	test.subnet_mask = 32;
	472	test.prio = 0;
	473	for (i = 0; i < alist->nr_ipv4; i++) {
	474	sa = rxrpc_kernel_remote_addr(alist->addrs[i].peer);
	475	sin = (const struct sockaddr_in *)sa;
	476	test.ipv4_addr = sin->sin_addr;
	477	for (j = 0; j < preflist->ipv6_off; j++) {
	478	cmp = afs_cmp_address_pref(&test, &preflist->prefs[j]);
	479	switch (cmp) {
	480	case CONTINUE_SEARCH:
	481	continue;
	482	case INSERT_HERE:
	483	break;
	484	case EXACT_MATCH:
	485	case SUBNET_MATCH:
	486	WRITE_ONCE(alist->addrs[i].prio, preflist->prefs[j].prio);
	487	break;
	488	}
	489	}
	490	}
	491
	492	test.family = AF_INET6;
	493	test.subnet_mask = 128;
	494	test.prio = 0;
	495	for (; i < alist->nr_addrs; i++) {
	496	sa = rxrpc_kernel_remote_addr(alist->addrs[i].peer);
	497	sin6 = (const struct sockaddr_in6 *)sa;
	498	test.ipv6_addr = sin6->sin6_addr;
	499	for (j = preflist->ipv6_off; j < preflist->nr; j++) {
	500	cmp = afs_cmp_address_pref(&test, &preflist->prefs[j]);
	501	switch (cmp) {
	502	case CONTINUE_SEARCH:
	503	continue;
	504	case INSERT_HERE:
	505	break;
	506	case EXACT_MATCH:
	507	case SUBNET_MATCH:
	508	WRITE_ONCE(alist->addrs[i].prio, preflist->prefs[j].prio);
	509	break;
	510	}
	511	}
	512	}
	513
514	smp_store_release(&alist->addr_pref_version, preflist->version);
515	}
516
517	/*
518	* Mark the priorities on an address list if the address preferences table has
519	* changed. Avoid taking the RCU read lock if we can.
520	*/
521	void afs_get_address_preferences(struct afs_net net, struct afs_addr_list alist)
522	{
523	if (!net->address_prefs \|\|
524	/* Load version before prefs */
525	smp_load_acquire(&net->address_pref_version) == alist->addr_pref_version)
526	return;
527
528	rcu_read_lock();
529	afs_get_address_preferences_rcu(net, alist);
530	rcu_read_unlock();
531	}