lustre/lov/lov_pool.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2012, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  *
  31  * lustre/lov/lov_pool.c
  32  *
  33  * OST pool methods
  34  *
  35  * Author: Jacques-Charles LAFOUCRIERE <jc.lafoucriere@cea.fr>
  36  * Author: Alex Lyashkov <Alexey.Lyashkov@Sun.COM>
  37  * Author: Nathaniel Rutman <Nathan.Rutman@Sun.COM>
  38  */
  39
  40 #define DEBUG_SUBSYSTEM S_LOV
  41
  42 #include <libcfs/libcfs.h>
  43 #include <libcfs/linux/linux-hash.h>
  44 #include <libcfs/linux/linux-fs.h>
  45
  46 #include <obd.h>
  47 #include "lov_internal.h"
  48
  49 #define pool_tgt(_p, _i) \
  50                 _p->pool_lobd->u.lov.lov_tgts[_p->pool_obds.op_array[_i]]
  51
  52 static u32 pool_hashfh(const void *data, u32 len, u32 seed)
  53 {
  54         const char *pool_name = data;
  55
  56         return hashlen_hash(cfs_hashlen_string((void *)(unsigned long)seed,
  57                                                pool_name));
  58 }
  59
  60 static int pool_cmpfn(struct rhashtable_compare_arg *arg, const void *obj)
  61 {
  62         const struct pool_desc *pool = obj;
  63         const char *pool_name = arg->key;
  64
  65         return strcmp(pool_name, pool->pool_name);
  66 }
  67
  68 static const struct rhashtable_params pools_hash_params = {
  69         .key_len        = 1, /* actually variable */
  70         .key_offset     = offsetof(struct pool_desc, pool_name),
  71         .head_offset    = offsetof(struct pool_desc, pool_hash),
  72         .hashfn         = pool_hashfh,
  73         .obj_cmpfn      = pool_cmpfn,
  74         .automatic_shrinking = true,
  75 };
  76
  77 static void lov_pool_getref(struct pool_desc *pool)
  78 {
  79         CDEBUG(D_INFO, "pool %p\n", pool);
  80         atomic_inc(&pool->pool_refcount);
  81 }
  82
  83 void lov_pool_putref(struct pool_desc *pool)
  84 {
  85         CDEBUG(D_INFO, "pool %p\n", pool);
  86         if (atomic_dec_and_test(&pool->pool_refcount)) {
  87                 LASSERT(list_empty(&pool->pool_list));
  88                 LASSERT(pool->pool_proc_entry == NULL);
  89                 tgt_pool_free(&(pool->pool_obds));
  90                 kfree_rcu(pool, pool_rcu);
  91                 EXIT;
  92         }
  93 }
  94
  95 #ifdef CONFIG_PROC_FS
  96 /*
  97  * pool /proc seq_file methods
  98  */
  99 /*
 100  * iterator is used to go through the target pool entries
 101  * index is the current entry index in the lp_array[] array
 102  * index >= pos returned to the seq_file interface
 103  * pos is from 0 to (pool->pool_obds.op_count - 1)
 104  */
 105 #define POOL_IT_MAGIC 0xB001CEA0
 106 struct pool_iterator {
 107         int magic;
 108         struct pool_desc *pool;
 109         int idx;        /* from 0 to pool_tgt_size - 1 */
 110 };
 111
 112 static void *pool_proc_next(struct seq_file *s, void *v, loff_t *pos)
 113 {
 114         struct pool_iterator *iter = (struct pool_iterator *)s->private;
 115         int prev_idx;
 116
 117         LASSERTF(iter->magic == POOL_IT_MAGIC, "%08X\n", iter->magic);
 118
 119         (*pos)++;
 120         /* test if end of file */
 121         if (*pos > pool_tgt_count(iter->pool))
 122                 return NULL;
 123
 124         /* iterate to find a non empty entry */
 125         prev_idx = iter->idx;
 126         iter->idx++;
 127         if (iter->idx >= pool_tgt_count(iter->pool)) {
 128                 iter->idx = prev_idx; /* we stay on the last entry */
 129                 return NULL;
 130         }
 131         /* return != NULL to continue */
 132         return iter;
 133 }
 134
 135 static void *pool_proc_start(struct seq_file *s, loff_t *pos)
 136 {
 137         struct pool_desc *pool = (struct pool_desc *)s->private;
 138         struct pool_iterator *iter;
 139
 140         lov_pool_getref(pool);
 141         if ((pool_tgt_count(pool) == 0) ||
 142             (*pos >= pool_tgt_count(pool))) {
 143                 /* iter is not created, so stop() has no way to
 144                  * find pool to dec ref */
 145                 lov_pool_putref(pool);
 146                 return NULL;
 147         }
 148
 149         OBD_ALLOC_PTR(iter);
 150         if (!iter)
 151                 return ERR_PTR(-ENOMEM);
 152         iter->magic = POOL_IT_MAGIC;
 153         iter->pool = pool;
 154         iter->idx = 0;
 155
 156         /* we use seq_file private field to memorized iterator so
 157          * we can free it at stop() */
 158         /* /!\ do not forget to restore it to pool before freeing it */
 159         s->private = iter;
 160         down_read(&pool_tgt_rw_sem(pool));
 161         if (*pos > 0) {
 162                 loff_t i;
 163                 void *ptr;
 164
 165                 i = 0;
 166                 do {
 167                      ptr = pool_proc_next(s, &iter, &i);
 168                 } while ((i < *pos) && (ptr != NULL));
 169                 return ptr;
 170         }
 171         return iter;
 172 }
 173
 174 static void pool_proc_stop(struct seq_file *s, void *v)
 175 {
 176         struct pool_iterator *iter = (struct pool_iterator *)s->private;
 177
 178         /* in some cases stop() method is called 2 times, without
 179          * calling start() method (see seq_read() from fs/seq_file.c)
 180          * we have to free only if s->private is an iterator */
 181         if ((iter) && (iter->magic == POOL_IT_MAGIC)) {
 182                 up_read(&pool_tgt_rw_sem(iter->pool));
 183                 /* we restore s->private so next call to pool_proc_start()
 184                  * will work */
 185                 s->private = iter->pool;
 186                 lov_pool_putref(iter->pool);
 187                 OBD_FREE_PTR(iter);
 188         }
 189 }
 190
 191 static int pool_proc_show(struct seq_file *s, void *v)
 192 {
 193         struct pool_iterator *iter = (struct pool_iterator *)v;
 194         struct lov_tgt_desc *tgt;
 195
 196         LASSERTF(iter->magic == POOL_IT_MAGIC, "%08X\n", iter->magic);
 197         LASSERT(iter->pool != NULL);
 198         LASSERT(iter->idx <= pool_tgt_count(iter->pool));
 199
 200         tgt = pool_tgt(iter->pool, iter->idx);
 201         if (tgt)
 202                 seq_printf(s, "%s\n", obd_uuid2str(&(tgt->ltd_uuid)));
 203
 204         return 0;
 205 }
 206
 207 static const struct seq_operations pool_proc_ops = {
 208         .start          = pool_proc_start,
 209         .next           = pool_proc_next,
 210         .stop           = pool_proc_stop,
 211         .show           = pool_proc_show,
 212 };
 213
 214 static int pool_proc_open(struct inode *inode, struct file *file)
 215 {
 216         int rc;
 217
 218         rc = seq_open(file, &pool_proc_ops);
 219         if (!rc) {
 220                 struct seq_file *s = file->private_data;
 221                 s->private = PDE_DATA(inode);
 222         }
 223         return rc;
 224 }
 225
 226 const static struct proc_ops pool_proc_operations = {
 227         .proc_open      = pool_proc_open,
 228         .proc_read      = seq_read,
 229         .proc_lseek     = seq_lseek,
 230         .proc_release   = seq_release,
 231 };
 232 #endif /* CONFIG_PROC_FS */
 233
 234 static void pools_hash_exit(void *vpool, void *data)
 235 {
 236         struct pool_desc *pool = vpool;
 237
 238         lov_pool_putref(pool);
 239 }
 240
 241 int lov_pool_hash_init(struct rhashtable *tbl)
 242 {
 243         return rhashtable_init(tbl, &pools_hash_params);
 244 }
 245
 246 void lov_pool_hash_destroy(struct rhashtable *tbl)
 247 {
 248         rhashtable_free_and_destroy(tbl, pools_hash_exit, NULL);
 249 }
 250
 251 int lov_pool_new(struct obd_device *obd, char *poolname)
 252 {
 253         struct lov_obd *lov;
 254         struct pool_desc *new_pool;
 255         int rc;
 256         ENTRY;
 257
 258         lov = &(obd->u.lov);
 259
 260         if (strlen(poolname) > LOV_MAXPOOLNAME)
 261                 RETURN(-ENAMETOOLONG);
 262
 263         /* OBD_ALLOC doesn't work with direct use of kfree_rcu */
 264         new_pool = kmalloc(sizeof(*new_pool), GFP_KERNEL);
 265         if (new_pool == NULL)
 266                 RETURN(-ENOMEM);
 267
 268         strlcpy(new_pool->pool_name, poolname, sizeof(new_pool->pool_name));
 269         new_pool->pool_lobd = obd;
 270         /* ref count init to 1 because when created a pool is always used
 271          * up to deletion
 272          */
 273         atomic_set(&new_pool->pool_refcount, 1);
 274         rc = tgt_pool_init(&new_pool->pool_obds, 0);
 275         if (rc)
 276                 GOTO(out_err, rc);
 277
 278 #ifdef CONFIG_PROC_FS
 279         /* get ref for /proc file */
 280         lov_pool_getref(new_pool);
 281         new_pool->pool_proc_entry = lprocfs_add_simple(lov->lov_pool_proc_entry,
 282                                                        poolname, new_pool,
 283                                                        &pool_proc_operations);
 284         if (IS_ERR(new_pool->pool_proc_entry)) {
 285                 CWARN("Cannot add proc pool entry "LOV_POOLNAMEF"\n", poolname);
 286                 new_pool->pool_proc_entry = NULL;
 287                 lov_pool_putref(new_pool);
 288         }
 289         CDEBUG(D_INFO, "pool %p - proc %p\n",
 290                new_pool, new_pool->pool_proc_entry);
 291 #endif
 292
 293         spin_lock(&obd->obd_dev_lock);
 294         list_add_tail(&new_pool->pool_list, &lov->lov_pool_list);
 295         lov->lov_pool_count++;
 296         spin_unlock(&obd->obd_dev_lock);
 297
 298         /* Add to hash table only when it is fully ready. */
 299         rc = rhashtable_lookup_insert_fast(&lov->lov_pools_hash_body,
 300                                            &new_pool->pool_hash,
 301                                            pools_hash_params);
 302         if (rc) {
 303                 if (rc != -EEXIST)
 304                         /*
 305                          * Hide -E2BIG and -EBUSY which
 306                          * are not helpful.
 307                          */
 308                         rc = -ENOMEM;
 309                 GOTO(out_err, rc);
 310         }
 311
 312         CDEBUG(D_CONFIG, LOV_POOLNAMEF" is pool #%d\n",
 313                poolname, lov->lov_pool_count);
 314
 315         RETURN(0);
 316
 317 out_err:
 318         spin_lock(&obd->obd_dev_lock);
 319         list_del_init(&new_pool->pool_list);
 320         lov->lov_pool_count--;
 321         spin_unlock(&obd->obd_dev_lock);
 322         lprocfs_remove(&new_pool->pool_proc_entry);
 323         tgt_pool_free(&new_pool->pool_obds);
 324         OBD_FREE_PTR(new_pool);
 325
 326         return rc;
 327 }
 328
 329 struct pool_desc *lov_pool_find(struct obd_device *obd, char *poolname)
 330 {
 331         struct pool_desc *pool;
 332         struct lov_obd *lov = &obd->u.lov;
 333
 334         rcu_read_lock();
 335         pool = rhashtable_lookup(&lov->lov_pools_hash_body,
 336                                  poolname,
 337                                  pools_hash_params);
 338         if (pool && !atomic_inc_not_zero(&pool->pool_refcount))
 339                 pool = NULL;
 340         rcu_read_unlock();
 341
 342         return pool;
 343 }
 344
 345 int lov_pool_del(struct obd_device *obd, char *poolname)
 346 {
 347         struct lov_obd *lov;
 348         struct pool_desc *pool;
 349         ENTRY;
 350
 351         lov = &(obd->u.lov);
 352
 353         /* lookup and kill hash reference */
 354         rcu_read_lock();
 355         pool = rhashtable_lookup(&lov->lov_pools_hash_body, poolname,
 356                                  pools_hash_params);
 357         if (pool && rhashtable_remove_fast(&lov->lov_pools_hash_body,
 358                                            &pool->pool_hash,
 359                                            pools_hash_params) != 0)
 360                 pool = NULL;
 361         rcu_read_unlock();
 362         if (!pool)
 363                 RETURN(-ENOENT);
 364
 365         if (pool->pool_proc_entry != NULL) {
 366                 CDEBUG(D_INFO, "proc entry %p\n", pool->pool_proc_entry);
 367                 lprocfs_remove(&pool->pool_proc_entry);
 368                 lov_pool_putref(pool);
 369         }
 370
 371         spin_lock(&obd->obd_dev_lock);
 372         list_del_init(&pool->pool_list);
 373         lov->lov_pool_count--;
 374         spin_unlock(&obd->obd_dev_lock);
 375
 376         /* release last reference */
 377         lov_pool_putref(pool);
 378
 379         RETURN(0);
 380 }
 381
 382
 383 int lov_pool_add(struct obd_device *obd, char *poolname, char *ostname)
 384 {
 385         struct obd_uuid ost_uuid;
 386         struct lov_obd *lov;
 387         struct pool_desc *pool;
 388         unsigned int lov_idx;
 389         int rc;
 390         ENTRY;
 391
 392         lov = &(obd->u.lov);
 393
 394         rcu_read_lock();
 395         pool = rhashtable_lookup(&lov->lov_pools_hash_body, poolname,
 396                                  pools_hash_params);
 397         if (pool && !atomic_inc_not_zero(&pool->pool_refcount))
 398                 pool = NULL;
 399         rcu_read_unlock();
 400         if (!pool)
 401                 RETURN(-ENOENT);
 402
 403         obd_str2uuid(&ost_uuid, ostname);
 404
 405
 406         /* search ost in lov array */
 407         lov_tgts_getref(obd);
 408         for (lov_idx = 0; lov_idx < lov->desc.ld_tgt_count; lov_idx++) {
 409                 if (!lov->lov_tgts[lov_idx])
 410                         continue;
 411                 if (obd_uuid_equals(&ost_uuid,
 412                                     &(lov->lov_tgts[lov_idx]->ltd_uuid)))
 413                         break;
 414         }
 415         /* test if ost found in lov */
 416         if (lov_idx == lov->desc.ld_tgt_count)
 417                 GOTO(out, rc = -EINVAL);
 418
 419         rc = tgt_pool_add(&pool->pool_obds, lov_idx, lov->lov_tgt_size);
 420         if (rc)
 421                 GOTO(out, rc);
 422
 423         CDEBUG(D_CONFIG, "Added %s to "LOV_POOLNAMEF" as member %d\n",
 424                ostname, poolname,  pool_tgt_count(pool));
 425
 426         EXIT;
 427 out:
 428         lov_tgts_putref(obd);
 429         lov_pool_putref(pool);
 430
 431         return rc;
 432 }
 433
 434 int lov_pool_remove(struct obd_device *obd, char *poolname, char *ostname)
 435 {
 436         struct obd_uuid ost_uuid;
 437         struct lov_obd *lov;
 438         struct pool_desc *pool;
 439         unsigned int lov_idx;
 440         int rc = 0;
 441         ENTRY;
 442
 443         lov = &(obd->u.lov);
 444
 445         /* lookup and kill hash reference */
 446         rcu_read_lock();
 447         pool = rhashtable_lookup(&lov->lov_pools_hash_body, poolname,
 448                                  pools_hash_params);
 449         if (pool && !atomic_inc_not_zero(&pool->pool_refcount))
 450                 pool = NULL;
 451         rcu_read_unlock();
 452         if (!pool)
 453                 RETURN(-ENOENT);
 454
 455         obd_str2uuid(&ost_uuid, ostname);
 456
 457         lov_tgts_getref(obd);
 458         /* search ost in lov array, to get index */
 459         for (lov_idx = 0; lov_idx < lov->desc.ld_tgt_count; lov_idx++) {
 460                 if (!lov->lov_tgts[lov_idx])
 461                         continue;
 462
 463                 if (obd_uuid_equals(&ost_uuid,
 464                                     &(lov->lov_tgts[lov_idx]->ltd_uuid)))
 465                         break;
 466         }
 467
 468         /* test if ost found in lov */
 469         if (lov_idx == lov->desc.ld_tgt_count)
 470                 GOTO(out, rc = -EINVAL);
 471
 472         tgt_pool_remove(&pool->pool_obds, lov_idx);
 473
 474         CDEBUG(D_CONFIG, "%s removed from "LOV_POOLNAMEF"\n", ostname,
 475                poolname);
 476
 477         EXIT;
 478 out:
 479         lov_tgts_putref(obd);
 480         lov_pool_putref(pool);
 481
 482         return rc;
 483 }