fs/afs/volume.c

   1 /* AFS volume management
   2  *
   3  * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/slab.h>
  14 #include "internal.h"
  15
  16 unsigned __read_mostly afs_volume_gc_delay = 10;
  17 unsigned __read_mostly afs_volume_record_life = 60 * 60;
  18
  19 static const char *const afs_voltypes[] = { "R/W", "R/O", "BAK" };
  20
  21 /*
  22  * Allocate a volume record and load it up from a vldb record.
  23  */
  24 static struct afs_volume *afs_alloc_volume(struct afs_mount_params *params,
  25                                            struct afs_vldb_entry *vldb,
  26                                            unsigned long type_mask)
  27 {
  28         struct afs_server_list *slist;
  29         struct afs_server *server;
  30         struct afs_volume *volume;
  31         int ret = -ENOMEM, nr_servers = 0, i, j;
  32
  33         for (i = 0; i < vldb->nr_servers; i++)
  34                 if (vldb->fs_mask[i] & type_mask)
  35                         nr_servers++;
  36
  37         volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL);
  38         if (!volume)
  39                 goto error_0;
  40
  41         volume->vid             = vldb->vid[params->type];
  42         volume->update_at       = ktime_get_real_seconds() + afs_volume_record_life;
  43         volume->cell            = afs_get_cell(params->cell);
  44         volume->type            = params->type;
  45         volume->type_force      = params->force;
  46         volume->name_len        = vldb->name_len;
  47
  48         atomic_set(&volume->usage, 1);
  49         INIT_LIST_HEAD(&volume->proc_link);
  50         rwlock_init(&volume->servers_lock);
  51         memcpy(volume->name, vldb->name, vldb->name_len + 1);
  52
  53         slist = afs_alloc_server_list(params->cell, params->key, vldb, type_mask);
  54         if (IS_ERR(slist)) {
  55                 ret = PTR_ERR(slist);
  56                 goto error_1;
  57         }
  58
  59         refcount_set(&slist->usage, 1);
  60         volume->servers = slist;
  61
  62         /* Make sure a records exists for each server this volume occupies. */
  63         for (i = 0; i < nr_servers; i++) {
  64                 if (!(vldb->fs_mask[i] & type_mask))
  65                         continue;
  66
  67                 server = afs_lookup_server(params->cell, params->key,
  68                                            &vldb->fs_server[i]);
  69                 if (IS_ERR(server)) {
  70                         ret = PTR_ERR(server);
  71                         if (ret == -ENOENT)
  72                                 continue;
  73                         goto error_2;
  74                 }
  75
  76                 /* Insertion-sort by server pointer */
  77                 for (j = 0; j < slist->nr_servers; j++)
  78                         if (slist->servers[j].server >= server)
  79                                 break;
  80                 if (j < slist->nr_servers) {
  81                         if (slist->servers[j].server == server) {
  82                                 afs_put_server(params->net, server);
  83                                 continue;
  84                         }
  85
  86                         memmove(slist->servers + j + 1,
  87                                 slist->servers + j,
  88                                 (slist->nr_servers - j) * sizeof(struct afs_server_entry));
  89                 }
  90
  91                 slist->servers[j].server = server;
  92                 slist->nr_servers++;
  93         }
  94
  95         if (slist->nr_servers == 0) {
  96                 ret = -EDESTADDRREQ;
  97                 goto error_2;
  98         }
  99
 100         return volume;
 101
 102 error_2:
 103         afs_put_serverlist(params->net, slist);
 104 error_1:
 105         kfree(volume);
 106 error_0:
 107         return ERR_PTR(ret);
 108 }
 109
 110 /*
 111  * Look up a VLDB record for a volume.
 112  */
 113 static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell,
 114                                                  struct key *key,
 115                                                  const char *volname,
 116                                                  size_t volnamesz)
 117 {
 118         struct afs_addr_cursor ac;
 119         struct afs_vldb_entry *vldb;
 120         int ret;
 121
 122         ret = afs_set_vl_cursor(&ac, cell);
 123         if (ret < 0)
 124                 return ERR_PTR(ret);
 125
 126         while (afs_iterate_addresses(&ac)) {
 127                 if (!test_bit(ac.index, &ac.alist->probed)) {
 128                         ret = afs_vl_get_capabilities(cell->net, &ac, key);
 129                         switch (ret) {
 130                         case VL_SERVICE:
 131                                 clear_bit(ac.index, &ac.alist->yfs);
 132                                 set_bit(ac.index, &ac.alist->probed);
 133                                 ac.addr->srx_service = ret;
 134                                 break;
 135                         case YFS_VL_SERVICE:
 136                                 set_bit(ac.index, &ac.alist->yfs);
 137                                 set_bit(ac.index, &ac.alist->probed);
 138                                 ac.addr->srx_service = ret;
 139                                 break;
 140                         }
 141                 }
 142
 143                 vldb = afs_vl_get_entry_by_name_u(cell->net, &ac, key,
 144                                                   volname, volnamesz);
 145                 switch (ac.error) {
 146                 case 0:
 147                         afs_end_cursor(&ac);
 148                         return vldb;
 149                 case -ECONNABORTED:
 150                         ac.error = afs_abort_to_error(ac.abort_code);
 151                         goto error;
 152                 case -ENOMEM:
 153                 case -ENONET:
 154                         goto error;
 155                 case -ENETUNREACH:
 156                 case -EHOSTUNREACH:
 157                 case -ECONNREFUSED:
 158                         break;
 159                 default:
 160                         ac.error = -EIO;
 161                         goto error;
 162                 }
 163         }
 164
 165 error:
 166         return ERR_PTR(afs_end_cursor(&ac));
 167 }
 168
 169 /*
 170  * Look up a volume in the VL server and create a candidate volume record for
 171  * it.
 172  *
 173  * The volume name can be one of the following:
 174  *      "%[cell:]volume[.]"             R/W volume
 175  *      "#[cell:]volume[.]"             R/O or R/W volume (rwparent=0),
 176  *                                       or R/W (rwparent=1) volume
 177  *      "%[cell:]volume.readonly"       R/O volume
 178  *      "#[cell:]volume.readonly"       R/O volume
 179  *      "%[cell:]volume.backup"         Backup volume
 180  *      "#[cell:]volume.backup"         Backup volume
 181  *
 182  * The cell name is optional, and defaults to the current cell.
 183  *
 184  * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin
 185  * Guide
 186  * - Rule 1: Explicit type suffix forces access of that type or nothing
 187  *           (no suffix, then use Rule 2 & 3)
 188  * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W
 189  *           if not available
 190  * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
 191  *           explicitly told otherwise
 192  */
 193 struct afs_volume *afs_create_volume(struct afs_mount_params *params)
 194 {
 195         struct afs_vldb_entry *vldb;
 196         struct afs_volume *volume;
 197         unsigned long type_mask = 1UL << params->type;
 198
 199         vldb = afs_vl_lookup_vldb(params->cell, params->key,
 200                                   params->volname, params->volnamesz);
 201         if (IS_ERR(vldb))
 202                 return ERR_CAST(vldb);
 203
 204         if (test_bit(AFS_VLDB_QUERY_ERROR, &vldb->flags)) {
 205                 volume = ERR_PTR(vldb->error);
 206                 goto error;
 207         }
 208
 209         /* Make the final decision on the type we want */
 210         volume = ERR_PTR(-ENOMEDIUM);
 211         if (params->force) {
 212                 if (!(vldb->flags & type_mask))
 213                         goto error;
 214         } else if (test_bit(AFS_VLDB_HAS_RO, &vldb->flags)) {
 215                 params->type = AFSVL_ROVOL;
 216         } else if (test_bit(AFS_VLDB_HAS_RW, &vldb->flags)) {
 217                 params->type = AFSVL_RWVOL;
 218         } else {
 219                 goto error;
 220         }
 221
 222         type_mask = 1UL << params->type;
 223         volume = afs_alloc_volume(params, vldb, type_mask);
 224
 225 error:
 226         kfree(vldb);
 227         return volume;
 228 }
 229
 230 /*
 231  * Destroy a volume record
 232  */
 233 static void afs_destroy_volume(struct afs_net *net, struct afs_volume *volume)
 234 {
 235         _enter("%p", volume);
 236
 237 #ifdef CONFIG_AFS_FSCACHE
 238         ASSERTCMP(volume->cache, ==, NULL);
 239 #endif
 240
 241         afs_put_serverlist(net, volume->servers);
 242         afs_put_cell(net, volume->cell);
 243         kfree(volume);
 244
 245         _leave(" [destroyed]");
 246 }
 247
 248 /*
 249  * Drop a reference on a volume record.
 250  */
 251 void afs_put_volume(struct afs_cell *cell, struct afs_volume *volume)
 252 {
 253         if (volume) {
 254                 _enter("%s", volume->name);
 255
 256                 if (atomic_dec_and_test(&volume->usage))
 257                         afs_destroy_volume(cell->net, volume);
 258         }
 259 }
 260
 261 /*
 262  * Activate a volume.
 263  */
 264 void afs_activate_volume(struct afs_volume *volume)
 265 {
 266 #ifdef CONFIG_AFS_FSCACHE
 267         volume->cache = fscache_acquire_cookie(volume->cell->cache,
 268                                                &afs_volume_cache_index_def,
 269                                                volume, true);
 270 #endif
 271
 272         write_lock(&volume->cell->proc_lock);
 273         list_add_tail(&volume->proc_link, &volume->cell->proc_volumes);
 274         write_unlock(&volume->cell->proc_lock);
 275 }
 276
 277 /*
 278  * Deactivate a volume.
 279  */
 280 void afs_deactivate_volume(struct afs_volume *volume)
 281 {
 282         _enter("%s", volume->name);
 283
 284         write_lock(&volume->cell->proc_lock);
 285         list_del_init(&volume->proc_link);
 286         write_unlock(&volume->cell->proc_lock);
 287
 288 #ifdef CONFIG_AFS_FSCACHE
 289         fscache_relinquish_cookie(volume->cache,
 290                                   test_bit(AFS_VOLUME_DELETED, &volume->flags));
 291         volume->cache = NULL;
 292 #endif
 293
 294         _leave("");
 295 }
 296
 297 /*
 298  * Query the VL service to update the volume status.
 299  */
 300 static int afs_update_volume_status(struct afs_volume *volume, struct key *key)
 301 {
 302         struct afs_server_list *new, *old, *discard;
 303         struct afs_vldb_entry *vldb;
 304         char idbuf[16];
 305         int ret, idsz;
 306
 307         _enter("");
 308
 309         /* We look up an ID by passing it as a decimal string in the
 310          * operation's name parameter.
 311          */
 312         idsz = sprintf(idbuf, "%u", volume->vid);
 313
 314         vldb = afs_vl_lookup_vldb(volume->cell, key, idbuf, idsz);
 315         if (IS_ERR(vldb)) {
 316                 ret = PTR_ERR(vldb);
 317                 goto error;
 318         }
 319
 320         /* See if the volume got renamed. */
 321         if (vldb->name_len != volume->name_len ||
 322             memcmp(vldb->name, volume->name, vldb->name_len) != 0) {
 323                 /* TODO: Use RCU'd string. */
 324                 memcpy(volume->name, vldb->name, AFS_MAXVOLNAME);
 325                 volume->name_len = vldb->name_len;
 326         }
 327
 328         /* See if the volume's server list got updated. */
 329         new = afs_alloc_server_list(volume->cell, key,
 330                                       vldb, (1 << volume->type));
 331         if (IS_ERR(new)) {
 332                 ret = PTR_ERR(new);
 333                 goto error_vldb;
 334         }
 335
 336         write_lock(&volume->servers_lock);
 337
 338         discard = new;
 339         old = volume->servers;
 340         if (afs_annotate_server_list(new, old)) {
 341                 new->seq = volume->servers_seq + 1;
 342                 volume->servers = new;
 343                 smp_wmb();
 344                 volume->servers_seq++;
 345                 discard = old;
 346         }
 347
 348         volume->update_at = ktime_get_real_seconds() + afs_volume_record_life;
 349         clear_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);
 350         write_unlock(&volume->servers_lock);
 351         ret = 0;
 352
 353         afs_put_serverlist(volume->cell->net, discard);
 354 error_vldb:
 355         kfree(vldb);
 356 error:
 357         _leave(" = %d", ret);
 358         return ret;
 359 }
 360
 361 /*
 362  * Make sure the volume record is up to date.
 363  */
 364 int afs_check_volume_status(struct afs_volume *volume, struct key *key)
 365 {
 366         time64_t now = ktime_get_real_seconds();
 367         int ret, retries = 0;
 368
 369         _enter("");
 370
 371         if (volume->update_at <= now)
 372                 set_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);
 373
 374 retry:
 375         if (!test_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags) &&
 376             !test_bit(AFS_VOLUME_WAIT, &volume->flags)) {
 377                 _leave(" = 0");
 378                 return 0;
 379         }
 380
 381         if (!test_and_set_bit_lock(AFS_VOLUME_UPDATING, &volume->flags)) {
 382                 ret = afs_update_volume_status(volume, key);
 383                 clear_bit_unlock(AFS_VOLUME_WAIT, &volume->flags);
 384                 clear_bit_unlock(AFS_VOLUME_UPDATING, &volume->flags);
 385                 wake_up_bit(&volume->flags, AFS_VOLUME_WAIT);
 386                 _leave(" = %d", ret);
 387                 return ret;
 388         }
 389
 390         if (!test_bit(AFS_VOLUME_WAIT, &volume->flags)) {
 391                 _leave(" = 0 [no wait]");
 392                 return 0;
 393         }
 394
 395         ret = wait_on_bit(&volume->flags, AFS_VOLUME_WAIT, TASK_INTERRUPTIBLE);
 396         if (ret == -ERESTARTSYS) {
 397                 _leave(" = %d", ret);
 398                 return ret;
 399         }
 400
 401         retries++;
 402         if (retries == 4) {
 403                 _leave(" = -ESTALE");
 404                 return -ESTALE;
 405         }
 406         goto retry;
 407 }