1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* AFS vlserver list management. 3 * 4 * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/slab.h> 10 #include "internal.h" 11 12 struct afs_vlserver *afs_alloc_vlserver(const char *name, size_t name_len, 13 unsigned short port) 14 { 15 struct afs_vlserver *vlserver; 16 static atomic_t debug_ids; 17 18 vlserver = kzalloc_flex(*vlserver, name, name_len + 1); 19 if (vlserver) { 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->debug_id = atomic_inc_return(&debug_ids); 25 vlserver->rtt = UINT_MAX; 26 vlserver->name_len = name_len; 27 vlserver->service_id = VL_SERVICE; 28 vlserver->port = port; 29 memcpy(vlserver->name, name, name_len); 30 } 31 return vlserver; 32 } 33 34 static void afs_vlserver_rcu(struct rcu_head *rcu) 35 { 36 struct afs_vlserver *vlserver = container_of(rcu, struct afs_vlserver, rcu); 37 38 afs_put_addrlist(rcu_access_pointer(vlserver->addresses), 39 afs_alist_trace_put_vlserver); 40 kfree_rcu(vlserver, rcu); 41 } 42 43 void afs_put_vlserver(struct afs_net *net, struct afs_vlserver *vlserver) 44 { 45 if (vlserver && 46 refcount_dec_and_test(&vlserver->ref)) 47 call_rcu(&vlserver->rcu, afs_vlserver_rcu); 48 } 49 50 struct afs_vlserver_list *afs_alloc_vlserver_list(unsigned int nr_servers) 51 { 52 struct afs_vlserver_list *vllist; 53 54 vllist = kzalloc_flex(*vllist, servers, nr_servers); 55 if (vllist) { 56 refcount_set(&vllist->ref, 1); 57 rwlock_init(&vllist->lock); 58 } 59 60 return vllist; 61 } 62 63 void afs_put_vlserverlist(struct afs_net *net, struct afs_vlserver_list *vllist) 64 { 65 if (vllist) { 66 if (refcount_dec_and_test(&vllist->ref)) { 67 int i; 68 69 for (i = 0; i < vllist->nr_servers; i++) { 70 afs_put_vlserver(net, vllist->servers[i].server); 71 } 72 kfree_rcu(vllist, rcu); 73 } 74 } 75 } 76 77 static u16 afs_extract_le16(const u8 **_b) 78 { 79 u16 val; 80 81 val = (u16)*(*_b)++ << 0; 82 val |= (u16)*(*_b)++ << 8; 83 return val; 84 } 85 86 /* 87 * Build a VL server address list from a DNS queried server list. 88 */ 89 static struct afs_addr_list *afs_extract_vl_addrs(struct afs_net *net, 90 const u8 **_b, const u8 *end, 91 u8 nr_addrs, u16 port) 92 { 93 struct afs_addr_list *alist; 94 const u8 *b = *_b; 95 int ret; 96 97 alist = afs_alloc_addrlist(nr_addrs); 98 if (!alist) 99 return ERR_PTR(-ENOMEM); 100 if (nr_addrs == 0) 101 return alist; 102 103 for (; nr_addrs > 0 && end - b >= nr_addrs; nr_addrs--) { 104 struct dns_server_list_v1_address hdr; 105 __be32 x[4]; 106 107 hdr.address_type = *b++; 108 109 switch (hdr.address_type) { 110 case DNS_ADDRESS_IS_IPV4: 111 if (end - b < 4) { 112 _leave(" = -EINVAL [short inet]"); 113 ret = -EINVAL; 114 goto error; 115 } 116 memcpy(x, b, 4); 117 ret = afs_merge_fs_addr4(net, alist, x[0], port); 118 if (ret < 0) 119 goto error; 120 b += 4; 121 break; 122 123 case DNS_ADDRESS_IS_IPV6: 124 if (end - b < 16) { 125 _leave(" = -EINVAL [short inet6]"); 126 ret = -EINVAL; 127 goto error; 128 } 129 memcpy(x, b, 16); 130 ret = afs_merge_fs_addr6(net, alist, x, port); 131 if (ret < 0) 132 goto error; 133 b += 16; 134 break; 135 136 default: 137 _leave(" = -EADDRNOTAVAIL [unknown af %u]", 138 hdr.address_type); 139 ret = -EADDRNOTAVAIL; 140 goto error; 141 } 142 } 143 144 /* Start with IPv6 if available. */ 145 if (alist->nr_ipv4 < alist->nr_addrs) 146 alist->preferred = alist->nr_ipv4; 147 148 *_b = b; 149 return alist; 150 151 error: 152 *_b = b; 153 afs_put_addrlist(alist, afs_alist_trace_put_parse_error); 154 return ERR_PTR(ret); 155 } 156 157 /* 158 * Build a VL server list from a DNS queried server list. 159 */ 160 struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *cell, 161 const void *buffer, 162 size_t buffer_size) 163 { 164 const struct dns_server_list_v1_header *hdr = buffer; 165 struct dns_server_list_v1_server bs; 166 struct afs_vlserver_list *vllist, *previous; 167 struct afs_addr_list *addrs; 168 struct afs_vlserver *server; 169 const u8 *b = buffer, *end = buffer + buffer_size; 170 int ret = -ENOMEM, nr_servers, i, j; 171 172 _enter(""); 173 174 /* Check that it's a server list, v1 */ 175 if (end - b < sizeof(*hdr) || 176 hdr->hdr.content != DNS_PAYLOAD_IS_SERVER_LIST || 177 hdr->hdr.version != 1) { 178 pr_notice("kAFS: Got DNS record [%u,%u] len %zu\n", 179 hdr->hdr.content, hdr->hdr.version, end - b); 180 ret = -EDESTADDRREQ; 181 goto dump; 182 } 183 184 nr_servers = hdr->nr_servers; 185 186 vllist = afs_alloc_vlserver_list(nr_servers); 187 if (!vllist) 188 return ERR_PTR(-ENOMEM); 189 190 vllist->source = (hdr->source < NR__dns_record_source) ? 191 hdr->source : NR__dns_record_source; 192 vllist->status = (hdr->status < NR__dns_lookup_status) ? 193 hdr->status : NR__dns_lookup_status; 194 195 read_lock(&cell->vl_servers_lock); 196 previous = afs_get_vlserverlist( 197 rcu_dereference_protected(cell->vl_servers, 198 lockdep_is_held(&cell->vl_servers_lock))); 199 read_unlock(&cell->vl_servers_lock); 200 201 b += sizeof(*hdr); 202 while (end - b >= sizeof(bs)) { 203 int nlen; 204 205 bs.name_len = afs_extract_le16(&b); 206 bs.priority = afs_extract_le16(&b); 207 bs.weight = afs_extract_le16(&b); 208 bs.port = afs_extract_le16(&b); 209 bs.source = *b++; 210 bs.status = *b++; 211 bs.protocol = *b++; 212 bs.nr_addrs = *b++; 213 214 nlen = min3(bs.name_len, end - b, 255); 215 216 _debug("extract %u %u %u %u %u %u %*.*s", 217 bs.name_len, bs.priority, bs.weight, 218 bs.port, bs.protocol, bs.nr_addrs, 219 bs.name_len, nlen, b); 220 221 if (end - b < bs.name_len) 222 break; 223 224 ret = -EPROTONOSUPPORT; 225 if (bs.protocol == DNS_SERVER_PROTOCOL_UNSPECIFIED) { 226 bs.protocol = DNS_SERVER_PROTOCOL_UDP; 227 } else if (bs.protocol != DNS_SERVER_PROTOCOL_UDP) { 228 _leave(" = [proto %u]", bs.protocol); 229 goto error; 230 } 231 232 if (bs.port == 0) 233 bs.port = AFS_VL_PORT; 234 if (bs.source > NR__dns_record_source) 235 bs.source = NR__dns_record_source; 236 if (bs.status > NR__dns_lookup_status) 237 bs.status = NR__dns_lookup_status; 238 239 /* See if we can update an old server record */ 240 server = NULL; 241 for (i = 0; i < previous->nr_servers; i++) { 242 struct afs_vlserver *p = previous->servers[i].server; 243 244 if (p->name_len == bs.name_len && 245 p->port == bs.port && 246 strncasecmp(b, p->name, bs.name_len) == 0) { 247 server = afs_get_vlserver(p); 248 break; 249 } 250 } 251 252 if (!server) { 253 ret = -ENOMEM; 254 server = afs_alloc_vlserver(b, bs.name_len, bs.port); 255 if (!server) 256 goto error; 257 } 258 259 b += bs.name_len; 260 261 /* Extract the addresses - note that we can't skip this as we 262 * have to advance the payload pointer. 263 */ 264 addrs = afs_extract_vl_addrs(cell->net, &b, end, bs.nr_addrs, bs.port); 265 if (IS_ERR(addrs)) { 266 ret = PTR_ERR(addrs); 267 goto error_2; 268 } 269 270 if (vllist->nr_servers >= nr_servers) { 271 _debug("skip %u >= %u", vllist->nr_servers, nr_servers); 272 afs_put_addrlist(addrs, afs_alist_trace_put_parse_empty); 273 afs_put_vlserver(cell->net, server); 274 continue; 275 } 276 277 addrs->source = bs.source; 278 addrs->status = bs.status; 279 280 if (addrs->nr_addrs == 0) { 281 afs_put_addrlist(addrs, afs_alist_trace_put_parse_empty); 282 if (!rcu_access_pointer(server->addresses)) { 283 afs_put_vlserver(cell->net, server); 284 continue; 285 } 286 } else { 287 struct afs_addr_list *old = addrs; 288 289 write_lock(&server->lock); 290 old = rcu_replace_pointer(server->addresses, old, 291 lockdep_is_held(&server->lock)); 292 write_unlock(&server->lock); 293 afs_put_addrlist(old, afs_alist_trace_put_vlserver_old); 294 } 295 296 /* Check for duplicates in the server list */ 297 for (j = 0; j < vllist->nr_servers; j++) { 298 struct afs_vlserver *s = vllist->servers[j].server; 299 300 if (s->name_len == server->name_len && 301 s->port == server->port && 302 strncasecmp(s->name, server->name, server->name_len) == 0) { 303 afs_put_vlserver(cell->net, server); 304 server = NULL; 305 break; 306 } 307 } 308 if (!server) 309 continue; 310 311 /* Insertion-sort by priority and weight */ 312 for (j = 0; j < vllist->nr_servers; j++) { 313 if (bs.priority < vllist->servers[j].priority) 314 break; /* Lower preferable */ 315 if (bs.priority == vllist->servers[j].priority && 316 bs.weight > vllist->servers[j].weight) 317 break; /* Higher preferable */ 318 } 319 320 if (j < vllist->nr_servers) { 321 memmove(vllist->servers + j + 1, 322 vllist->servers + j, 323 (vllist->nr_servers - j) * sizeof(struct afs_vlserver_entry)); 324 } 325 326 clear_bit(AFS_VLSERVER_FL_PROBED, &server->flags); 327 328 vllist->servers[j].priority = bs.priority; 329 vllist->servers[j].weight = bs.weight; 330 vllist->servers[j].server = server; 331 vllist->nr_servers++; 332 } 333 334 if (b != end) { 335 _debug("parse error %zd", b - end); 336 goto error; 337 } 338 339 afs_put_vlserverlist(cell->net, previous); 340 _leave(" = ok [%u]", vllist->nr_servers); 341 return vllist; 342 343 error_2: 344 afs_put_vlserver(cell->net, server); 345 error: 346 afs_put_vlserverlist(cell->net, vllist); 347 afs_put_vlserverlist(cell->net, previous); 348 dump: 349 if (ret != -ENOMEM) { 350 printk(KERN_DEBUG "DNS: at %zu\n", (const void *)b - buffer); 351 print_hex_dump_bytes("DNS: ", DUMP_PREFIX_NONE, buffer, buffer_size); 352 } 353 return ERR_PTR(ret); 354 } 355