fs/afs/server_list.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* AFS fileserver list management.
   3  *
   4  * Copyright (C) 2017 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 void afs_put_serverlist(struct afs_net *net, struct afs_server_list *slist)
  13 {
  14         int i;
  15
  16         if (slist && refcount_dec_and_test(&slist->usage)) {
  17                 for (i = 0; i < slist->nr_servers; i++)
  18                         afs_unuse_server(net, slist->servers[i].server,
  19                                          afs_server_trace_put_slist);
  20                 kfree_rcu(slist, rcu);
  21         }
  22 }
  23
  24 /*
  25  * Build a server list from a VLDB record.
  26  */
  27 struct afs_server_list *afs_alloc_server_list(struct afs_volume *volume,
  28                                               struct key *key,
  29                                               struct afs_vldb_entry *vldb)
  30 {
  31         struct afs_server_list *slist;
  32         struct afs_server *server;
  33         unsigned int type_mask = 1 << volume->type;
  34         bool use_newrepsites = false;
  35         int ret = -ENOMEM, nr_servers = 0, newrep = 0, i, j, usable = 0;
  36
  37         /* Work out if we're going to restrict to NEWREPSITE-marked servers or
  38          * not.  If at least one site is marked as NEWREPSITE, then it's likely
  39          * that "vos release" is busy updating RO sites.  We cut over from one
  40          * to the other when >=50% of the sites have been updated.  Sites that
  41          * are in the process of being updated are marked DONTUSE.
  42          */
  43         for (i = 0; i < vldb->nr_servers; i++) {
  44                 if (!(vldb->fs_mask[i] & type_mask))
  45                         continue;
  46                 nr_servers++;
  47                 if (vldb->vlsf_flags[i] & AFS_VLSF_DONTUSE)
  48                         continue;
  49                 usable++;
  50                 if (vldb->vlsf_flags[i] & AFS_VLSF_NEWREPSITE)
  51                         newrep++;
  52         }
  53
  54         slist = kzalloc(struct_size(slist, servers, nr_servers), GFP_KERNEL);
  55         if (!slist)
  56                 goto error;
  57
  58         if (newrep) {
  59                 if (newrep < usable / 2) {
  60                         slist->ro_replicating = AFS_RO_REPLICATING_USE_OLD;
  61                 } else {
  62                         slist->ro_replicating = AFS_RO_REPLICATING_USE_NEW;
  63                         use_newrepsites = true;
  64                 }
  65         }
  66
  67         refcount_set(&slist->usage, 1);
  68         rwlock_init(&slist->lock);
  69
  70         /* Make sure a records exists for each server in the list. */
  71         for (i = 0; i < vldb->nr_servers; i++) {
  72                 unsigned long se_flags = 0;
  73                 bool newrepsite = vldb->vlsf_flags[i] & AFS_VLSF_NEWREPSITE;
  74
  75                 if (!(vldb->fs_mask[i] & type_mask))
  76                         continue;
  77                 if (vldb->vlsf_flags[i] & AFS_VLSF_DONTUSE)
  78                         __set_bit(AFS_SE_EXCLUDED, &se_flags);
  79                 if (newrep && (newrepsite ^ use_newrepsites))
  80                         __set_bit(AFS_SE_EXCLUDED, &se_flags);
  81
  82                 server = afs_lookup_server(volume->cell, key, &vldb->fs_server[i],
  83                                            vldb->addr_version[i]);
  84                 if (IS_ERR(server)) {
  85                         ret = PTR_ERR(server);
  86                         if (ret == -ENOENT ||
  87                             ret == -ENOMEDIUM)
  88                                 continue;
  89                         goto error_2;
  90                 }
  91
  92                 /* Insertion-sort by UUID */
  93                 for (j = 0; j < slist->nr_servers; j++)
  94                         if (memcmp(&slist->servers[j].server->uuid,
  95                                    &server->uuid,
  96                                    sizeof(server->uuid)) >= 0)
  97                                 break;
  98                 if (j < slist->nr_servers) {
  99                         if (slist->servers[j].server == server) {
 100                                 afs_put_server(volume->cell->net, server,
 101                                                afs_server_trace_put_slist_isort);
 102                                 continue;
 103                         }
 104
 105                         memmove(slist->servers + j + 1,
 106                                 slist->servers + j,
 107                                 (slist->nr_servers - j) * sizeof(struct afs_server_entry));
 108                 }
 109
 110                 slist->servers[j].server = server;
 111                 slist->servers[j].volume = volume;
 112                 slist->servers[j].flags = se_flags;
 113                 slist->servers[j].cb_expires_at = AFS_NO_CB_PROMISE;
 114                 slist->nr_servers++;
 115         }
 116
 117         if (slist->nr_servers == 0) {
 118                 ret = -EDESTADDRREQ;
 119                 goto error_2;
 120         }
 121
 122         return slist;
 123
 124 error_2:
 125         afs_put_serverlist(volume->cell->net, slist);
 126 error:
 127         return ERR_PTR(ret);
 128 }
 129
 130 /*
 131  * Copy the annotations from an old server list to its potential replacement.
 132  */
 133 bool afs_annotate_server_list(struct afs_server_list *new,
 134                               struct afs_server_list *old)
 135 {
 136         unsigned long mask = 1UL << AFS_SE_EXCLUDED;
 137         int i;
 138
 139         if (old->nr_servers != new->nr_servers ||
 140             old->ro_replicating != new->ro_replicating)
 141                 goto changed;
 142
 143         for (i = 0; i < old->nr_servers; i++) {
 144                 if (old->servers[i].server != new->servers[i].server)
 145                         goto changed;
 146                 if ((old->servers[i].flags & mask) != (new->servers[i].flags & mask))
 147                         goto changed;
 148         }
 149         return false;
 150 changed:
 151         return true;
 152 }
 153
 154 /*
 155  * Attach a volume to the servers it is going to use.
 156  */
 157 void afs_attach_volume_to_servers(struct afs_volume *volume, struct afs_server_list *slist)
 158 {
 159         struct afs_server_entry *se, *pe;
 160         struct afs_server *server;
 161         struct list_head *p;
 162         unsigned int i;
 163
 164         down_write(&volume->cell->vs_lock);
 165
 166         for (i = 0; i < slist->nr_servers; i++) {
 167                 se = &slist->servers[i];
 168                 server = se->server;
 169
 170                 list_for_each(p, &server->volumes) {
 171                         pe = list_entry(p, struct afs_server_entry, slink);
 172                         if (volume->vid <= pe->volume->vid)
 173                                 break;
 174                 }
 175                 list_add_tail(&se->slink, p);
 176         }
 177
 178         slist->attached = true;
 179         up_write(&volume->cell->vs_lock);
 180 }
 181
 182 /*
 183  * Reattach a volume to the servers it is going to use when server list is
 184  * replaced.  We try to switch the attachment points to avoid rewalking the
 185  * lists.
 186  */
 187 void afs_reattach_volume_to_servers(struct afs_volume *volume, struct afs_server_list *new,
 188                                     struct afs_server_list *old)
 189 {
 190         unsigned int n = 0, o = 0;
 191
 192         down_write(&volume->cell->vs_lock);
 193
 194         while (n < new->nr_servers || o < old->nr_servers) {
 195                 struct afs_server_entry *pn = n < new->nr_servers ? &new->servers[n] : NULL;
 196                 struct afs_server_entry *po = o < old->nr_servers ? &old->servers[o] : NULL;
 197                 struct afs_server_entry *s;
 198                 struct list_head *p;
 199                 int diff;
 200
 201                 if (pn && po && pn->server == po->server) {
 202                         pn->cb_expires_at = po->cb_expires_at;
 203                         list_replace(&po->slink, &pn->slink);
 204                         n++;
 205                         o++;
 206                         continue;
 207                 }
 208
 209                 if (pn && po)
 210                         diff = memcmp(&pn->server->uuid, &po->server->uuid,
 211                                       sizeof(pn->server->uuid));
 212                 else
 213                         diff = pn ? -1 : 1;
 214
 215                 if (diff < 0) {
 216                         list_for_each(p, &pn->server->volumes) {
 217                                 s = list_entry(p, struct afs_server_entry, slink);
 218                                 if (volume->vid <= s->volume->vid)
 219                                         break;
 220                         }
 221                         list_add_tail(&pn->slink, p);
 222                         n++;
 223                 } else {
 224                         list_del(&po->slink);
 225                         o++;
 226                 }
 227         }
 228
 229         up_write(&volume->cell->vs_lock);
 230 }
 231
 232 /*
 233  * Detach a volume from the servers it has been using.
 234  */
 235 void afs_detach_volume_from_servers(struct afs_volume *volume, struct afs_server_list *slist)
 236 {
 237         unsigned int i;
 238
 239         if (!slist->attached)
 240                 return;
 241
 242         down_write(&volume->cell->vs_lock);
 243
 244         for (i = 0; i < slist->nr_servers; i++)
 245                 list_del(&slist->servers[i].slink);
 246
 247         slist->attached = false;
 248         up_write(&volume->cell->vs_lock);
 249 }