250 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/* 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 12void 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 */27struct 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 or38 * not. If at least one site is marked as NEWREPSITE, then it's likely39 * that "vos release" is busy updating RO sites. We cut over from one40 * to the other when >=50% of the sites have been updated. Sites that41 * 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 124error_2:125 afs_put_serverlist(volume->cell->net, slist);126error:127 return ERR_PTR(ret);128}129 130/*131 * Copy the annotations from an old server list to its potential replacement.132 */133bool 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;150changed:151 return true;152}153 154/*155 * Attach a volume to the servers it is going to use.156 */157void 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 is184 * replaced. We try to switch the attachment points to avoid rewalking the185 * lists.186 */187void 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 else213 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 */235void 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}250