* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*/
/*
#include "lov_internal.h"
-
/* Keep a refcount of lov->tgt usage to prevent racing with addition/deletion.
Any function that expects lov_tgts to remain stationary must take a ref. */
-void lov_getref(struct obd_device *obd)
+static void lov_getref(struct obd_device *obd)
{
struct lov_obd *lov = &obd->u.lov;
/* nobody gets through here until lov_putref is done */
- mutex_down(&lov->lov_lock);
- atomic_inc(&lov->lov_refcount);
- mutex_up(&lov->lov_lock);
+ cfs_mutex_down(&lov->lov_lock);
+ cfs_atomic_inc(&lov->lov_refcount);
+ cfs_mutex_up(&lov->lov_lock);
return;
}
-static void __lov_del_obd(struct obd_device *obd, __u32 index);
+static void __lov_del_obd(struct obd_device *obd, struct lov_tgt_desc *tgt);
-void lov_putref(struct obd_device *obd)
+static void lov_putref(struct obd_device *obd)
{
struct lov_obd *lov = &obd->u.lov;
- mutex_down(&lov->lov_lock);
+
+ cfs_mutex_down(&lov->lov_lock);
/* ok to dec to 0 more than once -- ltd_exp's will be null */
- if (atomic_dec_and_test(&lov->lov_refcount) && lov->lov_death_row) {
+ if (cfs_atomic_dec_and_test(&lov->lov_refcount) && lov->lov_death_row) {
+ CFS_LIST_HEAD(kill);
int i;
+ struct lov_tgt_desc *tgt, *n;
CDEBUG(D_CONFIG, "destroying %d lov targets\n",
lov->lov_death_row);
for (i = 0; i < lov->desc.ld_tgt_count; i++) {
- if (!lov->lov_tgts[i] || !lov->lov_tgts[i]->ltd_reap)
+ tgt = lov->lov_tgts[i];
+
+ if (!tgt || !tgt->ltd_reap)
continue;
- /* Disconnect and delete from list */
- __lov_del_obd(obd, i);
+ cfs_list_add(&tgt->ltd_kill, &kill);
+ /* XXX - right now there is a dependency on ld_tgt_count
+ * being the maximum tgt index for computing the
+ * mds_max_easize. So we can't shrink it. */
+ lov_ost_pool_remove(&lov->lov_packed, i);
+ lov->lov_tgts[i] = NULL;
lov->lov_death_row--;
}
+ cfs_mutex_up(&lov->lov_lock);
+
+ cfs_list_for_each_entry_safe(tgt, n, &kill, ltd_kill) {
+ cfs_list_del(&tgt->ltd_kill);
+ /* Disconnect */
+ __lov_del_obd(obd, tgt);
+ }
+ } else {
+ cfs_mutex_up(&lov->lov_lock);
}
- mutex_up(&lov->lov_lock);
}
static int lov_set_osc_active(struct obd_device *obd, struct obd_uuid *uuid,
struct obd_connect_data *data)
{
struct lov_obd *lov = &obd->u.lov;
- struct obd_uuid tgt_uuid;
+ struct obd_uuid *tgt_uuid;
struct obd_device *tgt_obd;
- struct obd_uuid lov_osc_uuid = { "LOV_OSC_UUID" };
- struct lustre_handle conn = {0, };
+ static struct obd_uuid lov_osc_uuid = { "LOV_OSC_UUID" };
struct obd_import *imp;
-
#ifdef __KERNEL__
cfs_proc_dir_entry_t *lov_proc_dir;
#endif
if (!lov->lov_tgts[index])
RETURN(-EINVAL);
- tgt_uuid = lov->lov_tgts[index]->ltd_uuid;
-
- tgt_obd = class_find_client_obd(&tgt_uuid, LUSTRE_OSC_NAME,
- &obd->obd_uuid);
+ tgt_uuid = &lov->lov_tgts[index]->ltd_uuid;
+ tgt_obd = lov->lov_tgts[index]->ltd_obd;
- if (!tgt_obd) {
- CERROR("Target %s not attached\n", obd_uuid2str(&tgt_uuid));
- RETURN(-EINVAL);
- }
if (!tgt_obd->obd_set_up) {
- CERROR("Target %s not set up\n", obd_uuid2str(&tgt_uuid));
+ CERROR("Target %s not set up\n", obd_uuid2str(tgt_uuid));
RETURN(-EINVAL);
}
ptlrpc_activate_import(imp);
}
+ rc = obd_register_observer(tgt_obd, obd);
+ if (rc) {
+ CERROR("Target %s register_observer error %d\n",
+ obd_uuid2str(tgt_uuid), rc);
+ RETURN(rc);
+ }
+
+
if (imp->imp_invalid) {
CERROR("not connecting OSC %s; administratively "
- "disabled\n", obd_uuid2str(&tgt_uuid));
- rc = obd_register_observer(tgt_obd, obd);
- if (rc) {
- CERROR("Target %s register_observer error %d; "
- "will not be able to reactivate\n",
- obd_uuid2str(&tgt_uuid), rc);
- }
+ "disabled\n", obd_uuid2str(tgt_uuid));
RETURN(0);
}
- rc = obd_connect(NULL, &conn, tgt_obd, &lov_osc_uuid, data, NULL);
- if (rc) {
+ rc = obd_connect(NULL, &lov->lov_tgts[index]->ltd_exp, tgt_obd,
+ &lov_osc_uuid, data, NULL);
+ if (rc || !lov->lov_tgts[index]->ltd_exp) {
CERROR("Target %s connect error %d\n",
- obd_uuid2str(&tgt_uuid), rc);
- RETURN(rc);
- }
- lov->lov_tgts[index]->ltd_exp = class_conn2export(&conn);
- if (!lov->lov_tgts[index]->ltd_exp) {
- CERROR("Target %s: null export!\n", obd_uuid2str(&tgt_uuid));
+ obd_uuid2str(tgt_uuid), rc);
RETURN(-ENODEV);
}
- rc = obd_register_observer(tgt_obd, obd);
- if (rc) {
- CERROR("Target %s register_observer error %d\n",
- obd_uuid2str(&tgt_uuid), rc);
- obd_disconnect(lov->lov_tgts[index]->ltd_exp);
- lov->lov_tgts[index]->ltd_exp = NULL;
- RETURN(rc);
- }
-
lov->lov_tgts[index]->ltd_reap = 0;
- if (activate) {
- lov->lov_tgts[index]->ltd_active = 1;
- lov->desc.ld_active_tgt_count++;
- lov->lov_tgts[index]->ltd_exp->exp_obd->obd_inactive = 0;
- }
+
CDEBUG(D_CONFIG, "Connected tgt idx %d %s (%s) %sactive\n", index,
- obd_uuid2str(&tgt_uuid), tgt_obd->obd_name, activate ? "":"in");
+ obd_uuid2str(tgt_uuid), tgt_obd->obd_name, activate ? "":"in");
#ifdef __KERNEL__
lov_proc_dir = lprocfs_srch(obd->obd_proc_entry, "target_obds");
if (lov_proc_dir) {
- struct obd_device *osc_obd = class_conn2obd(&conn);
+ struct obd_device *osc_obd = lov->lov_tgts[index]->ltd_exp->exp_obd;
cfs_proc_dir_entry_t *osc_symlink;
- char name[MAX_STRING_SIZE];
LASSERT(osc_obd != NULL);
LASSERT(osc_obd->obd_magic == OBD_DEVICE_MAGIC);
LASSERT(osc_obd->obd_type->typ_name != NULL);
- snprintf(name, MAX_STRING_SIZE, "../../../%s/%s",
- osc_obd->obd_type->typ_name,
- osc_obd->obd_name);
- osc_symlink = lprocfs_add_symlink(osc_obd->obd_name, lov_proc_dir,
- name);
+
+ osc_symlink = lprocfs_add_symlink(osc_obd->obd_name,
+ lov_proc_dir,
+ "../../../%s/%s",
+ osc_obd->obd_type->typ_name,
+ osc_obd->obd_name);
if (osc_symlink == NULL) {
CERROR("could not register LOV target "
- "/proc/fs/lustre/%s/%s/target_obds/%s.",
- obd->obd_type->typ_name, obd->obd_name,
- osc_obd->obd_name);
+ "/proc/fs/lustre/%s/%s/target_obds/%s.",
+ obd->obd_type->typ_name, obd->obd_name,
+ osc_obd->obd_name);
lprocfs_remove(&lov_proc_dir);
}
}
}
static int lov_connect(const struct lu_env *env,
- struct lustre_handle *conn, struct obd_device *obd,
+ struct obd_export **exp, struct obd_device *obd,
struct obd_uuid *cluuid, struct obd_connect_data *data,
void *localdata)
{
struct lov_obd *lov = &obd->u.lov;
struct lov_tgt_desc *tgt;
+ struct lustre_handle conn;
int i, rc;
ENTRY;
CDEBUG(D_CONFIG, "connect #%d\n", lov->lov_connects);
- rc = class_connect(conn, obd, cluuid);
+ rc = class_connect(&conn, obd, cluuid);
if (rc)
RETURN(rc);
+ *exp = class_conn2export(&conn);
+
/* Why should there ever be more than 1 connect? */
lov->lov_connects++;
LASSERT(lov->lov_connects == 1);
if (data)
lov->lov_ocd = *data;
- lov_getref(obd);
+ obd_getref(obd);
for (i = 0; i < lov->desc.ld_tgt_count; i++) {
tgt = lov->lov_tgts[i];
if (!tgt || obd_uuid_empty(&tgt->ltd_uuid))
continue;
rc = lov_notify(obd, lov->lov_tgts[i]->ltd_exp->exp_obd,
- OBD_NOTIFY_ACTIVE, (void *)&i);
+ OBD_NOTIFY_CONNECT, (void *)&i);
if (rc) {
CERROR("%s error sending notify %d\n",
obd->obd_name, rc);
}
}
- lov_putref(obd);
+ obd_putref(obd);
RETURN(0);
}
-static int lov_disconnect_obd(struct obd_device *obd, __u32 index)
+static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
{
cfs_proc_dir_entry_t *lov_proc_dir;
struct lov_obd *lov = &obd->u.lov;
struct obd_device *osc_obd;
int rc;
-
ENTRY;
- if (lov->lov_tgts[index] == NULL)
- RETURN(-EINVAL);
-
- osc_obd = class_exp2obd(lov->lov_tgts[index]->ltd_exp);
+ osc_obd = class_exp2obd(tgt->ltd_exp);
CDEBUG(D_CONFIG, "%s: disconnecting target %s\n",
obd->obd_name, osc_obd->obd_name);
- if (lov->lov_tgts[index]->ltd_active) {
- lov->lov_tgts[index]->ltd_active = 0;
+ if (tgt->ltd_active) {
+ tgt->ltd_active = 0;
lov->desc.ld_active_tgt_count--;
- lov->lov_tgts[index]->ltd_exp->exp_obd->obd_inactive = 1;
+ tgt->ltd_exp->exp_obd->obd_inactive = 1;
}
lov_proc_dir = lprocfs_srch(obd->obd_proc_entry, "target_obds");
obd_register_observer(osc_obd, NULL);
- rc = obd_disconnect(lov->lov_tgts[index]->ltd_exp);
+ rc = obd_disconnect(tgt->ltd_exp);
if (rc) {
CERROR("Target %s disconnect error %d\n",
- lov_uuid2str(lov, index), rc);
+ tgt->ltd_uuid.uuid, rc);
rc = 0;
}
- qos_del_tgt(obd, index);
+ qos_del_tgt(obd, tgt);
- lov->lov_tgts[index]->ltd_exp = NULL;
+ tgt->ltd_exp = NULL;
RETURN(0);
}
/* Let's hold another reference so lov_del_obd doesn't spin through
putref every time */
- lov_getref(obd);
+ obd_getref(obd);
for (i = 0; i < lov->desc.ld_tgt_count; i++) {
if (lov->lov_tgts[i] && lov->lov_tgts[i]->ltd_exp) {
lov_del_target(obd, i, 0, lov->lov_tgts[i]->ltd_gen);
}
}
- lov_putref(obd);
+ obd_putref(obd);
out:
rc = class_disconnect(exp); /* bz 9811 */
CDEBUG(D_INFO, "Searching in lov %p for uuid %s (activate=%d)\n",
lov, uuid->uuid, activate);
- lov_getref(obd);
+ obd_getref(obd);
for (index = 0; index < lov->desc.ld_tgt_count; index++) {
tgt = lov->lov_tgts[index];
if (!tgt || !tgt->ltd_exp)
lov->lov_tgts[index]->ltd_qos.ltq_penalty = 0;
out:
- lov_putref(obd);
+ obd_putref(obd);
RETURN(index);
}
{
int rc = 0;
ENTRY;
-
+
if (ev == OBD_NOTIFY_ACTIVE || ev == OBD_NOTIFY_INACTIVE) {
struct obd_uuid *uuid;
/* NULL watched means all osc's in the lov (only for syncs) */
/* sync event should be send lov idx as data */
struct lov_obd *lov = &obd->u.lov;
- struct obd_device *tgt_obd;
- int i;
- lov_getref(obd);
+ int i, is_sync;
+
+ data = &i;
+ is_sync = (ev == OBD_NOTIFY_SYNC) ||
+ (ev == OBD_NOTIFY_SYNC_NONBLOCK);
+
+ obd_getref(obd);
for (i = 0; i < lov->desc.ld_tgt_count; i++) {
if (!lov->lov_tgts[i])
continue;
- if ((ev == OBD_NOTIFY_SYNC) ||
- (ev == OBD_NOTIFY_SYNC_NONBLOCK))
- data = &i;
-
- tgt_obd = class_exp2obd(lov->lov_tgts[i]->ltd_exp);
+ /* don't send sync event if target not
+ * connected/activated */
+ if (is_sync && !lov->lov_tgts[i]->ltd_active)
+ continue;
- rc = obd_notify_observer(obd, tgt_obd, ev, data);
+ rc = obd_notify_observer(obd, lov->lov_tgts[i]->ltd_obd,
+ ev, data);
if (rc) {
CERROR("%s: notify %s of %s failed %d\n",
obd->obd_name,
obd->obd_observer->obd_name,
- tgt_obd->obd_name, rc);
- break;
+ lov->lov_tgts[i]->ltd_obd->obd_name,
+ rc);
}
}
- lov_putref(obd);
+ obd_putref(obd);
}
RETURN(rc);
}
-int lov_add_target(struct obd_device *obd, struct obd_uuid *uuidp,
- __u32 index, int gen, int active)
+static int lov_add_target(struct obd_device *obd, struct obd_uuid *uuidp,
+ __u32 index, int gen, int active)
{
struct lov_obd *lov = &obd->u.lov;
struct lov_tgt_desc *tgt;
+ struct obd_device *tgt_obd;
int rc;
ENTRY;
RETURN(-EINVAL);
}
- mutex_down(&lov->lov_lock);
+ tgt_obd = class_find_client_obd(uuidp, LUSTRE_OSC_NAME,
+ &obd->obd_uuid);
+ if (tgt_obd == NULL)
+ RETURN(-EINVAL);
+
+ cfs_mutex_down(&lov->lov_lock);
if ((index < lov->lov_tgt_size) && (lov->lov_tgts[index] != NULL)) {
tgt = lov->lov_tgts[index];
CERROR("UUID %s already assigned at LOV target index %d\n",
obd_uuid2str(&tgt->ltd_uuid), index);
- mutex_up(&lov->lov_lock);
+ cfs_mutex_up(&lov->lov_lock);
RETURN(-EEXIST);
}
newsize = newsize << 1;
OBD_ALLOC(newtgts, sizeof(*newtgts) * newsize);
if (newtgts == NULL) {
- mutex_up(&lov->lov_lock);
+ cfs_mutex_up(&lov->lov_lock);
RETURN(-ENOMEM);
}
OBD_ALLOC_PTR(tgt);
if (!tgt) {
- mutex_up(&lov->lov_lock);
+ cfs_mutex_up(&lov->lov_lock);
RETURN(-ENOMEM);
}
- memset(tgt, 0, sizeof(*tgt));
+ rc = lov_ost_pool_add(&lov->lov_packed, index, lov->lov_tgt_size);
+ if (rc) {
+ cfs_mutex_up(&lov->lov_lock);
+ OBD_FREE_PTR(tgt);
+ RETURN(rc);
+ }
+
tgt->ltd_uuid = *uuidp;
+ tgt->ltd_obd = tgt_obd;
/* XXX - add a sanity check on the generation number. */
tgt->ltd_gen = gen;
tgt->ltd_index = index;
if (index >= lov->desc.ld_tgt_count)
lov->desc.ld_tgt_count = index + 1;
- rc = lov_ost_pool_add(&lov->lov_packed, index, lov->lov_tgt_size);
- if (rc)
- RETURN(rc);
-
- mutex_up(&lov->lov_lock);
+ cfs_mutex_up(&lov->lov_lock);
CDEBUG(D_CONFIG, "idx=%d ltd_gen=%d ld_tgt_count=%d\n",
index, tgt->ltd_gen, lov->desc.ld_tgt_count);
+ rc = obd_notify(obd, tgt_obd, OBD_NOTIFY_CREATE, &index);
+
if (lov->lov_connects == 0) {
/* lov_connect hasn't been called yet. We'll do the
lov_connect_obd on this target when that fn first runs,
RETURN(0);
}
- lov_getref(obd);
+ obd_getref(obd);
rc = lov_connect_obd(obd, index, active, &lov->lov_ocd);
if (rc)
GOTO(out, rc = 0);
rc = lov_notify(obd, tgt->ltd_exp->exp_obd,
- active ? OBD_NOTIFY_ACTIVE : OBD_NOTIFY_INACTIVE,
+ active ? OBD_NOTIFY_CONNECT : OBD_NOTIFY_INACTIVE,
(void *)&index);
out:
obd_uuid2str(&tgt->ltd_uuid));
lov_del_target(obd, index, 0, 0);
}
- lov_putref(obd);
+ obd_putref(obd);
RETURN(rc);
}
RETURN(-EINVAL);
}
- lov_getref(obd);
+ obd_getref(obd);
if (!lov->lov_tgts[index]) {
CERROR("LOV target at index %d is not setup.\n", index);
lov->lov_tgts[index]->ltd_reap = 1;
lov->lov_death_row++;
- /* we really delete it from lov_putref */
+ /* we really delete it from obd_putref */
out:
- lov_putref(obd);
+ obd_putref(obd);
RETURN(rc);
}
-/* We are holding lov_lock */
-static void __lov_del_obd(struct obd_device *obd, __u32 index)
+static void __lov_del_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
{
- struct lov_obd *lov = &obd->u.lov;
struct obd_device *osc_obd;
- struct lov_tgt_desc *tgt = lov->lov_tgts[index];
LASSERT(tgt);
LASSERT(tgt->ltd_reap);
osc_obd = class_exp2obd(tgt->ltd_exp);
CDEBUG(D_CONFIG, "Removing tgt %s : %s\n",
- lov_uuid2str(lov, index),
+ tgt->ltd_uuid.uuid,
osc_obd ? osc_obd->obd_name : "<no obd>");
if (tgt->ltd_exp)
- lov_disconnect_obd(obd, index);
+ lov_disconnect_obd(obd, tgt);
- /* XXX - right now there is a dependency on ld_tgt_count being the
- * maximum tgt index for computing the mds_max_easize. So we can't
- * shrink it. */
-
- lov_ost_pool_remove(&lov->lov_packed, index);
- lov->lov_tgts[index] = NULL;
OBD_FREE_PTR(tgt);
/* Manual cleanup - no cleanup logs to clean up the osc's. We must
struct lprocfs_static_vars lvars = { 0 };
struct lov_desc *desc;
struct lov_obd *lov = &obd->u.lov;
- int count;
int rc;
ENTRY;
lov_fix_desc(desc);
- /* Because of 64-bit divide/mod operations only work with a 32-bit
- * divisor in a 32-bit kernel, we cannot support a stripe width
- * of 4GB or larger on 32-bit CPUs. */
- count = desc->ld_default_stripe_count;
- if ((count > 0 ? count : desc->ld_tgt_count) *
- desc->ld_default_stripe_size > 0xffffffff) {
- CERROR("LOV: stripe width "LPU64"x%u > 4294967295 bytes\n",
- desc->ld_default_stripe_size, count);
- RETURN(-EINVAL);
- }
-
desc->ld_active_tgt_count = 0;
lov->desc = *desc;
lov->lov_tgt_size = 0;
- sema_init(&lov->lov_lock, 1);
- atomic_set(&lov->lov_refcount, 0);
+ cfs_sema_init(&lov->lov_lock, 1);
+ cfs_atomic_set(&lov->lov_refcount, 0);
CFS_INIT_LIST_HEAD(&lov->lov_qos.lq_oss_list);
- init_rwsem(&lov->lov_qos.lq_rw_sem);
+ cfs_init_rwsem(&lov->lov_qos.lq_rw_sem);
lov->lov_sp_me = LUSTRE_SP_CLI;
lov->lov_qos.lq_dirty = 1;
lov->lov_qos.lq_rr.lqr_dirty = 1;
lov->lov_qos.lq_reset = 1;
/* Default priority is toward free space balance */
lov->lov_qos.lq_prio_free = 232;
-
- lov->lov_pools_hash_body = lustre_hash_init("POOLS", 7, 7,
- &pool_hash_operations, 0);
+ /* Default threshold for rr (roughly 17%) */
+ lov->lov_qos.lq_threshold_rr = 43;
+ /* Init statfs fields */
+ OBD_ALLOC_PTR(lov->lov_qos.lq_statfs_data);
+ if (NULL == lov->lov_qos.lq_statfs_data)
+ RETURN(-ENOMEM);
+ cfs_waitq_init(&lov->lov_qos.lq_statfs_waitq);
+
+ lov->lov_pools_hash_body = cfs_hash_create("POOLS", HASH_POOLS_CUR_BITS,
+ HASH_POOLS_MAX_BITS,
+ HASH_POOLS_BKT_BITS, 0,
+ CFS_HASH_MIN_THETA,
+ CFS_HASH_MAX_THETA,
+ &pool_hash_operations,
+ CFS_HASH_DEFAULT);
CFS_INIT_LIST_HEAD(&lov->lov_pool_list);
lov->lov_pool_count = 0;
rc = lov_ost_pool_init(&lov->lov_packed, 0);
if (rc)
- RETURN(rc);
+ GOTO(out_free_statfs, rc);
rc = lov_ost_pool_init(&lov->lov_qos.lq_rr.lqr_pool, 0);
- if (rc) {
- lov_ost_pool_free(&lov->lov_packed);
- RETURN(rc);
- }
+ if (rc)
+ GOTO(out_free_lov_packed, rc);
lprocfs_lov_init_vars(&lvars);
lprocfs_obd_setup(obd, lvars.obd_vars);
NULL, NULL);
RETURN(0);
+
+out_free_lov_packed:
+ lov_ost_pool_free(&lov->lov_packed);
+out_free_statfs:
+ OBD_FREE_PTR(lov->lov_qos.lq_statfs_data);
+ return rc;
}
static int lov_precleanup(struct obd_device *obd, enum obd_cleanup_stage stage)
{
int rc = 0;
+ struct lov_obd *lov = &obd->u.lov;
+
ENTRY;
switch (stage) {
case OBD_CLEANUP_EARLY: {
- struct lov_obd *lov = &obd->u.lov;
int i;
for (i = 0; i < lov->desc.ld_tgt_count; i++) {
if (!lov->lov_tgts[i] || !lov->lov_tgts[i]->ltd_active)
static int lov_cleanup(struct obd_device *obd)
{
struct lov_obd *lov = &obd->u.lov;
- struct list_head *pos, *tmp;
+ cfs_list_t *pos, *tmp;
struct pool_desc *pool;
- lprocfs_obd_cleanup(obd);
-
- list_for_each_safe(pos, tmp, &lov->lov_pool_list) {
- pool = list_entry(pos, struct pool_desc, pool_list);
- list_del(&pool->pool_list);
- lov_ost_pool_free(&(pool->pool_rr.lqr_pool));
- lov_ost_pool_free(&(pool->pool_obds));
- OBD_FREE_PTR(pool);
+ cfs_list_for_each_safe(pos, tmp, &lov->lov_pool_list) {
+ pool = cfs_list_entry(pos, struct pool_desc, pool_list);
+ /* free pool structs */
+ CDEBUG(D_INFO, "delete pool %p\n", pool);
+ lov_pool_del(obd, pool->pool_name);
}
+ cfs_hash_putref(lov->lov_pools_hash_body);
lov_ost_pool_free(&(lov->lov_qos.lq_rr.lqr_pool));
lov_ost_pool_free(&lov->lov_packed);
- lustre_hash_exit(lov->lov_pools_hash_body);
if (lov->lov_tgts) {
int i;
+ obd_getref(obd);
for (i = 0; i < lov->desc.ld_tgt_count; i++) {
if (!lov->lov_tgts[i])
continue;
/* Inactive targets may never have connected */
if (lov->lov_tgts[i]->ltd_active ||
- atomic_read(&lov->lov_refcount))
+ cfs_atomic_read(&lov->lov_refcount))
/* We should never get here - these
should have been removed in the
disconnect. */
CERROR("lov tgt %d not cleaned!"
" deathrow=%d, lovrc=%d\n",
i, lov->lov_death_row,
- atomic_read(&lov->lov_refcount));
+ cfs_atomic_read(&lov->lov_refcount));
lov_del_target(obd, i, 0, 0);
}
+ obd_putref(obd);
OBD_FREE(lov->lov_tgts, sizeof(*lov->lov_tgts) *
lov->lov_tgt_size);
lov->lov_tgt_size = 0;
}
+ /* clear pools parent proc entry only after all pools is killed */
+ lprocfs_obd_cleanup(obd);
+
+ OBD_FREE_PTR(lov->lov_qos.lq_statfs_data);
RETURN(0);
}
rc = class_process_proc_param(PARAM_LOV, lvars.obd_vars,
lcfg, obd);
- if (rc > 0)
- rc = 0;
+ if (rc > 0)
+ rc = 0;
GOTO(out, rc);
}
case LCFG_POOL_NEW:
}
#ifndef log2
-#define log2(n) ffz(~(n))
+#define log2(n) cfs_ffz(~(n))
#endif
static int lov_clear_orphans(struct obd_export *export, struct obdo *src_oa,
ost_uuid->uuid);
}
- lov_getref(export->exp_obd);
+ obd_getref(export->exp_obd);
for (i = 0; i < lov->desc.ld_tgt_count; i++) {
struct lov_stripe_md obj_md;
struct lov_stripe_md *obj_mdp = &obj_md;
if (ost_uuid)
break;
}
- lov_putref(export->exp_obd);
+ obd_putref(export->exp_obd);
OBDO_FREE(tmp_oa);
RETURN(rc);
struct obd_info oinfo;
struct lov_request_set *set = NULL;
struct lov_request *req;
- struct obd_statfs osfs;
- __u64 maxage;
+ struct l_wait_info lwi = { 0 };
int rc = 0;
ENTRY;
if (!lov->desc.ld_active_tgt_count)
RETURN(-EIO);
- lov_getref(exp->exp_obd);
+ obd_getref(exp->exp_obd);
/* Recreate a specific object id at the given OST index */
if ((src_oa->o_valid & OBD_MD_FLFLAGS) &&
(src_oa->o_flags & OBD_FL_RECREATE_OBJS)) {
GOTO(out, rc);
}
- maxage = cfs_time_shift_64(-lov->desc.ld_qos_maxage);
- obd_statfs_rqset(exp->exp_obd, &osfs, maxage, OBD_STATFS_NODELAY);
+ /* issue statfs rpcs if the osfs data is older than qos_maxage - 1s,
+ * later in alloc_qos(), we will wait for those rpcs to complete if
+ * the osfs age is older than 2 * qos_maxage */
+ qos_statfs_update(exp->exp_obd,
+ cfs_time_shift_64(-lov->desc.ld_qos_maxage +
+ OBD_STATFS_CACHE_SECONDS),
+ 0);
rc = lov_prep_create_set(exp, &oinfo, ea, src_oa, oti, &set);
if (rc)
GOTO(out, rc);
- list_for_each_entry(req, &set->set_list, rq_link) {
+ cfs_list_for_each_entry(req, &set->set_list, rq_link) {
/* XXX: LOV STACKING: use real "obj_mdp" sub-data */
- rc = obd_create(lov->lov_tgts[req->rq_idx]->ltd_exp,
- req->rq_oi.oi_oa, &req->rq_oi.oi_md, oti);
- lov_update_create_set(set, req, rc);
+ rc = obd_create_async(lov->lov_tgts[req->rq_idx]->ltd_exp,
+ &req->rq_oi, &req->rq_oi.oi_md, oti);
}
+
+ /* osc_create have timeout equ obd_timeout/2 so waiting don't be
+ * longer then this */
+ l_wait_event(set->set_waitq, lov_finished_set(set), &lwi);
+
+ /* we not have ptlrpc set for assign set->interpret and should
+ * be call interpret function himself. calling from cb_create_update
+ * not permited because lov_fini_create_set can sleep for long time,
+ * but we must avoid sleeping in ptlrpcd interpret function. */
rc = lov_fini_create_set(set, ea);
out:
- lov_putref(exp->exp_obd);
+ obd_putref(exp->exp_obd);
RETURN(rc);
}
do { \
LASSERT((lsmp) != NULL); \
LASSERTF(((lsmp)->lsm_magic == LOV_MAGIC_V1 || \
- (lsmp)->lsm_magic == LOV_MAGIC_V3 || \
- (lsmp)->lsm_magic == LOV_MAGIC_JOIN), "%p->lsm_magic=%x\n", \
- (lsmp), (lsmp)->lsm_magic); \
+ (lsmp)->lsm_magic == LOV_MAGIC_V3), \
+ "%p->lsm_magic=%x\n", (lsmp), (lsmp)->lsm_magic); \
} while (0)
static int lov_destroy(struct obd_export *exp, struct obdo *oa,
struct lov_request_set *set;
struct obd_info oinfo;
struct lov_request *req;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_obd *lov;
int rc = 0, err = 0;
ENTRY;
}
lov = &exp->exp_obd->u.lov;
- lov_getref(exp->exp_obd);
+ obd_getref(exp->exp_obd);
rc = lov_prep_destroy_set(exp, &oinfo, oa, lsm, oti, &set);
if (rc)
GOTO(out, rc);
- list_for_each (pos, &set->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &set->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
if (oa->o_valid & OBD_MD_FLCOOKIE)
oti->oti_logcookies = set->set_cookies + req->rq_stripe;
}
err = lov_fini_destroy_set(set);
out:
- lov_putref(exp->exp_obd);
+ obd_putref(exp->exp_obd);
RETURN(rc ? rc : err);
}
{
struct lov_request_set *set;
struct lov_request *req;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_obd *lov;
int err = 0, rc = 0;
ENTRY;
if (rc)
RETURN(rc);
- list_for_each (pos, &set->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &set->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
CDEBUG(D_INFO, "objid "LPX64"[%d] has subobj "LPX64" at idx "
"%u\n", oinfo->oi_oa->o_id, req->rq_stripe,
{
struct lov_request_set *lovset;
struct lov_obd *lov;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_request *req;
int rc = 0, err;
ENTRY;
oinfo->oi_md->lsm_object_id, oinfo->oi_md->lsm_stripe_count,
oinfo->oi_md->lsm_stripe_size);
- list_for_each (pos, &lovset->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &lovset->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
CDEBUG(D_INFO, "objid "LPX64"[%d] has subobj "LPX64" at idx "
"%u\n", oinfo->oi_oa->o_id, req->rq_stripe,
}
}
- if (!list_empty(&rqset->set_requests)) {
+ if (!cfs_list_empty(&rqset->set_requests)) {
LASSERT(rc == 0);
LASSERT (rqset->set_interpret == NULL);
rqset->set_interpret = lov_getattr_interpret;
{
struct lov_request_set *set;
struct lov_obd *lov;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_request *req;
int err = 0, rc = 0;
ENTRY;
if (rc)
RETURN(rc);
- list_for_each (pos, &set->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &set->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
rc = obd_setattr(lov->lov_tgts[req->rq_idx]->ltd_exp,
&req->rq_oi, NULL);
{
struct lov_request_set *set;
struct lov_request *req;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_obd *lov;
int rc = 0;
ENTRY;
oinfo->oi_md->lsm_object_id, oinfo->oi_md->lsm_stripe_count,
oinfo->oi_md->lsm_stripe_size);
- list_for_each (pos, &set->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &set->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
if (oinfo->oi_oa->o_valid & OBD_MD_FLCOOKIE)
oti->oti_logcookies = set->set_cookies + req->rq_stripe;
}
/* If we are not waiting for responses on async requests, return. */
- if (rc || !rqset || list_empty(&rqset->set_requests)) {
+ if (rc || !rqset || cfs_list_empty(&rqset->set_requests)) {
int err;
if (rc)
set->set_completes = 0;
{
struct lov_request_set *set;
struct lov_obd *lov;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_request *req;
int rc = 0;
ENTRY;
if (rc)
RETURN(rc);
- list_for_each (pos, &set->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &set->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
rc = obd_punch(lov->lov_tgts[req->rq_idx]->ltd_exp,
&req->rq_oi, NULL, rqset);
}
}
- if (rc || list_empty(&rqset->set_requests)) {
+ if (rc || cfs_list_empty(&rqset->set_requests)) {
int err;
err = lov_fini_punch_set(set);
RETURN(rc ? rc : err);
struct lov_request_set *set;
struct obd_info oinfo;
struct lov_obd *lov;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_request *req;
int err = 0, rc = 0;
ENTRY;
if (rc)
RETURN(rc);
- list_for_each (pos, &set->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &set->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
rc = obd_sync(lov->lov_tgts[req->rq_idx]->ltd_exp,
req->rq_oi.oi_oa, NULL,
RETURN(rc);
}
+static int lov_sync_fs(struct obd_device *obd, struct obd_info *dummy,
+ int wait)
+{
+ struct lov_obd *lov;
+ struct obd_info oinfo = { { { 0 } } };
+ struct lov_request *req;
+ struct lov_request_set *set;
+ struct l_wait_info lwi = { 0 };
+ cfs_list_t *pos;
+ int rc = 0;
+ ENTRY;
+
+ lov = &obd->u.lov;
+ rc = lov_prep_sync_fs_set(obd, &oinfo, &set);
+ if (rc)
+ RETURN(rc);
+
+ cfs_list_for_each(pos, &set->set_list) {
+ struct obd_device *osc_obd;
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
+
+ osc_obd = class_exp2obd(lov->lov_tgts[req->rq_idx]->ltd_exp);
+ rc = obd_sync_fs(osc_obd, &req->rq_oi, wait);
+ if (rc)
+ break;
+ }
+ /* if wait then check if all sync_fs IO's are done */
+ if (wait)
+ l_wait_event(set->set_waitq, lov_finished_set(set), &lwi);
+
+ rc = lov_fini_sync_fs_set(set);
+ RETURN(rc);
+}
+
static int lov_brw_check(struct lov_obd *lov, struct obd_info *lov_oinfo,
obd_count oa_bufs, struct brw_page *pga)
{
{
struct lov_request_set *set;
struct lov_request *req;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_obd *lov = &exp->exp_obd->u.lov;
int err, rc = 0;
ENTRY;
if (rc)
RETURN(rc);
- list_for_each (pos, &set->set_list) {
+ cfs_list_for_each (pos, &set->set_list) {
struct obd_export *sub_exp;
struct brw_page *sub_pga;
- req = list_entry(pos, struct lov_request, rq_link);
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
sub_exp = lov->lov_tgts[req->rq_idx]->ltd_exp;
sub_pga = set->set_pga + req->rq_pgaidx;
ldlm_mode_t mode = einfo->ei_mode;
struct lov_request_set *set;
struct lov_request *req;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_obd *lov;
ldlm_error_t rc;
ENTRY;
if (rc)
RETURN(rc);
- list_for_each (pos, &set->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &set->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
rc = obd_enqueue(lov->lov_tgts[req->rq_idx]->ltd_exp,
&req->rq_oi, einfo, rqset);
GOTO(out, rc);
}
- if (rqset && !list_empty(&rqset->set_requests)) {
+ if (rqset && !cfs_list_empty(&rqset->set_requests)) {
LASSERT(rc == 0);
LASSERT(rqset->set_interpret == NULL);
rqset->set_interpret = lov_enqueue_interpret;
if (!exp || !exp->exp_obd)
RETURN(-ENODEV);
- LASSERT_MDS_GROUP(lsm->lsm_object_gr);
-
lov = &exp->exp_obd->u.lov;
for (i = 0; i < lsm->lsm_stripe_count; i++) {
struct lov_stripe_md submd;
continue;
}
+ LASSERT_SEQ_IS_MDT(loi->loi_seq);
submd.lsm_object_id = loi->loi_id;
- submd.lsm_object_gr = lsm->lsm_object_gr;
+ submd.lsm_object_seq = loi->loi_seq;
submd.lsm_stripe_count = 0;
rc = obd_change_cbdata(lov->lov_tgts[loi->loi_ost_idx]->ltd_exp,
&submd, it, data);
RETURN(rc);
}
+/* find any ldlm lock of the inode in lov
+ * return 0 not find
+ * 1 find one
+ * < 0 error */
+static int lov_find_cbdata(struct obd_export *exp,
+ struct lov_stripe_md *lsm, ldlm_iterator_t it,
+ void *data)
+{
+ struct lov_obd *lov;
+ int rc = 0, i;
+ ENTRY;
+
+ ASSERT_LSM_MAGIC(lsm);
+
+ if (!exp || !exp->exp_obd)
+ RETURN(-ENODEV);
+
+ lov = &exp->exp_obd->u.lov;
+ for (i = 0; i < lsm->lsm_stripe_count; i++) {
+ struct lov_stripe_md submd;
+ struct lov_oinfo *loi = lsm->lsm_oinfo[i];
+
+ if (!lov->lov_tgts[loi->loi_ost_idx]) {
+ CDEBUG(D_HA, "lov idx %d NULL \n", loi->loi_ost_idx);
+ continue;
+ }
+
+ LASSERT_SEQ_IS_MDT(loi->loi_seq);
+ submd.lsm_object_id = loi->loi_id;
+ submd.lsm_object_seq = loi->loi_seq;
+ submd.lsm_stripe_count = 0;
+ rc = obd_find_cbdata(lov->lov_tgts[loi->loi_ost_idx]->ltd_exp,
+ &submd, it, data);
+ if (rc != 0)
+ RETURN(rc);
+ }
+ RETURN(rc);
+}
+
static int lov_cancel(struct obd_export *exp, struct lov_stripe_md *lsm,
__u32 mode, struct lustre_handle *lockh)
{
struct lov_request_set *set;
struct obd_info oinfo;
struct lov_request *req;
- struct list_head *pos;
- struct lov_obd *lov = &exp->exp_obd->u.lov;
+ cfs_list_t *pos;
+ struct lov_obd *lov;
struct lustre_handle *lov_lockhp;
int err = 0, rc = 0;
ENTRY;
if (!exp || !exp->exp_obd)
RETURN(-ENODEV);
- LASSERT_MDS_GROUP(lsm->lsm_object_gr);
+ LASSERT_SEQ_IS_MDT(lsm->lsm_object_seq);
LASSERT(lockh);
lov = &exp->exp_obd->u.lov;
rc = lov_prep_cancel_set(exp, &oinfo, lsm, mode, lockh, &set);
if (rc)
RETURN(rc);
- list_for_each (pos, &set->set_list) {
- req = list_entry(pos, struct lov_request, rq_link);
+ cfs_list_for_each (pos, &set->set_list) {
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
lov_lockhp = set->set_lockh->llh_handles + req->rq_stripe;
rc = obd_cancel(lov->lov_tgts[req->rq_idx]->ltd_exp,
static int lov_cancel_unused(struct obd_export *exp,
struct lov_stripe_md *lsm,
- int flags, void *opaque)
+ ldlm_cancel_flags_t flags, void *opaque)
{
struct lov_obd *lov;
int rc = 0, i;
ASSERT_LSM_MAGIC(lsm);
- LASSERT_MDS_GROUP(lsm->lsm_object_gr);
+ LASSERT_SEQ_IS_MDT(lsm->lsm_object_seq);
for (i = 0; i < lsm->lsm_stripe_count; i++) {
struct lov_stripe_md submd;
struct lov_oinfo *loi = lsm->lsm_oinfo[i];
CDEBUG(D_HA, "lov idx %d inactive\n", loi->loi_ost_idx);
submd.lsm_object_id = loi->loi_id;
- submd.lsm_object_gr = lsm->lsm_object_gr;
+ submd.lsm_object_seq = loi->loi_seq;
submd.lsm_stripe_count = 0;
err = obd_cancel_unused(lov->lov_tgts[loi->loi_ost_idx]->ltd_exp,
&submd, flags, opaque);
RETURN(rc);
}
-static int lov_statfs_interpret(struct ptlrpc_request_set *rqset,
- void *data, int rc)
+int lov_statfs_interpret(struct ptlrpc_request_set *rqset, void *data, int rc)
{
struct lov_request_set *lovset = (struct lov_request_set *)data;
int err;
{
struct lov_request_set *set;
struct lov_request *req;
- struct list_head *pos;
+ cfs_list_t *pos;
struct lov_obd *lov;
int rc = 0;
ENTRY;
if (rc)
RETURN(rc);
- list_for_each (pos, &set->set_list) {
+ cfs_list_for_each (pos, &set->set_list) {
struct obd_device *osc_obd;
- req = list_entry(pos, struct lov_request, rq_link);
+ req = cfs_list_entry(pos, struct lov_request, rq_link);
osc_obd = class_exp2obd(lov->lov_tgts[req->rq_idx]->ltd_exp);
rc = obd_statfs_async(osc_obd, &req->rq_oi, max_age, rqset);
break;
}
- if (rc || list_empty(&rqset->set_requests)) {
+ if (rc || cfs_list_empty(&rqset->set_requests)) {
int err;
if (rc)
set->set_completes = 0;
__u32 index;
memcpy(&index, data->ioc_inlbuf2, sizeof(__u32));
- LASSERT(data->ioc_plen1 == sizeof(struct obd_statfs));
-
if ((index >= count))
RETURN(-ENODEV);
if (!osc_obd)
RETURN(-EINVAL);
+ /* copy UUID */
+ if (cfs_copy_to_user(data->ioc_pbuf2, obd2cli_tgt(osc_obd),
+ min((int) data->ioc_plen2,
+ (int) sizeof(struct obd_uuid))))
+ RETURN(-EFAULT);
+
/* got statfs data */
rc = obd_statfs(osc_obd, &stat_buf,
- cfs_time_current_64() - HZ, 0);
+ cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
+ 0);
if (rc)
RETURN(rc);
- if (copy_to_user(data->ioc_pbuf1, &stat_buf, data->ioc_plen1))
- RETURN(-EFAULT);
- /* copy UUID */
- if (copy_to_user(data->ioc_pbuf2, obd2cli_tgt(osc_obd),
- data->ioc_plen2))
+ if (cfs_copy_to_user(data->ioc_pbuf1, &stat_buf,
+ min((int) data->ioc_plen1,
+ (int) sizeof(stat_buf))))
RETURN(-EFAULT);
break;
}
*genp = lov->lov_tgts[i]->ltd_gen;
}
- if (copy_to_user((void *)uarg, buf, len))
+ if (cfs_copy_to_user((void *)uarg, buf, len))
rc = -EFAULT;
obd_ioctl_freedata(buf, len);
break;
}
case LL_IOC_LOV_SETSTRIPE:
- rc = lov_setstripe(exp, karg, uarg);
+ rc = lov_setstripe(exp, len, karg, uarg);
break;
case LL_IOC_LOV_GETSTRIPE:
rc = lov_getstripe(exp, karg, uarg);
fm_local->fm_flags = fiemap->fm_flags;
fm_key->oa.o_id = lsm->lsm_oinfo[cur_stripe]->loi_id;
+ fm_key->oa.o_seq = lsm->lsm_oinfo[cur_stripe]->loi_seq;
ost_index = lsm->lsm_oinfo[cur_stripe]->loi_ost_idx;
if (ost_index < 0 || ost_index >=lov->desc.ld_tgt_count)
GOTO(out, rc = -EINVAL);
/* If OST is inactive, return extent with UNKNOWN flag */
- if (lov && !lov->lov_tgts[ost_index]->ltd_active) {
+ if (!lov->lov_tgts[ost_index]->ltd_active) {
fm_local->fm_flags |= FIEMAP_EXTENT_LAST;
fm_local->fm_mapped_extents = 1;
if (!vallen || !val)
RETURN(-EFAULT);
- lov_getref(obddev);
+ obd_getref(obddev);
if (KEY_IS(KEY_LOCK_TO_STRIPE)) {
struct {
continue;
if (lov->lov_tgts[loi->loi_ost_idx]->ltd_exp ==
data->lock->l_conn_export &&
- osc_res_name_eq(loi->loi_id, loi->loi_gr, res_id)) {
+ osc_res_name_eq(loi->loi_id, loi->loi_seq, res_id)) {
*stripe = i;
GOTO(out, rc = 0);
}
} else if (KEY_IS(KEY_FIEMAP)) {
rc = lov_fiemap(lov, keylen, key, vallen, val, lsm);
GOTO(out, rc);
+ } else if (KEY_IS(KEY_CONNECT_FLAG)) {
+ struct lov_tgt_desc *tgt;
+ __u64 ost_idx = *((__u64*)val);
+
+ LASSERT(*vallen == sizeof(__u64));
+ LASSERT(ost_idx < lov->desc.ld_tgt_count);
+ tgt = lov->lov_tgts[ost_idx];
+
+ if (!tgt || !tgt->ltd_exp)
+ GOTO(out, rc = -ESRCH);
+
+ *((__u64*)val) = tgt->ltd_exp->exp_connect_flags;
+ GOTO(out, rc = 0);
}
rc = -EINVAL;
out:
- lov_putref(obddev);
+ obd_putref(obddev);
RETURN(rc);
}
struct lov_tgt_desc *tgt;
unsigned incr, check_uuid,
do_inactive, no_set;
- unsigned next_id = 0, mds_con = 0;
+ unsigned next_id = 0, mds_con = 0, capa = 0;
ENTRY;
incr = check_uuid = do_inactive = no_set = 0;
RETURN(-ENOMEM);
}
- lov_getref(obddev);
+ obd_getref(obddev);
count = lov->desc.ld_tgt_count;
if (KEY_IS(KEY_NEXT_ID)) {
next_id = 1;
} else if (KEY_IS(KEY_CHECKSUM)) {
do_inactive = 1;
- } else if (KEY_IS(KEY_UNLINKED)) {
- check_uuid = val ? 1 : 0;
} else if (KEY_IS(KEY_EVICT_BY_NID)) {
/* use defaults: do_inactive = incr = 0; */
} else if (KEY_IS(KEY_MDS_CONN)) {
mds_con = 1;
+ } else if (KEY_IS(KEY_CAPA_KEY)) {
+ capa = 1;
}
for (i = 0; i < count; i++, val = (char *)val + incr) {
err = obd_set_info_async(tgt->ltd_exp,
keylen, key, vallen,
((struct obd_id_info*)val)->data, set);
- } else {
+ } else if (capa) {
+ struct mds_capa_info *info = (struct mds_capa_info*)val;
+
+ LASSERT(vallen == sizeof(*info));
+
+ /* Only want a specific OSC */
+ if (info->uuid &&
+ !obd_uuid_equals(info->uuid, &tgt->ltd_uuid))
+ continue;
+
+ err = obd_set_info_async(tgt->ltd_exp, keylen, key,
+ sizeof(*info->capa),
+ info->capa, set);
+
+ } else {
/* Only want a specific OSC */
if (check_uuid &&
!obd_uuid_equals(val, &tgt->ltd_uuid))
rc = err;
}
- lov_putref(obddev);
+ obd_putref(obddev);
if (no_set) {
err = ptlrpc_set_wait(set);
if (!rc)
RETURN(rc);
}
-static int lov_checkmd(struct obd_export *exp, struct obd_export *md_exp,
- struct lov_stripe_md *lsm)
-{
- int rc;
- ENTRY;
-
- if (!lsm)
- RETURN(0);
- LASSERT(md_exp);
- LASSERT(lsm_op_find(lsm->lsm_magic) != NULL);
- rc = lsm_op_find(lsm->lsm_magic)->lsm_revalidate(lsm, md_exp->exp_obd);
-
- RETURN(rc);
-}
-
int lov_test_and_clear_async_rc(struct lov_stripe_md *lsm)
{
int i, rc = 0;
RETURN(0);
}
-
-#if 0
-struct lov_multi_wait {
- struct ldlm_lock *lock;
- wait_queue_t wait;
- int completed;
- int generation;
-};
-
-int lov_complete_many(struct obd_export *exp, struct lov_stripe_md *lsm,
- struct lustre_handle *lockh)
-{
- struct lov_lock_handles *lov_lockh = NULL;
- struct lustre_handle *lov_lockhp;
- struct lov_obd *lov;
- struct lov_oinfo *loi;
- struct lov_multi_wait *queues;
- int rc = 0, i;
- ENTRY;
-
- ASSERT_LSM_MAGIC(lsm);
-
- if (!exp || !exp->exp_obd)
- RETURN(-ENODEV);
-
- LASSERT(lockh != NULL);
- if (lsm->lsm_stripe_count > 1) {
- lov_lockh = lov_handle2llh(lockh);
- if (lov_lockh == NULL) {
- CERROR("LOV: invalid lov lock handle %p\n", lockh);
- RETURN(-EINVAL);
- }
-
- lov_lockhp = lov_lockh->llh_handles;
- } else {
- lov_lockhp = lockh;
- }
-
- OBD_ALLOC(queues, lsm->lsm_stripe_count * sizeof(*queues));
- if (queues == NULL)
- GOTO(out, rc = -ENOMEM);
-
- lov = &exp->exp_obd->u.lov;
- for (i = 0, loi = lsm->lsm_oinfo; i < lsm->lsm_stripe_count;
- i++, loi++, lov_lockhp++) {
- struct ldlm_lock *lock;
- struct obd_device *obd;
-
- lock = ldlm_handle2lock_long(lov_lockhp, 0);
- if (lock == NULL) {
- CDEBUG(D_HA, "lov idx %d subobj "LPX64" no lock?\n",
- loi->loi_ost_idx, loi->loi_id);
- queues[i].completed = 1;
- continue;
- }
-
- queues[i].lock = lock;
- init_waitqueue_entry(&(queues[i].wait), current);
- add_wait_queue(lock->l_waitq, &(queues[i].wait));
-
- obd = class_exp2obd(lock->l_conn_export);
- if (obd != NULL)
- imp = obd->u.cli.cl_import;
- if (imp != NULL) {
- spin_lock(&imp->imp_lock);
- queues[i].generation = imp->imp_generation;
- spin_unlock(&imp->imp_lock);
- }
- }
-
- lwi = LWI_TIMEOUT_INTR(obd_timeout * HZ, ldlm_expired_completion_wait,
- interrupted_completion_wait, &lwd);
- rc = l_wait_event_added(check_multi_complete(queues, lsm), &lwi);
-
- for (i = 0; i < lsm->lsm_stripe_count; i++)
- remove_wait_queue(lock->l_waitq, &(queues[i].wait));
-
- if (rc == -EINTR || rc == -ETIMEDOUT) {
-
-
- }
-
- out:
- if (lov_lockh != NULL)
- lov_llh_put(lov_lockh);
- RETURN(rc);
-}
-#endif
-
void lov_stripe_lock(struct lov_stripe_md *md)
{
LASSERT(md->lsm_lock_owner != cfs_curproc_pid());
- spin_lock(&md->lsm_lock);
+ cfs_spin_lock(&md->lsm_lock);
LASSERT(md->lsm_lock_owner == 0);
md->lsm_lock_owner = cfs_curproc_pid();
}
{
LASSERT(md->lsm_lock_owner == cfs_curproc_pid());
md->lsm_lock_owner = 0;
- spin_unlock(&md->lsm_lock);
+ cfs_spin_unlock(&md->lsm_lock);
}
EXPORT_SYMBOL(lov_stripe_unlock);
.o_statfs_async = lov_statfs_async,
.o_packmd = lov_packmd,
.o_unpackmd = lov_unpackmd,
- .o_checkmd = lov_checkmd,
.o_create = lov_create,
.o_destroy = lov_destroy,
.o_getattr = lov_getattr,
.o_sync = lov_sync,
.o_enqueue = lov_enqueue,
.o_change_cbdata = lov_change_cbdata,
+ .o_find_cbdata = lov_find_cbdata,
.o_cancel = lov_cancel,
.o_cancel_unused = lov_cancel_unused,
.o_iocontrol = lov_iocontrol,
.o_pool_rem = lov_pool_remove,
.o_pool_add = lov_pool_add,
.o_pool_del = lov_pool_del,
+ .o_getref = lov_getref,
+ .o_putref = lov_putref,
+ .o_sync_fs = lov_sync_fs,
};
static quota_interface_t *quota_interface;
lov_oinfo_slab = cfs_mem_cache_create("lov_oinfo",
sizeof(struct lov_oinfo),
- 0, SLAB_HWCACHE_ALIGN);
+ 0, CFS_SLAB_HWCACHE_ALIGN);
if (lov_oinfo_slab == NULL) {
lu_kmem_fini(lov_caches);
return -ENOMEM;
}
lprocfs_lov_init_vars(&lvars);
- request_module("lquota");
+ cfs_request_module("lquota");
quota_interface = PORTAL_SYMBOL_GET(lov_quota_interface);
init_obd_quota_ops(quota_interface, &lov_obd_ops);