* 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/
{
CDEBUG(D_INFO, "pool %p\n", pool);
if (atomic_dec_and_test(&pool->pool_refcount)) {
- LASSERT(cfs_hlist_unhashed(&pool->pool_hash));
- LASSERT(cfs_list_empty(&pool->pool_list));
+ 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));
*
* \retval computed hash value from \a key and limited by \a mask
*/
-static __u32 pool_hashfn(cfs_hash_t *hash_body, const void *key, unsigned mask)
+static __u32 pool_hashfn(struct cfs_hash *hash_body, const void *key,
+ unsigned mask)
{
return cfs_hash_djb2_hash(key, strnlen(key, LOV_MAXPOOLNAME), mask);
}
*
* \retval char array referencing the pool name (no refcount)
*/
-static void *pool_key(cfs_hlist_node_t *hnode)
+static void *pool_key(struct hlist_node *hnode)
{
struct pool_desc *pool;
- pool = cfs_hlist_entry(hnode, struct pool_desc, pool_hash);
+ pool = hlist_entry(hnode, struct pool_desc, pool_hash);
return pool->pool_name;
}
* \retval 0 if \a key is the same as the key of \a compared
* \retval 1 if \a key is different from the key of \a compared
*/
-static int pool_hashkey_keycmp(const void *key, cfs_hlist_node_t *compared_hnode)
+static int pool_hashkey_keycmp(const void *key, struct hlist_node *compared)
{
- char *pool_name;
- struct pool_desc *pool;
-
- pool_name = (char *)key;
- pool = cfs_hlist_entry(compared_hnode, struct pool_desc, pool_hash);
- return !strncmp(pool_name, pool->pool_name, LOV_MAXPOOLNAME);
+ return !strncmp(key, pool_key(compared), LOV_MAXPOOLNAME);
}
/**
*
* \retval struct pool_desc for the specified \a hnode
*/
-static void *pool_hashobject(cfs_hlist_node_t *hnode)
+static void *pool_hashobject(struct hlist_node *hnode)
{
- return cfs_hlist_entry(hnode, struct pool_desc, pool_hash);
+ return hlist_entry(hnode, struct pool_desc, pool_hash);
}
-static void pool_hashrefcount_get(cfs_hash_t *hs, cfs_hlist_node_t *hnode)
+static void pool_hashrefcount_get(struct cfs_hash *hs, struct hlist_node *hnode)
{
struct pool_desc *pool;
- pool = cfs_hlist_entry(hnode, struct pool_desc, pool_hash);
+ pool = hlist_entry(hnode, struct pool_desc, pool_hash);
pool_getref(pool);
}
-static void pool_hashrefcount_put_locked(cfs_hash_t *hs,
- cfs_hlist_node_t *hnode)
+static void pool_hashrefcount_put_locked(struct cfs_hash *hs,
+ struct hlist_node *hnode)
{
struct pool_desc *pool;
- pool = cfs_hlist_entry(hnode, struct pool_desc, pool_hash);
+ pool = hlist_entry(hnode, struct pool_desc, pool_hash);
pool_putref_locked(pool);
}
-cfs_hash_ops_t pool_hash_operations = {
+struct cfs_hash_ops pool_hash_operations = {
.hs_hash = pool_hashfn,
.hs_key = pool_key,
.hs_keycmp = pool_hashkey_keycmp,
#define POOL_IT_MAGIC 0xB001CEA0
struct lod_pool_iterator {
- int lpi_magic; /* POOL_IT_MAGIC */
- int lpi_idx; /* from 0 to pool_tgt_size - 1 */
+ unsigned int lpi_magic; /* POOL_IT_MAGIC */
+ unsigned int lpi_idx; /* from 0 to pool_tgt_size - 1 */
struct pool_desc *lpi_pool;
};
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)));
*/
void lod_dump_pool(int level, struct pool_desc *pool)
{
- int i;
+ unsigned int i;
pool_getref(pool);
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);
int lod_ost_pool_extend(struct ost_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;
*/
int lod_ost_pool_add(struct ost_pool *op, __u32 idx, unsigned int min_count)
{
- int rc = 0, i;
+ unsigned int i;
+ int rc = 0;
ENTRY;
down_write(&op->op_rw_sem);
*/
int lod_ost_pool_remove(struct ost_pool *op, __u32 idx)
{
- int i;
+ unsigned int i;
ENTRY;
down_write(&op->op_rw_sem);
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;
if (rc)
GOTO(out_err, rc);
- memset(&new_pool->pool_rr, 0, sizeof(new_pool->pool_rr));
+ lu_qos_rr_init(&new_pool->pool_rr);
+
rc = lod_ost_pool_init(&new_pool->pool_rr.lqr_pool, 0);
if (rc)
GOTO(out_free_pool_obds, rc);
INIT_HLIST_NODE(&new_pool->pool_hash);
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
pool_getref(new_pool);
new_pool->pool_proc_entry = lprocfs_add_simple(lod->lod_pool_proc_entry,
- poolname,
-#ifndef HAVE_ONLY_PROCFS_SEQ
- NULL, NULL,
-#endif
- new_pool,
+ poolname, new_pool,
&pool_proc_operations);
if (IS_ERR(new_pool->pool_proc_entry)) {
CDEBUG(D_CONFIG, "%s: cannot add proc entry "LOV_POOLNAMEF"\n",
#endif
spin_lock(&obd->obd_dev_lock);
- cfs_list_add_tail(&new_pool->pool_list, &lod->lod_pool_list);
+ list_add_tail(&new_pool->pool_list, &lod->lod_pool_list);
lod->lod_pool_count++;
spin_unlock(&obd->obd_dev_lock);
out_err:
spin_lock(&obd->obd_dev_lock);
- cfs_list_del_init(&new_pool->pool_list);
+ list_del_init(&new_pool->pool_list);
lod->lod_pool_count--;
spin_unlock(&obd->obd_dev_lock);
}
spin_lock(&obd->obd_dev_lock);
- cfs_list_del_init(&pool->pool_list);
+ list_del_init(&pool->pool_list);
lod->lod_pool_count--;
spin_unlock(&obd->obd_dev_lock);
*/
int lod_check_index_in_pool(__u32 idx, struct pool_desc *pool)
{
- int i, rc;
+ unsigned int i;
+ int rc;
ENTRY;
pool_getref(pool);