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