forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da 
 kernel/fs/afs/addr_list.c
....@@ -1,12 +1,8 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /* Server address list management
23  *
34  * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
45  * 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 Licence
8
- * as published by the Free Software Foundation; either version
9
- * 2 of the Licence, or (at your option) any later version.
106  */
117 
128 #include <linux/slab.h>
....@@ -17,18 +13,13 @@
1713 #include "internal.h"
1814 #include "afs_fs.h"
1915 
20
-//#define AFS_MAX_ADDRESSES
21
-//	((unsigned int)((PAGE_SIZE - sizeof(struct afs_addr_list)) /
22
-//			sizeof(struct sockaddr_rxrpc)))
23
-#define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8))
24
-
2516 /*
2617  * Release an address list.
2718  */
2819 void afs_put_addrlist(struct afs_addr_list *alist)
2920 {
3021 	if (alist && refcount_dec_and_test(&alist->usage))
31
-		call_rcu(&alist->rcu, (rcu_callback_t)kfree);
22
+		kfree_rcu(alist, rcu);
3223 }
3324 
3425 /*
....@@ -43,11 +34,15 @@
4334 
4435 	_enter("%u,%u,%u", nr, service, port);
4536 
37
+	if (nr > AFS_MAX_ADDRESSES)
38
+		nr = AFS_MAX_ADDRESSES;
39
+
4640 	alist = kzalloc(struct_size(alist, addrs, nr), GFP_KERNEL);
4741 	if (!alist)
4842 		return NULL;
4943 
5044 	refcount_set(&alist->usage, 1);
45
+	alist->max_addrs = nr;
5146 
5247 	for (i = 0; i < nr; i++) {
5348 		struct sockaddr_rxrpc *srx = &alist->addrs[i];
....@@ -65,19 +60,25 @@
6560 /*
6661  * Parse a text string consisting of delimited addresses.
6762  */
68
-struct afs_addr_list *afs_parse_text_addrs(const char *text, size_t len,
69
-					   char delim,
70
-					   unsigned short service,
71
-					   unsigned short port)
63
+struct afs_vlserver_list *afs_parse_text_addrs(struct afs_net *net,
64
+					       const char *text, size_t len,
65
+					       char delim,
66
+					       unsigned short service,
67
+					       unsigned short port)
7268 {
69
+	struct afs_vlserver_list *vllist;
7370 	struct afs_addr_list *alist;
7471 	const char *p, *end = text + len;
72
+	const char *problem;
7573 	unsigned int nr = 0;
74
+	int ret = -ENOMEM;
7675 
7776 	_enter("%*.*s,%c", (int)len, (int)len, text, delim);
7877 
79
-	if (!len)
78
+	if (!len) {
79
+		_leave(" = -EDESTADDRREQ [empty]");
8080 		return ERR_PTR(-EDESTADDRREQ);
81
+	}
8182 
8283 	if (delim == ':' && (memchr(text, ',', len) || !memchr(text, '.', len)))
8384 		delim = ',';
....@@ -85,18 +86,24 @@
8586 	/* Count the addresses */
8687 	p = text;
8788 	do {
88
-		if (!*p)
89
-			return ERR_PTR(-EINVAL);
89
+		if (!*p) {
90
+			problem = "nul";
91
+			goto inval;
92
+		}
9093 		if (*p == delim)
9194 			continue;
9295 		nr++;
9396 		if (*p == '[') {
9497 			p++;
95
-			if (p == end)
96
-				return ERR_PTR(-EINVAL);
98
+			if (p == end) {
99
+				problem = "brace1";
100
+				goto inval;
101
+			}
97102 			p = memchr(p, ']', end - p);
98
-			if (!p)
99
-				return ERR_PTR(-EINVAL);
103
+			if (!p) {
104
+				problem = "brace2";
105
+				goto inval;
106
+			}
100107 			p++;
101108 			if (p >= end)
102109 				break;
....@@ -109,18 +116,27 @@
109116 	} while (p < end);
110117 
111118 	_debug("%u/%u addresses", nr, AFS_MAX_ADDRESSES);
112
-	if (nr > AFS_MAX_ADDRESSES)
113
-		nr = AFS_MAX_ADDRESSES;
114119 
115
-	alist = afs_alloc_addrlist(nr, service, port);
116
-	if (!alist)
120
+	vllist = afs_alloc_vlserver_list(1);
121
+	if (!vllist)
117122 		return ERR_PTR(-ENOMEM);
123
+
124
+	vllist->nr_servers = 1;
125
+	vllist->servers[0].server = afs_alloc_vlserver("<dummy>", 7, AFS_VL_PORT);
126
+	if (!vllist->servers[0].server)
127
+		goto error_vl;
128
+
129
+	alist = afs_alloc_addrlist(nr, service, AFS_VL_PORT);
130
+	if (!alist)
131
+		goto error;
118132 
119133 	/* Extract the addresses */
120134 	p = text;
121135 	do {
122
-		struct sockaddr_rxrpc *srx = &alist->addrs[alist->nr_addrs];
123136 		const char *q, *stop;
137
+		unsigned int xport = port;
138
+		__be32 x[4];
139
+		int family;
124140 
125141 		if (*p == delim) {
126142 			p++;
....@@ -136,58 +152,74 @@
136152 					break;
137153 		}
138154 
139
-		if (in4_pton(p, q - p,
140
-			     (u8 *)&srx->transport.sin6.sin6_addr.s6_addr32[3],
141
-			     -1, &stop)) {
142
-			srx->transport.sin6.sin6_addr.s6_addr32[0] = 0;
143
-			srx->transport.sin6.sin6_addr.s6_addr32[1] = 0;
144
-			srx->transport.sin6.sin6_addr.s6_addr32[2] = htonl(0xffff);
145
-		} else if (in6_pton(p, q - p,
146
-				    srx->transport.sin6.sin6_addr.s6_addr,
147
-				    -1, &stop)) {
148
-			/* Nothing to do */
155
+		if (in4_pton(p, q - p, (u8 *)&x[0], -1, &stop)) {
156
+			family = AF_INET;
157
+		} else if (in6_pton(p, q - p, (u8 *)x, -1, &stop)) {
158
+			family = AF_INET6;
149159 		} else {
160
+			problem = "family";
150161 			goto bad_address;
151162 		}
152163 
153
-		if (stop != q)
154
-			goto bad_address;
155
-
156164 		p = q;
165
+		if (stop != p) {
166
+			problem = "nostop";
167
+			goto bad_address;
168
+		}
169
+
157170 		if (q < end && *q == ']')
158171 			p++;
159172 
160173 		if (p < end) {
161174 			if (*p == '+') {
162175 				/* Port number specification "+1234" */
163
-				unsigned int xport = 0;
176
+				xport = 0;
164177 				p++;
165
-				if (p >= end || !isdigit(*p))
178
+				if (p >= end || !isdigit(*p)) {
179
+					problem = "port";
166180 					goto bad_address;
181
+				}
167182 				do {
168183 					xport *= 10;
169184 					xport += *p - '0';
170
-					if (xport > 65535)
185
+					if (xport > 65535) {
186
+						problem = "pval";
171187 						goto bad_address;
188
+					}
172189 					p++;
173190 				} while (p < end && isdigit(*p));
174
-				srx->transport.sin6.sin6_port = htons(xport);
175191 			} else if (*p == delim) {
176192 				p++;
177193 			} else {
194
+				problem = "weird";
178195 				goto bad_address;
179196 			}
180197 		}
181198 
182
-		alist->nr_addrs++;
183
-	} while (p < end && alist->nr_addrs < AFS_MAX_ADDRESSES);
199
+		if (family == AF_INET)
200
+			afs_merge_fs_addr4(alist, x[0], xport);
201
+		else
202
+			afs_merge_fs_addr6(alist, x, xport);
184203 
204
+	} while (p < end);
205
+
206
+	rcu_assign_pointer(vllist->servers[0].server->addresses, alist);
185207 	_leave(" = [nr %u]", alist->nr_addrs);
186
-	return alist;
208
+	return vllist;
187209 
188
-bad_address:
189
-	kfree(alist);
210
+inval:
211
+	_leave(" = -EINVAL [%s %zu %*.*s]",
212
+	       problem, p - text, (int)len, (int)len, text);
190213 	return ERR_PTR(-EINVAL);
214
+bad_address:
215
+	_leave(" = -EINVAL [%s %zu %*.*s]",
216
+	       problem, p - text, (int)len, (int)len, text);
217
+	ret = -EINVAL;
218
+error:
219
+	afs_put_addrlist(alist);
220
+error_vl:
221
+	afs_put_vlserverlist(net, vllist);
222
+	return ERR_PTR(ret);
191223 }
192224 
193225 /*
....@@ -206,30 +238,34 @@
206238 /*
207239  * Perform a DNS query for VL servers and build a up an address list.
208240  */
209
-struct afs_addr_list *afs_dns_query(struct afs_cell *cell, time64_t *_expiry)
241
+struct afs_vlserver_list *afs_dns_query(struct afs_cell *cell, time64_t *_expiry)
210242 {
211
-	struct afs_addr_list *alist;
212
-	char *vllist = NULL;
243
+	struct afs_vlserver_list *vllist;
244
+	char *result = NULL;
213245 	int ret;
214246 
215247 	_enter("%s", cell->name);
216248 
217
-	ret = dns_query("afsdb", cell->name, cell->name_len,
218
-			"", &vllist, _expiry);
219
-	if (ret < 0)
249
+	ret = dns_query(cell->net->net, "afsdb", cell->name, cell->name_len,
250
+			"srv=1", &result, _expiry, true);
251
+	if (ret < 0) {
252
+		_leave(" = %d [dns]", ret);
220253 		return ERR_PTR(ret);
221
-
222
-	alist = afs_parse_text_addrs(vllist, strlen(vllist), ',',
223
-				     VL_SERVICE, AFS_VL_PORT);
224
-	if (IS_ERR(alist)) {
225
-		kfree(vllist);
226
-		if (alist != ERR_PTR(-ENOMEM))
227
-			pr_err("Failed to parse DNS data\n");
228
-		return alist;
229254 	}
230255 
231
-	kfree(vllist);
232
-	return alist;
256
+	if (*_expiry == 0)
257
+		*_expiry = ktime_get_real_seconds() + 60;
258
+
259
+	if (ret > 1 && result[0] == 0)
260
+		vllist = afs_extract_vlserver_list(cell, result, ret);
261
+	else
262
+		vllist = afs_parse_text_addrs(cell->net, result, ret, ',',
263
+					      VL_SERVICE, AFS_VL_PORT);
264
+	kfree(result);
265
+	if (IS_ERR(vllist) && vllist != ERR_PTR(-ENOMEM))
266
+		pr_err("Failed to parse DNS data %ld\n", PTR_ERR(vllist));
267
+
268
+	return vllist;
233269 }
234270 
235271 /*
....@@ -237,19 +273,23 @@
237273  */
238274 void afs_merge_fs_addr4(struct afs_addr_list *alist, __be32 xdr, u16 port)
239275 {
240
-	struct sockaddr_in6 *a;
241
-	__be16 xport = htons(port);
276
+	struct sockaddr_rxrpc *srx;
277
+	u32 addr = ntohl(xdr);
242278 	int i;
243279 
280
+	if (alist->nr_addrs >= alist->max_addrs)
281
+		return;
282
+
244283 	for (i = 0; i < alist->nr_ipv4; i++) {
245
-		a = &alist->addrs[i].transport.sin6;
246
-		if (xdr == a->sin6_addr.s6_addr32[3] &&
247
-		    xport == a->sin6_port)
284
+		struct sockaddr_in *a = &alist->addrs[i].transport.sin;
285
+		u32 a_addr = ntohl(a->sin_addr.s_addr);
286
+		u16 a_port = ntohs(a->sin_port);
287
+
288
+		if (addr == a_addr && port == a_port)
248289 			return;
249
-		if (xdr == a->sin6_addr.s6_addr32[3] &&
250
-		    (u16 __force)xport < (u16 __force)a->sin6_port)
290
+		if (addr == a_addr && port < a_port)
251291 			break;
252
-		if ((u32 __force)xdr < (u32 __force)a->sin6_addr.s6_addr32[3])
292
+		if (addr < a_addr)
253293 			break;
254294 	}
255295 
....@@ -258,12 +298,13 @@
258298 			alist->addrs + i,
259299 			sizeof(alist->addrs[0]) * (alist->nr_addrs - i));
260300 
261
-	a = &alist->addrs[i].transport.sin6;
262
-	a->sin6_port		  = xport;
263
-	a->sin6_addr.s6_addr32[0] = 0;
264
-	a->sin6_addr.s6_addr32[1] = 0;
265
-	a->sin6_addr.s6_addr32[2] = htonl(0xffff);
266
-	a->sin6_addr.s6_addr32[3] = xdr;
301
+	srx = &alist->addrs[i];
302
+	srx->srx_family = AF_RXRPC;
303
+	srx->transport_type = SOCK_DGRAM;
304
+	srx->transport_len = sizeof(srx->transport.sin);
305
+	srx->transport.sin.sin_family = AF_INET;
306
+	srx->transport.sin.sin_port = htons(port);
307
+	srx->transport.sin.sin_addr.s_addr = xdr;
267308 	alist->nr_ipv4++;
268309 	alist->nr_addrs++;
269310 }
....@@ -273,18 +314,20 @@
273314  */
274315 void afs_merge_fs_addr6(struct afs_addr_list *alist, __be32 *xdr, u16 port)
275316 {
276
-	struct sockaddr_in6 *a;
277
-	__be16 xport = htons(port);
317
+	struct sockaddr_rxrpc *srx;
278318 	int i, diff;
279319 
320
+	if (alist->nr_addrs >= alist->max_addrs)
321
+		return;
322
+
280323 	for (i = alist->nr_ipv4; i < alist->nr_addrs; i++) {
281
-		a = &alist->addrs[i].transport.sin6;
324
+		struct sockaddr_in6 *a = &alist->addrs[i].transport.sin6;
325
+		u16 a_port = ntohs(a->sin6_port);
326
+
282327 		diff = memcmp(xdr, &a->sin6_addr, 16);
283
-		if (diff == 0 &&
284
-		    xport == a->sin6_port)
328
+		if (diff == 0 && port == a_port)
285329 			return;
286
-		if (diff == 0 &&
287
-		    (u16 __force)xport < (u16 __force)a->sin6_port)
330
+		if (diff == 0 && port < a_port)
288331 			break;
289332 		if (diff < 0)
290333 			break;
....@@ -295,12 +338,13 @@
295338 			alist->addrs + i,
296339 			sizeof(alist->addrs[0]) * (alist->nr_addrs - i));
297340 
298
-	a = &alist->addrs[i].transport.sin6;
299
-	a->sin6_port		  = xport;
300
-	a->sin6_addr.s6_addr32[0] = xdr[0];
301
-	a->sin6_addr.s6_addr32[1] = xdr[1];
302
-	a->sin6_addr.s6_addr32[2] = xdr[2];
303
-	a->sin6_addr.s6_addr32[3] = xdr[3];
341
+	srx = &alist->addrs[i];
342
+	srx->srx_family = AF_RXRPC;
343
+	srx->transport_type = SOCK_DGRAM;
344
+	srx->transport_len = sizeof(srx->transport.sin6);
345
+	srx->transport.sin6.sin6_family = AF_INET6;
346
+	srx->transport.sin6.sin6_port = htons(port);
347
+	memcpy(&srx->transport.sin6.sin6_addr, xdr, 16);
304348 	alist->nr_addrs++;
305349 }
306350 
....@@ -309,25 +353,33 @@
309353  */
310354 bool afs_iterate_addresses(struct afs_addr_cursor *ac)
311355 {
312
-	_enter("%hu+%hd", ac->start, (short)ac->index);
356
+	unsigned long set, failed;
357
+	int index;
313358 
314359 	if (!ac->alist)
315360 		return false;
316361 
317
-	if (ac->begun) {
318
-		ac->index++;
319
-		if (ac->index == ac->alist->nr_addrs)
320
-			ac->index = 0;
362
+	set = ac->alist->responded;
363
+	failed = ac->alist->failed;
364
+	_enter("%lx-%lx-%lx,%d", set, failed, ac->tried, ac->index);
321365 
322
-		if (ac->index == ac->start) {
323
-			ac->error = -EDESTADDRREQ;
324
-			return false;
325
-		}
326
-	}
366
+	ac->nr_iterations++;
327367 
328
-	ac->begun = true;
368
+	set &= ~(failed | ac->tried);
369
+
370
+	if (!set)
371
+		return false;
372
+
373
+	index = READ_ONCE(ac->alist->preferred);
374
+	if (test_bit(index, &set))
375
+		goto selected;
376
+
377
+	index = __ffs(set);
378
+
379
+selected:
380
+	ac->index = index;
381
+	set_bit(index, &ac->tried);
329382 	ac->responded = false;
330
-	ac->addr = &ac->alist->addrs[ac->index];
331383 	return true;
332384 }
333385 
....@@ -340,53 +392,13 @@
340392 
341393 	alist = ac->alist;
342394 	if (alist) {
343
-		if (ac->responded && ac->index != ac->start)
344
-			WRITE_ONCE(alist->index, ac->index);
395
+		if (ac->responded &&
396
+		    ac->index != alist->preferred &&
397
+		    test_bit(ac->alist->preferred, &ac->tried))
398
+			WRITE_ONCE(alist->preferred, ac->index);
345399 		afs_put_addrlist(alist);
400
+		ac->alist = NULL;
346401 	}
347402 
348
-	ac->addr = NULL;
349
-	ac->alist = NULL;
350
-	ac->begun = false;
351403 	return ac->error;
352
-}
353
-
354
-/*
355
- * Set the address cursor for iterating over VL servers.
356
- */
357
-int afs_set_vl_cursor(struct afs_addr_cursor *ac, struct afs_cell *cell)
358
-{
359
-	struct afs_addr_list *alist;
360
-	int ret;
361
-
362
-	if (!rcu_access_pointer(cell->vl_addrs)) {
363
-		ret = wait_on_bit(&cell->flags, AFS_CELL_FL_NO_LOOKUP_YET,
364
-				  TASK_INTERRUPTIBLE);
365
-		if (ret < 0)
366
-			return ret;
367
-
368
-		if (!rcu_access_pointer(cell->vl_addrs) &&
369
-		    ktime_get_real_seconds() < cell->dns_expiry)
370
-			return cell->error;
371
-	}
372
-
373
-	read_lock(&cell->vl_addrs_lock);
374
-	alist = rcu_dereference_protected(cell->vl_addrs,
375
-					  lockdep_is_held(&cell->vl_addrs_lock));
376
-	if (alist->nr_addrs > 0)
377
-		afs_get_addrlist(alist);
378
-	else
379
-		alist = NULL;
380
-	read_unlock(&cell->vl_addrs_lock);
381
-
382
-	if (!alist)
383
-		return -EDESTADDRREQ;
384
-
385
-	ac->alist = alist;
386
-	ac->addr = NULL;
387
-	ac->start = READ_ONCE(alist->index);
388
-	ac->index = ac->start;
389
-	ac->error = 0;
390
-	ac->begun = false;
391
-	return 0;
392404 }