* Copyright 2008 Sun Microsystems, Inc. All rights reserved
* Use is subject to license terms.
*
- * Copyright (c) 2012, 2014 Intel Corporation.
+ * Copyright (c) 2012, 2017, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
LASSERT(hlist_unhashed(&pool->pool_hash));
LASSERT(list_empty(&pool->pool_list));
LASSERT(pool->pool_proc_entry == NULL);
- lod_ost_pool_free(&(pool->pool_rr.lqr_pool));
- lod_ost_pool_free(&(pool->pool_obds));
+ lod_tgt_pool_free(&(pool->pool_rr.lqr_pool));
+ lod_tgt_pool_free(&(pool->pool_obds));
OBD_FREE_PTR(pool);
EXIT;
}
if (*pos >= pool_tgt_count(iter->lpi_pool))
return NULL;
+ OBD_FAIL_TIMEOUT(OBD_FAIL_OST_LIST_ASSERT, cfs_fail_val);
+
/* iterate to find a non empty entry */
prev_idx = iter->lpi_idx;
- down_read(&pool_tgt_rw_sem(iter->lpi_pool));
iter->lpi_idx++;
- if (iter->lpi_idx == pool_tgt_count(iter->lpi_pool)) {
+ if (iter->lpi_idx >= pool_tgt_count(iter->lpi_pool)) {
iter->lpi_idx = prev_idx; /* we stay on the last entry */
- up_read(&pool_tgt_rw_sem(iter->lpi_pool));
return NULL;
}
- up_read(&pool_tgt_rw_sem(iter->lpi_pool));
(*pos)++;
/* return != NULL to continue */
return iter;
iter->lpi_idx = 0;
seq->private = iter;
+ down_read(&pool_tgt_rw_sem(pool));
if (*pos > 0) {
loff_t i;
void *ptr;
struct lod_pool_iterator *iter = seq->private;
if (iter != NULL && iter->lpi_magic == POOL_IT_MAGIC) {
+ up_read(&pool_tgt_rw_sem(iter->lpi_pool));
seq->private = iter->lpi_pool;
lod_pool_putref(iter->lpi_pool);
OBD_FREE_PTR(iter);
LASSERT(iter->lpi_pool != NULL);
LASSERT(iter->lpi_idx <= pool_tgt_count(iter->lpi_pool));
- down_read(&pool_tgt_rw_sem(iter->lpi_pool));
tgt = pool_tgt(iter->lpi_pool, iter->lpi_idx);
- up_read(&pool_tgt_rw_sem(iter->lpi_pool));
if (tgt != NULL)
seq_printf(seq, "%s\n", obd_uuid2str(&(tgt->ltd_uuid)));
* \retval negative error number on failure
*/
#define POOL_INIT_COUNT 2
-int lod_ost_pool_init(struct ost_pool *op, unsigned int count)
+int lod_tgt_pool_init(struct lu_tgt_pool *op, unsigned int count)
{
ENTRY;
op->op_array = NULL;
op->op_count = 0;
init_rwsem(&op->op_rw_sem);
- op->op_size = count;
- OBD_ALLOC(op->op_array, op->op_size * sizeof(op->op_array[0]));
+ op->op_size = count * sizeof(op->op_array[0]);
+ OBD_ALLOC(op->op_array, op->op_size);
if (op->op_array == NULL) {
op->op_size = 0;
RETURN(-ENOMEM);
* \retval 0 on success
* \retval negative error number on failure.
*/
-int lod_ost_pool_extend(struct ost_pool *op, unsigned int min_count)
+int lod_tgt_pool_extend(struct lu_tgt_pool *op, unsigned int min_count)
{
__u32 *new;
- int new_size;
+ __u32 new_size;
LASSERT(min_count != 0);
- if (op->op_count < op->op_size)
+ if (op->op_count * sizeof(op->op_array[0]) < op->op_size)
return 0;
- new_size = max(min_count, 2 * op->op_size);
- OBD_ALLOC(new, new_size * sizeof(op->op_array[0]));
+ new_size = max_t(__u32, min_count * sizeof(op->op_array[0]),
+ 2 * op->op_size);
+ OBD_ALLOC(new, new_size);
if (new == NULL)
return -ENOMEM;
/* copy old array to new one */
- memcpy(new, op->op_array, op->op_size * sizeof(op->op_array[0]));
- OBD_FREE(op->op_array, op->op_size * sizeof(op->op_array[0]));
+ memcpy(new, op->op_array, op->op_size);
+ OBD_FREE(op->op_array, op->op_size);
op->op_array = new;
op->op_size = new_size;
* \retval 0 if target could be added to the pool
* \retval negative error if target \a idx was not added
*/
-int lod_ost_pool_add(struct ost_pool *op, __u32 idx, unsigned int min_count)
+int lod_tgt_pool_add(struct lu_tgt_pool *op, __u32 idx, unsigned int min_count)
{
unsigned int i;
int rc = 0;
down_write(&op->op_rw_sem);
- rc = lod_ost_pool_extend(op, min_count);
+ rc = lod_tgt_pool_extend(op, min_count);
if (rc)
GOTO(out, rc);
* \retval 0 on success
* \retval negative error number on failure
*/
-int lod_ost_pool_remove(struct ost_pool *op, __u32 idx)
+int lod_tgt_pool_remove(struct lu_tgt_pool *op, __u32 idx)
{
unsigned int i;
ENTRY;
*
* \retval 0 on success or if pool was already freed
*/
-int lod_ost_pool_free(struct ost_pool *op)
+int lod_tgt_pool_free(struct lu_tgt_pool *op)
{
ENTRY;
down_write(&op->op_rw_sem);
- OBD_FREE(op->op_array, op->op_size * sizeof(op->op_array[0]));
+ OBD_FREE(op->op_array, op->op_size);
op->op_array = NULL;
op->op_count = 0;
op->op_size = 0;
strlcpy(new_pool->pool_name, poolname, sizeof(new_pool->pool_name));
new_pool->pool_lobd = obd;
atomic_set(&new_pool->pool_refcount, 1);
- rc = lod_ost_pool_init(&new_pool->pool_obds, 0);
+ rc = lod_tgt_pool_init(&new_pool->pool_obds, 0);
if (rc)
GOTO(out_err, rc);
- lod_qos_rr_init(&new_pool->pool_rr);
- rc = lod_ost_pool_init(&new_pool->pool_rr.lqr_pool, 0);
+ lu_qos_rr_init(&new_pool->pool_rr);
+
+ rc = lod_tgt_pool_init(&new_pool->pool_rr.lqr_pool, 0);
if (rc)
GOTO(out_free_pool_obds, rc);
lprocfs_remove(&new_pool->pool_proc_entry);
- lod_ost_pool_free(&new_pool->pool_rr.lqr_pool);
+ lod_tgt_pool_free(&new_pool->pool_rr.lqr_pool);
out_free_pool_obds:
- lod_ost_pool_free(&new_pool->pool_obds);
+ lod_tgt_pool_free(&new_pool->pool_obds);
OBD_FREE_PTR(new_pool);
return rc;
}
*/
int lod_pool_add(struct obd_device *obd, char *poolname, char *ostname)
{
- struct lod_device *lod = lu2lod_dev(obd->obd_lu_dev);
- struct obd_uuid ost_uuid;
- struct pool_desc *pool;
- unsigned int idx;
- int rc = -EINVAL;
+ struct lod_device *lod = lu2lod_dev(obd->obd_lu_dev);
+ struct obd_uuid ost_uuid;
+ struct pool_desc *pool;
+ struct lu_tgt_desc *tgt;
+ int rc = -EINVAL;
ENTRY;
pool = cfs_hash_lookup(lod->lod_pools_hash_body, poolname);
/* search ost in lod array */
lod_getref(&lod->lod_ost_descs);
- lod_foreach_ost(lod, idx) {
- if (obd_uuid_equals(&ost_uuid, &OST_TGT(lod, idx)->ltd_uuid)) {
+ lod_foreach_ost(lod, tgt) {
+ if (obd_uuid_equals(&ost_uuid, &tgt->ltd_uuid)) {
rc = 0;
break;
}
if (rc)
GOTO(out, rc);
- rc = lod_ost_pool_add(&pool->pool_obds, idx, lod->lod_osts_size);
+ rc = lod_tgt_pool_add(&pool->pool_obds, tgt->ltd_index,
+ lod->lod_ost_count);
if (rc)
GOTO(out, rc);
*/
int lod_pool_remove(struct obd_device *obd, char *poolname, char *ostname)
{
- struct lod_device *lod = lu2lod_dev(obd->obd_lu_dev);
- struct obd_uuid ost_uuid;
- struct pool_desc *pool;
- unsigned int idx;
- int rc = -EINVAL;
+ struct lod_device *lod = lu2lod_dev(obd->obd_lu_dev);
+ struct lu_tgt_desc *ost;
+ struct obd_uuid ost_uuid;
+ struct pool_desc *pool;
+ int rc = -EINVAL;
ENTRY;
pool = cfs_hash_lookup(lod->lod_pools_hash_body, poolname);
obd_str2uuid(&ost_uuid, ostname);
lod_getref(&lod->lod_ost_descs);
- cfs_foreach_bit(lod->lod_ost_bitmap, idx) {
- if (obd_uuid_equals(&ost_uuid, &OST_TGT(lod, idx)->ltd_uuid)) {
+ lod_foreach_ost(lod, ost) {
+ if (obd_uuid_equals(&ost_uuid, &ost->ltd_uuid)) {
rc = 0;
break;
}
if (rc)
GOTO(out, rc);
- lod_ost_pool_remove(&pool->pool_obds, idx);
-
+ lod_tgt_pool_remove(&pool->pool_obds, ost->ltd_index);
pool->pool_rr.lqr_dirty = 1;
CDEBUG(D_CONFIG, "%s removed from "LOV_POOLNAMEF"\n", ostname,