fs/afs/vl_alias.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* AFS cell alias detection
   3  *
   4  * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/slab.h>
   9 #include <linux/sched.h>
  10 #include <linux/namei.h>
  11 #include <keys/rxrpc-type.h>
  12 #include "internal.h"
  13
  14 /*
  15  * Sample a volume.
  16  */
  17 static struct afs_volume *afs_sample_volume(struct afs_cell *cell, struct key *key,
  18                                             const char *name, unsigned int namelen)
  19 {
  20         struct afs_volume *volume;
  21         struct afs_fs_context fc = {
  22                 .type           = 0, /* Explicitly leave it to the VLDB */
  23                 .volnamesz      = namelen,
  24                 .volname        = name,
  25                 .net            = cell->net,
  26                 .cell           = cell,
  27                 .key            = key, /* This might need to be something */
  28         };
  29
  30         volume = afs_create_volume(&fc);
  31         _leave(" = %p", volume);
  32         return volume;
  33 }
  34
  35 /*
  36  * Compare two addresses.
  37  */
  38 static int afs_compare_addrs(const struct sockaddr_rxrpc *srx_a,
  39                              const struct sockaddr_rxrpc *srx_b)
  40 {
  41         short port_a, port_b;
  42         int addr_a, addr_b, diff;
  43
  44         diff = (short)srx_a->transport_type - (short)srx_b->transport_type;
  45         if (diff)
  46                 goto out;
  47
  48         switch (srx_a->transport_type) {
  49         case AF_INET: {
  50                 const struct sockaddr_in *a = &srx_a->transport.sin;
  51                 const struct sockaddr_in *b = &srx_b->transport.sin;
  52                 addr_a = ntohl(a->sin_addr.s_addr);
  53                 addr_b = ntohl(b->sin_addr.s_addr);
  54                 diff = addr_a - addr_b;
  55                 if (diff == 0) {
  56                         port_a = ntohs(a->sin_port);
  57                         port_b = ntohs(b->sin_port);
  58                         diff = port_a - port_b;
  59                 }
  60                 break;
  61         }
  62
  63         case AF_INET6: {
  64                 const struct sockaddr_in6 *a = &srx_a->transport.sin6;
  65                 const struct sockaddr_in6 *b = &srx_b->transport.sin6;
  66                 diff = memcmp(&a->sin6_addr, &b->sin6_addr, 16);
  67                 if (diff == 0) {
  68                         port_a = ntohs(a->sin6_port);
  69                         port_b = ntohs(b->sin6_port);
  70                         diff = port_a - port_b;
  71                 }
  72                 break;
  73         }
  74
  75         default:
  76                 WARN_ON(1);
  77                 diff = 1;
  78         }
  79
  80 out:
  81         return diff;
  82 }
  83
  84 /*
  85  * Compare the address lists of a pair of fileservers.
  86  */
  87 static int afs_compare_fs_alists(const struct afs_server *server_a,
  88                                  const struct afs_server *server_b)
  89 {
  90         const struct afs_addr_list *la, *lb;
  91         int a = 0, b = 0, addr_matches = 0;
  92
  93         la = rcu_dereference(server_a->addresses);
  94         lb = rcu_dereference(server_b->addresses);
  95
  96         while (a < la->nr_addrs && b < lb->nr_addrs) {
  97                 const struct sockaddr_rxrpc *srx_a = &la->addrs[a];
  98                 const struct sockaddr_rxrpc *srx_b = &lb->addrs[b];
  99                 int diff = afs_compare_addrs(srx_a, srx_b);
 100
 101                 if (diff < 0) {
 102                         a++;
 103                 } else if (diff > 0) {
 104                         b++;
 105                 } else {
 106                         addr_matches++;
 107                         a++;
 108                         b++;
 109                 }
 110         }
 111
 112         return addr_matches;
 113 }
 114
 115 /*
 116  * Compare the fileserver lists of two volumes.  The server lists are sorted in
 117  * order of ascending UUID.
 118  */
 119 static int afs_compare_volume_slists(const struct afs_volume *vol_a,
 120                                      const struct afs_volume *vol_b)
 121 {
 122         const struct afs_server_list *la, *lb;
 123         int i, a = 0, b = 0, uuid_matches = 0, addr_matches = 0;
 124
 125         la = rcu_dereference(vol_a->servers);
 126         lb = rcu_dereference(vol_b->servers);
 127
 128         for (i = 0; i < AFS_MAXTYPES; i++)
 129                 if (la->vids[i] != lb->vids[i])
 130                         return 0;
 131
 132         while (a < la->nr_servers && b < lb->nr_servers) {
 133                 const struct afs_server *server_a = la->servers[a].server;
 134                 const struct afs_server *server_b = lb->servers[b].server;
 135                 int diff = memcmp(&server_a->uuid, &server_b->uuid, sizeof(uuid_t));
 136
 137                 if (diff < 0) {
 138                         a++;
 139                 } else if (diff > 0) {
 140                         b++;
 141                 } else {
 142                         uuid_matches++;
 143                         addr_matches += afs_compare_fs_alists(server_a, server_b);
 144                         a++;
 145                         b++;
 146                 }
 147         }
 148
 149         _leave(" = %d [um %d]", addr_matches, uuid_matches);
 150         return addr_matches;
 151 }
 152
 153 /*
 154  * Compare root.cell volumes.
 155  */
 156 static int afs_compare_cell_roots(struct afs_cell *cell)
 157 {
 158         struct afs_cell *p;
 159
 160         _enter("");
 161
 162         rcu_read_lock();
 163
 164         hlist_for_each_entry_rcu(p, &cell->net->proc_cells, proc_link) {
 165                 if (p == cell || p->alias_of)
 166                         continue;
 167                 if (!p->root_volume)
 168                         continue; /* Ignore cells that don't have a root.cell volume. */
 169
 170                 if (afs_compare_volume_slists(cell->root_volume, p->root_volume) != 0)
 171                         goto is_alias;
 172         }
 173
 174         rcu_read_unlock();
 175         _leave(" = 0");
 176         return 0;
 177
 178 is_alias:
 179         rcu_read_unlock();
 180         cell->alias_of = afs_get_cell(p);
 181         return 1;
 182 }
 183
 184 /*
 185  * Query the new cell for a volume from a cell we're already using.
 186  */
 187 static int afs_query_for_alias_one(struct afs_cell *cell, struct key *key,
 188                                    struct afs_cell *p)
 189 {
 190         struct afs_volume *volume, *pvol = NULL;
 191         int ret;
 192
 193         /* Arbitrarily pick a volume from the list. */
 194         read_seqlock_excl(&p->volume_lock);
 195         if (!RB_EMPTY_ROOT(&p->volumes))
 196                 pvol = afs_get_volume(rb_entry(p->volumes.rb_node,
 197                                                struct afs_volume, cell_node),
 198                                       afs_volume_trace_get_query_alias);
 199         read_sequnlock_excl(&p->volume_lock);
 200         if (!pvol)
 201                 return 0;
 202
 203         _enter("%s:%s", cell->name, pvol->name);
 204
 205         /* And see if it's in the new cell. */
 206         volume = afs_sample_volume(cell, key, pvol->name, pvol->name_len);
 207         if (IS_ERR(volume)) {
 208                 afs_put_volume(cell->net, pvol, afs_volume_trace_put_query_alias);
 209                 if (PTR_ERR(volume) != -ENOMEDIUM)
 210                         return PTR_ERR(volume);
 211                 /* That volume is not in the new cell, so not an alias */
 212                 return 0;
 213         }
 214
 215         /* The new cell has a like-named volume also - compare volume ID,
 216          * server and address lists.
 217          */
 218         ret = 0;
 219         if (pvol->vid == volume->vid) {
 220                 rcu_read_lock();
 221                 if (afs_compare_volume_slists(volume, pvol))
 222                         ret = 1;
 223                 rcu_read_unlock();
 224         }
 225
 226         afs_put_volume(cell->net, volume, afs_volume_trace_put_query_alias);
 227         afs_put_volume(cell->net, pvol, afs_volume_trace_put_query_alias);
 228         return ret;
 229 }
 230
 231 /*
 232  * Query the new cell for volumes we know exist in cells we're already using.
 233  */
 234 static int afs_query_for_alias(struct afs_cell *cell, struct key *key)
 235 {
 236         struct afs_cell *p;
 237
 238         _enter("%s", cell->name);
 239
 240         if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0)
 241                 return -ERESTARTSYS;
 242
 243         hlist_for_each_entry(p, &cell->net->proc_cells, proc_link) {
 244                 if (p == cell || p->alias_of)
 245                         continue;
 246                 if (RB_EMPTY_ROOT(&p->volumes))
 247                         continue;
 248                 if (p->root_volume)
 249                         continue; /* Ignore cells that have a root.cell volume. */
 250                 afs_get_cell(p);
 251                 mutex_unlock(&cell->net->proc_cells_lock);
 252
 253                 if (afs_query_for_alias_one(cell, key, p) != 0)
 254                         goto is_alias;
 255
 256                 if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0) {
 257                         afs_put_cell(cell->net, p);
 258                         return -ERESTARTSYS;
 259                 }
 260
 261                 afs_put_cell(cell->net, p);
 262         }
 263
 264         mutex_unlock(&cell->net->proc_cells_lock);
 265         _leave(" = 0");
 266         return 0;
 267
 268 is_alias:
 269         cell->alias_of = p; /* Transfer our ref */
 270         return 1;
 271 }
 272
 273 /*
 274  * Look up a VLDB record for a volume.
 275  */
 276 static char *afs_vl_get_cell_name(struct afs_cell *cell, struct key *key)
 277 {
 278         struct afs_vl_cursor vc;
 279         char *cell_name = ERR_PTR(-EDESTADDRREQ);
 280         bool skipped = false, not_skipped = false;
 281         int ret;
 282
 283         if (!afs_begin_vlserver_operation(&vc, cell, key))
 284                 return ERR_PTR(-ERESTARTSYS);
 285
 286         while (afs_select_vlserver(&vc)) {
 287                 if (!test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) {
 288                         vc.ac.error = -EOPNOTSUPP;
 289                         skipped = true;
 290                         continue;
 291                 }
 292                 not_skipped = true;
 293                 cell_name = afs_yfsvl_get_cell_name(&vc);
 294         }
 295
 296         ret = afs_end_vlserver_operation(&vc);
 297         if (skipped && !not_skipped)
 298                 ret = -EOPNOTSUPP;
 299         return ret < 0 ? ERR_PTR(ret) : cell_name;
 300 }
 301
 302 static int yfs_check_canonical_cell_name(struct afs_cell *cell, struct key *key)
 303 {
 304         struct afs_cell *master;
 305         char *cell_name;
 306
 307         cell_name = afs_vl_get_cell_name(cell, key);
 308         if (IS_ERR(cell_name))
 309                 return PTR_ERR(cell_name);
 310
 311         if (strcmp(cell_name, cell->name) == 0) {
 312                 kfree(cell_name);
 313                 return 0;
 314         }
 315
 316         master = afs_lookup_cell(cell->net, cell_name, strlen(cell_name),
 317                                  NULL, false);
 318         kfree(cell_name);
 319         if (IS_ERR(master))
 320                 return PTR_ERR(master);
 321
 322         cell->alias_of = master; /* Transfer our ref */
 323         return 1;
 324 }
 325
 326 static int afs_do_cell_detect_alias(struct afs_cell *cell, struct key *key)
 327 {
 328         struct afs_volume *root_volume;
 329         int ret;
 330
 331         _enter("%s", cell->name);
 332
 333         ret = yfs_check_canonical_cell_name(cell, key);
 334         if (ret != -EOPNOTSUPP)
 335                 return ret;
 336
 337         /* Try and get the root.cell volume for comparison with other cells */
 338         root_volume = afs_sample_volume(cell, key, "root.cell", 9);
 339         if (!IS_ERR(root_volume)) {
 340                 cell->root_volume = root_volume;
 341                 return afs_compare_cell_roots(cell);
 342         }
 343
 344         if (PTR_ERR(root_volume) != -ENOMEDIUM)
 345                 return PTR_ERR(root_volume);
 346
 347         /* Okay, this cell doesn't have an root.cell volume.  We need to
 348          * locate some other random volume and use that to check.
 349          */
 350         return afs_query_for_alias(cell, key);
 351 }
 352
 353 /*
 354  * Check to see if a new cell is an alias of a cell we already have.  At this
 355  * point we have the cell's volume server list.
 356  *
 357  * Returns 0 if we didn't detect an alias, 1 if we found an alias and an error
 358  * if we had problems gathering the data required.  In the case the we did
 359  * detect an alias, cell->alias_of is set to point to the assumed master.
 360  */
 361 int afs_cell_detect_alias(struct afs_cell *cell, struct key *key)
 362 {
 363         struct afs_net *net = cell->net;
 364         int ret;
 365
 366         if (mutex_lock_interruptible(&net->cells_alias_lock) < 0)
 367                 return -ERESTARTSYS;
 368
 369         if (test_bit(AFS_CELL_FL_CHECK_ALIAS, &cell->flags)) {
 370                 ret = afs_do_cell_detect_alias(cell, key);
 371                 if (ret >= 0)
 372                         clear_bit_unlock(AFS_CELL_FL_CHECK_ALIAS, &cell->flags);
 373         } else {
 374                 ret = cell->alias_of ? 1 : 0;
 375         }
 376
 377         mutex_unlock(&net->cells_alias_lock);
 378
 379         if (ret == 1)
 380                 pr_notice("kAFS: Cell %s is an alias of %s\n",
 381                           cell->name, cell->alias_of->name);
 382         return ret;
 383 }