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  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/lov/lov_pool.c
  33  *
  34  * OST pool methods
  35  *
  36  * Author: Jacques-Charles LAFOUCRIERE <jc.lafoucriere@cea.fr>
  37  * Author: Alex Lyashkov <Alexey.Lyashkov@Sun.COM>
  38  * Author: Nathaniel Rutman <Nathan.Rutman@Sun.COM>
  39  */
  40
  41 #define DEBUG_SUBSYSTEM S_LOV
  42
  43 #include <libcfs/libcfs.h>
  44 #include <libcfs/linux/linux-hash.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 file_operations pool_proc_operations = {
 227         .open           = pool_proc_open,
 228         .read           = seq_read,
 229         .llseek         = seq_lseek,
 230         .release        = seq_release,
 231 };
 232 #endif /* CONFIG_PROC_FS */
 233
 234 void lov_dump_pool(int level, struct pool_desc *pool)
 235 {
 236         int i;
 237
 238         lov_pool_getref(pool);
 239
 240         CDEBUG(level, "pool "LOV_POOLNAMEF" has %d members\n",
 241                pool->pool_name, pool->pool_obds.op_count);
 242         down_read(&pool_tgt_rw_sem(pool));
 243
 244         for (i = 0; i < pool_tgt_count(pool) ; i++) {
 245                 if (!pool_tgt(pool, i) || !(pool_tgt(pool, i))->ltd_exp)
 246                         continue;
 247                 CDEBUG(level, "pool "LOV_POOLNAMEF"[%d] = %s\n",
 248                        pool->pool_name, i,
 249                        obd_uuid2str(&((pool_tgt(pool, i))->ltd_uuid)));
 250         }
 251
 252         up_read(&pool_tgt_rw_sem(pool));
 253         lov_pool_putref(pool);
 254 }
 255
 256 static void pools_hash_exit(void *vpool, void *data)
 257 {
 258         struct pool_desc *pool = vpool;
 259
 260         lov_pool_putref(pool);
 261 }
 262
 263 int lov_pool_hash_init(struct rhashtable *tbl)
 264 {
 265         return rhashtable_init(tbl, &pools_hash_params);
 266 }
 267
 268 void lov_pool_hash_destroy(struct rhashtable *tbl)
 269 {
 270         rhashtable_free_and_destroy(tbl, pools_hash_exit, NULL);
 271 }
 272
 273 int lov_pool_new(struct obd_device *obd, char *poolname)
 274 {
 275         struct lov_obd *lov;
 276         struct pool_desc *new_pool;
 277         int rc;
 278         ENTRY;
 279
 280         lov = &(obd->u.lov);
 281
 282         if (strlen(poolname) > LOV_MAXPOOLNAME)
 283                 RETURN(-ENAMETOOLONG);
 284
 285         /* OBD_ALLOC doesn't work with direct use of kfree_rcu */
 286         new_pool = kmalloc(sizeof(*new_pool), GFP_KERNEL);
 287         if (new_pool == NULL)
 288                 RETURN(-ENOMEM);
 289
 290         strlcpy(new_pool->pool_name, poolname, sizeof(new_pool->pool_name));
 291         new_pool->pool_lobd = obd;
 292         /* ref count init to 1 because when created a pool is always used
 293          * up to deletion
 294          */
 295         atomic_set(&new_pool->pool_refcount, 1);
 296         rc = tgt_pool_init(&new_pool->pool_obds, 0);
 297         if (rc)
 298                 GOTO(out_err, rc);
 299
 300 #ifdef CONFIG_PROC_FS
 301         /* get ref for /proc file */
 302         lov_pool_getref(new_pool);
 303         new_pool->pool_proc_entry = lprocfs_add_simple(lov->lov_pool_proc_entry,
 304                                                        poolname, new_pool,
 305                                                        &pool_proc_operations);
 306         if (IS_ERR(new_pool->pool_proc_entry)) {
 307                 CWARN("Cannot add proc pool entry "LOV_POOLNAMEF"\n", poolname);
 308                 new_pool->pool_proc_entry = NULL;
 309                 lov_pool_putref(new_pool);
 310         }
 311         CDEBUG(D_INFO, "pool %p - proc %p\n",
 312                new_pool, new_pool->pool_proc_entry);
 313 #endif
 314
 315         spin_lock(&obd->obd_dev_lock);
 316         list_add_tail(&new_pool->pool_list, &lov->lov_pool_list);
 317         lov->lov_pool_count++;
 318         spin_unlock(&obd->obd_dev_lock);
 319
 320         /* Add to hash table only when it is fully ready. */
 321         rc = rhashtable_lookup_insert_fast(&lov->lov_pools_hash_body,
 322                                            &new_pool->pool_hash,
 323                                            pools_hash_params);
 324         if (rc) {
 325                 if (rc != -EEXIST)
 326                         /*
 327                          * Hide -E2BIG and -EBUSY which
 328                          * are not helpful.
 329                          */
 330                         rc = -ENOMEM;
 331                 GOTO(out_err, rc);
 332         }
 333
 334         CDEBUG(D_CONFIG, LOV_POOLNAMEF" is pool #%d\n",
 335                poolname, lov->lov_pool_count);
 336
 337         RETURN(0);
 338
 339 out_err:
 340         spin_lock(&obd->obd_dev_lock);
 341         list_del_init(&new_pool->pool_list);
 342         lov->lov_pool_count--;
 343         spin_unlock(&obd->obd_dev_lock);
 344         lprocfs_remove(&new_pool->pool_proc_entry);
 345         tgt_pool_free(&new_pool->pool_obds);
 346         OBD_FREE_PTR(new_pool);
 347
 348         return rc;
 349 }
 350
 351 struct pool_desc *lov_pool_find(struct obd_device *obd, char *poolname)
 352 {
 353         struct pool_desc *pool;
 354         struct lov_obd *lov = &obd->u.lov;
 355
 356         rcu_read_lock();
 357         pool = rhashtable_lookup(&lov->lov_pools_hash_body,
 358                                  poolname,
 359                                  pools_hash_params);
 360         if (pool && !atomic_inc_not_zero(&pool->pool_refcount))
 361                 pool = NULL;
 362         rcu_read_unlock();
 363
 364         return pool;
 365 }
 366
 367 int lov_pool_del(struct obd_device *obd, char *poolname)
 368 {
 369         struct lov_obd *lov;
 370         struct pool_desc *pool;
 371         ENTRY;
 372
 373         lov = &(obd->u.lov);
 374
 375         /* lookup and kill hash reference */
 376         rcu_read_lock();
 377         pool = rhashtable_lookup(&lov->lov_pools_hash_body, poolname,
 378                                  pools_hash_params);
 379         if (pool && rhashtable_remove_fast(&lov->lov_pools_hash_body,
 380                                            &pool->pool_hash,
 381                                            pools_hash_params) != 0)
 382                 pool = NULL;
 383         rcu_read_unlock();
 384         if (!pool)
 385                 RETURN(-ENOENT);
 386
 387         if (pool->pool_proc_entry != NULL) {
 388                 CDEBUG(D_INFO, "proc entry %p\n", pool->pool_proc_entry);
 389                 lprocfs_remove(&pool->pool_proc_entry);
 390                 lov_pool_putref(pool);
 391         }
 392
 393         spin_lock(&obd->obd_dev_lock);
 394         list_del_init(&pool->pool_list);
 395         lov->lov_pool_count--;
 396         spin_unlock(&obd->obd_dev_lock);
 397
 398         /* release last reference */
 399         lov_pool_putref(pool);
 400
 401         RETURN(0);
 402 }
 403
 404
 405 int lov_pool_add(struct obd_device *obd, char *poolname, char *ostname)
 406 {
 407         struct obd_uuid ost_uuid;
 408         struct lov_obd *lov;
 409         struct pool_desc *pool;
 410         unsigned int lov_idx;
 411         int rc;
 412         ENTRY;
 413
 414         lov = &(obd->u.lov);
 415
 416         rcu_read_lock();
 417         pool = rhashtable_lookup(&lov->lov_pools_hash_body, poolname,
 418                                  pools_hash_params);
 419         if (pool && !atomic_inc_not_zero(&pool->pool_refcount))
 420                 pool = NULL;
 421         rcu_read_unlock();
 422         if (!pool)
 423                 RETURN(-ENOENT);
 424
 425         obd_str2uuid(&ost_uuid, ostname);
 426
 427
 428         /* search ost in lov array */
 429         lov_tgts_getref(obd);
 430         for (lov_idx = 0; lov_idx < lov->desc.ld_tgt_count; lov_idx++) {
 431                 if (!lov->lov_tgts[lov_idx])
 432                         continue;
 433                 if (obd_uuid_equals(&ost_uuid,
 434                                     &(lov->lov_tgts[lov_idx]->ltd_uuid)))
 435                         break;
 436         }
 437         /* test if ost found in lov */
 438         if (lov_idx == lov->desc.ld_tgt_count)
 439                 GOTO(out, rc = -EINVAL);
 440
 441         rc = tgt_pool_add(&pool->pool_obds, lov_idx, lov->lov_tgt_size);
 442         if (rc)
 443                 GOTO(out, rc);
 444
 445         CDEBUG(D_CONFIG, "Added %s to "LOV_POOLNAMEF" as member %d\n",
 446                ostname, poolname,  pool_tgt_count(pool));
 447
 448         EXIT;
 449 out:
 450         lov_tgts_putref(obd);
 451         lov_pool_putref(pool);
 452
 453         return rc;
 454 }
 455
 456 int lov_pool_remove(struct obd_device *obd, char *poolname, char *ostname)
 457 {
 458         struct obd_uuid ost_uuid;
 459         struct lov_obd *lov;
 460         struct pool_desc *pool;
 461         unsigned int lov_idx;
 462         int rc = 0;
 463         ENTRY;
 464
 465         lov = &(obd->u.lov);
 466
 467         /* lookup and kill hash reference */
 468         rcu_read_lock();
 469         pool = rhashtable_lookup(&lov->lov_pools_hash_body, poolname,
 470                                  pools_hash_params);
 471         if (pool && !atomic_inc_not_zero(&pool->pool_refcount))
 472                 pool = NULL;
 473         rcu_read_unlock();
 474         if (!pool)
 475                 RETURN(-ENOENT);
 476
 477         obd_str2uuid(&ost_uuid, ostname);
 478
 479         lov_tgts_getref(obd);
 480         /* search ost in lov array, to get index */
 481         for (lov_idx = 0; lov_idx < lov->desc.ld_tgt_count; lov_idx++) {
 482                 if (!lov->lov_tgts[lov_idx])
 483                         continue;
 484
 485                 if (obd_uuid_equals(&ost_uuid,
 486                                     &(lov->lov_tgts[lov_idx]->ltd_uuid)))
 487                         break;
 488         }
 489
 490         /* test if ost found in lov */
 491         if (lov_idx == lov->desc.ld_tgt_count)
 492                 GOTO(out, rc = -EINVAL);
 493
 494         tgt_pool_remove(&pool->pool_obds, lov_idx);
 495
 496         CDEBUG(D_CONFIG, "%s removed from "LOV_POOLNAMEF"\n", ostname,
 497                poolname);
 498
 499         EXIT;
 500 out:
 501         lov_tgts_putref(obd);
 502         lov_pool_putref(pool);
 503
 504         return rc;
 505 }