fs/afs/vl_list.c

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