1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* AFS vlserver list management.
4 * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
8 #include <linux/kernel.h>
9 #include <linux/slab.h>
12 struct afs_vlserver *afs_alloc_vlserver(const char *name, size_t name_len,
15 struct afs_vlserver *vlserver;
17 vlserver = kzalloc(struct_size(vlserver, name, name_len + 1),
20 refcount_set(&vlserver->ref, 1);
21 rwlock_init(&vlserver->lock);
22 init_waitqueue_head(&vlserver->probe_wq);
23 spin_lock_init(&vlserver->probe_lock);
24 vlserver->rtt = UINT_MAX;
25 vlserver->name_len = name_len;
26 vlserver->port = port;
27 memcpy(vlserver->name, name, name_len);
32 static void afs_vlserver_rcu(struct rcu_head *rcu)
34 struct afs_vlserver *vlserver = container_of(rcu, struct afs_vlserver, rcu);
36 afs_put_addrlist(rcu_access_pointer(vlserver->addresses));
37 kfree_rcu(vlserver, rcu);
40 void afs_put_vlserver(struct afs_net *net, struct afs_vlserver *vlserver)
43 refcount_dec_and_test(&vlserver->ref))
44 call_rcu(&vlserver->rcu, afs_vlserver_rcu);
47 struct afs_vlserver_list *afs_alloc_vlserver_list(unsigned int nr_servers)
49 struct afs_vlserver_list *vllist;
51 vllist = kzalloc(struct_size(vllist, servers, nr_servers), GFP_KERNEL);
53 refcount_set(&vllist->ref, 1);
54 rwlock_init(&vllist->lock);
60 void afs_put_vlserverlist(struct afs_net *net, struct afs_vlserver_list *vllist)
63 if (refcount_dec_and_test(&vllist->ref)) {
66 for (i = 0; i < vllist->nr_servers; i++) {
67 afs_put_vlserver(net, vllist->servers[i].server);
69 kfree_rcu(vllist, rcu);
74 static u16 afs_extract_le16(const u8 **_b)
78 val = (u16)*(*_b)++ << 0;
79 val |= (u16)*(*_b)++ << 8;
84 * Build a VL server address list from a DNS queried server list.
86 static struct afs_addr_list *afs_extract_vl_addrs(struct afs_net *net,
87 const u8 **_b, const u8 *end,
88 u8 nr_addrs, u16 port)
90 struct afs_addr_list *alist;
94 alist = afs_alloc_addrlist(nr_addrs, VL_SERVICE);
96 return ERR_PTR(-ENOMEM);
100 for (; nr_addrs > 0 && end - b >= nr_addrs; nr_addrs--) {
101 struct dns_server_list_v1_address hdr;
104 hdr.address_type = *b++;
106 switch (hdr.address_type) {
107 case DNS_ADDRESS_IS_IPV4:
109 _leave(" = -EINVAL [short inet]");
113 ret = afs_merge_fs_addr4(net, alist, x[0], port);
119 case DNS_ADDRESS_IS_IPV6:
121 _leave(" = -EINVAL [short inet6]");
125 ret = afs_merge_fs_addr6(net, alist, x, port);
132 _leave(" = -EADDRNOTAVAIL [unknown af %u]",
134 ret = -EADDRNOTAVAIL;
139 /* Start with IPv6 if available. */
140 if (alist->nr_ipv4 < alist->nr_addrs)
141 alist->preferred = alist->nr_ipv4;
148 afs_put_addrlist(alist);
153 * Build a VL server list from a DNS queried server list.
155 struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *cell,
159 const struct dns_server_list_v1_header *hdr = buffer;
160 struct dns_server_list_v1_server bs;
161 struct afs_vlserver_list *vllist, *previous;
162 struct afs_addr_list *addrs;
163 struct afs_vlserver *server;
164 const u8 *b = buffer, *end = buffer + buffer_size;
165 int ret = -ENOMEM, nr_servers, i, j;
169 /* Check that it's a server list, v1 */
170 if (end - b < sizeof(*hdr) ||
171 hdr->hdr.content != DNS_PAYLOAD_IS_SERVER_LIST ||
172 hdr->hdr.version != 1) {
173 pr_notice("kAFS: Got DNS record [%u,%u] len %zu\n",
174 hdr->hdr.content, hdr->hdr.version, end - b);
179 nr_servers = hdr->nr_servers;
181 vllist = afs_alloc_vlserver_list(nr_servers);
183 return ERR_PTR(-ENOMEM);
185 vllist->source = (hdr->source < NR__dns_record_source) ?
186 hdr->source : NR__dns_record_source;
187 vllist->status = (hdr->status < NR__dns_lookup_status) ?
188 hdr->status : NR__dns_lookup_status;
190 read_lock(&cell->vl_servers_lock);
191 previous = afs_get_vlserverlist(
192 rcu_dereference_protected(cell->vl_servers,
193 lockdep_is_held(&cell->vl_servers_lock)));
194 read_unlock(&cell->vl_servers_lock);
197 while (end - b >= sizeof(bs)) {
198 bs.name_len = afs_extract_le16(&b);
199 bs.priority = afs_extract_le16(&b);
200 bs.weight = afs_extract_le16(&b);
201 bs.port = afs_extract_le16(&b);
207 _debug("extract %u %u %u %u %u %u %*.*s",
208 bs.name_len, bs.priority, bs.weight,
209 bs.port, bs.protocol, bs.nr_addrs,
210 bs.name_len, bs.name_len, b);
212 if (end - b < bs.name_len)
215 ret = -EPROTONOSUPPORT;
216 if (bs.protocol == DNS_SERVER_PROTOCOL_UNSPECIFIED) {
217 bs.protocol = DNS_SERVER_PROTOCOL_UDP;
218 } else if (bs.protocol != DNS_SERVER_PROTOCOL_UDP) {
219 _leave(" = [proto %u]", bs.protocol);
224 bs.port = AFS_VL_PORT;
225 if (bs.source > NR__dns_record_source)
226 bs.source = NR__dns_record_source;
227 if (bs.status > NR__dns_lookup_status)
228 bs.status = NR__dns_lookup_status;
230 /* See if we can update an old server record */
232 for (i = 0; i < previous->nr_servers; i++) {
233 struct afs_vlserver *p = previous->servers[i].server;
235 if (p->name_len == bs.name_len &&
236 p->port == bs.port &&
237 strncasecmp(b, p->name, bs.name_len) == 0) {
238 server = afs_get_vlserver(p);
245 server = afs_alloc_vlserver(b, bs.name_len, bs.port);
252 /* Extract the addresses - note that we can't skip this as we
253 * have to advance the payload pointer.
255 addrs = afs_extract_vl_addrs(cell->net, &b, end, bs.nr_addrs, bs.port);
257 ret = PTR_ERR(addrs);
261 if (vllist->nr_servers >= nr_servers) {
262 _debug("skip %u >= %u", vllist->nr_servers, nr_servers);
263 afs_put_addrlist(addrs);
264 afs_put_vlserver(cell->net, server);
268 addrs->source = bs.source;
269 addrs->status = bs.status;
271 if (addrs->nr_addrs == 0) {
272 afs_put_addrlist(addrs);
273 if (!rcu_access_pointer(server->addresses)) {
274 afs_put_vlserver(cell->net, server);
278 struct afs_addr_list *old = addrs;
280 write_lock(&server->lock);
281 old = rcu_replace_pointer(server->addresses, old,
282 lockdep_is_held(&server->lock));
283 write_unlock(&server->lock);
284 afs_put_addrlist(old);
288 /* TODO: Might want to check for duplicates */
290 /* Insertion-sort by priority and weight */
291 for (j = 0; j < vllist->nr_servers; j++) {
292 if (bs.priority < vllist->servers[j].priority)
293 break; /* Lower preferable */
294 if (bs.priority == vllist->servers[j].priority &&
295 bs.weight > vllist->servers[j].weight)
296 break; /* Higher preferable */
299 if (j < vllist->nr_servers) {
300 memmove(vllist->servers + j + 1,
302 (vllist->nr_servers - j) * sizeof(struct afs_vlserver_entry));
305 clear_bit(AFS_VLSERVER_FL_PROBED, &server->flags);
307 vllist->servers[j].priority = bs.priority;
308 vllist->servers[j].weight = bs.weight;
309 vllist->servers[j].server = server;
310 vllist->nr_servers++;
314 _debug("parse error %zd", b - end);
318 afs_put_vlserverlist(cell->net, previous);
319 _leave(" = ok [%u]", vllist->nr_servers);
323 afs_put_vlserver(cell->net, server);
325 afs_put_vlserverlist(cell->net, vllist);
326 afs_put_vlserverlist(cell->net, previous);
328 if (ret != -ENOMEM) {
329 printk(KERN_DEBUG "DNS: at %zu\n", (const void *)b - buffer);
330 print_hex_dump_bytes("DNS: ", DUMP_PREFIX_NONE, buffer, buffer_size);