* in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU General Public License
- * version 2 along with this program; If not, see [sun.com URL with a
- * copy of GPLv2].
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * version 2 along with this program; If not, see
+ * http://www.gnu.org/licenses/gpl-2.0.html
*
* GPL HEADER END
*/
* Copyright (c) 2008, 2010, Oracle and/or its affiliates. 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/
};
#ifdef CONFIG_PROC_FS
-/* ifdef needed for liblustre support */
/*
* pool /proc seq_file methods
*/
/* iterate to find a non empty entry */
prev_idx = iter->idx;
- down_read(&pool_tgt_rw_sem(iter->pool));
iter->idx++;
- if (iter->idx == pool_tgt_count(iter->pool)) {
+ if (iter->idx >= pool_tgt_count(iter->pool)) {
iter->idx = prev_idx; /* we stay on the last entry */
- up_read(&pool_tgt_rw_sem(iter->pool));
return NULL;
}
- up_read(&pool_tgt_rw_sem(iter->pool));
(*pos)++;
/* return != NULL to continue */
return iter;
* we can free it at stop() */
/* /!\ do not forget to restore it to pool before freeing it */
s->private = iter;
+ down_read(&pool_tgt_rw_sem(pool));
if (*pos > 0) {
loff_t i;
void *ptr;
* calling start() method (see seq_read() from fs/seq_file.c)
* we have to free only if s->private is an iterator */
if ((iter) && (iter->magic == POOL_IT_MAGIC)) {
+ up_read(&pool_tgt_rw_sem(iter->pool));
/* we restore s->private so next call to pool_proc_start()
* will work */
s->private = iter->pool;
LASSERT(iter->pool != NULL);
LASSERT(iter->idx <= pool_tgt_count(iter->pool));
- down_read(&pool_tgt_rw_sem(iter->pool));
tgt = pool_tgt(iter->pool, iter->idx);
- up_read(&pool_tgt_rw_sem(iter->pool));
if (tgt)
seq_printf(s, "%s\n", obd_uuid2str(&(tgt->ltd_uuid)));
}
#define LOV_POOL_INIT_COUNT 2
-int lov_ost_pool_init(struct ost_pool *op, unsigned int count)
+int lov_ost_pool_init(struct lu_tgt_pool *op, unsigned int count)
{
- ENTRY;
+ ENTRY;
- if (count == 0)
- count = LOV_POOL_INIT_COUNT;
- op->op_array = NULL;
- op->op_count = 0;
+ if (count == 0)
+ count = LOV_POOL_INIT_COUNT;
+ 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]));
- if (op->op_array == NULL) {
- op->op_size = 0;
- RETURN(-ENOMEM);
- }
- EXIT;
- return 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);
+ }
+ EXIT;
+ return 0;
}
/* Caller must hold write op_rwlock */
-int lov_ost_pool_extend(struct ost_pool *op, unsigned int min_count)
+int lov_ost_pool_extend(struct lu_tgt_pool *op, unsigned int min_count)
{
- __u32 *new;
- int new_size;
-
- LASSERT(min_count != 0);
-
- if (op->op_count < op->op_size)
- return 0;
-
- new_size = max(min_count, 2 * op->op_size);
- OBD_ALLOC(new, new_size * sizeof(op->op_array[0]));
- 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]));
- op->op_array = new;
- op->op_size = new_size;
- return 0;
+ __u32 *new;
+ __u32 new_size;
+
+ LASSERT(min_count != 0);
+
+ if (op->op_count * sizeof(op->op_array[0]) < op->op_size)
+ return 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);
+ OBD_FREE(op->op_array, op->op_size);
+ op->op_array = new;
+ op->op_size = new_size;
+ return 0;
}
-int lov_ost_pool_add(struct ost_pool *op, __u32 idx, unsigned int min_count)
+int lov_ost_pool_add(struct lu_tgt_pool *op, __u32 idx, unsigned int min_count)
{
int rc = 0, i;
ENTRY;
return rc;
}
-int lov_ost_pool_remove(struct ost_pool *op, __u32 idx)
+int lov_ost_pool_remove(struct lu_tgt_pool *op, __u32 idx)
{
int i;
ENTRY;
RETURN(-EINVAL);
}
-int lov_ost_pool_free(struct ost_pool *op)
+int lov_ost_pool_free(struct lu_tgt_pool *op)
{
- ENTRY;
+ ENTRY;
- if (op->op_size == 0)
- RETURN(0);
+ if (op->op_size == 0)
+ RETURN(0);
down_write(&op->op_rw_sem);
- OBD_FREE(op->op_array, op->op_size * sizeof(op->op_array[0]));
- op->op_array = NULL;
- op->op_count = 0;
- op->op_size = 0;
+ OBD_FREE(op->op_array, op->op_size);
+ op->op_array = NULL;
+ op->op_count = 0;
+ op->op_size = 0;
up_write(&op->op_rw_sem);
- RETURN(0);
+ RETURN(0);
}
/* search ost in lov array */
- obd_getref(obd);
+ lov_tgts_getref(obd);
for (lov_idx = 0; lov_idx < lov->desc.ld_tgt_count; lov_idx++) {
if (!lov->lov_tgts[lov_idx])
continue;
EXIT;
out:
- obd_putref(obd);
- lov_pool_putref(pool);
- return rc;
+ lov_tgts_putref(obd);
+ lov_pool_putref(pool);
+
+ return rc;
}
int lov_pool_remove(struct obd_device *obd, char *poolname, char *ostname)
obd_str2uuid(&ost_uuid, ostname);
- obd_getref(obd);
+ lov_tgts_getref(obd);
/* search ost in lov array, to get index */
for (lov_idx = 0; lov_idx < lov->desc.ld_tgt_count; lov_idx++) {
if (!lov->lov_tgts[lov_idx])
EXIT;
out:
- obd_putref(obd);
- lov_pool_putref(pool);
- return rc;
+ lov_tgts_putref(obd);
+ lov_pool_putref(pool);
+
+ return rc;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff