#include "ofd_internal.h"
#include <obd_cksum.h>
-#include <lquota.h>
+#include <lustre_quota.h>
static int ofd_export_stats_init(struct ofd_device *ofd,
struct obd_export *exp, void *client_nid)
GOTO(clean, rc = -ENOMEM);
for (i = 0; i < BRW_LAST; i++)
- cfs_spin_lock_init(&stats->nid_brw_stats->hist[i].oh_lock);
+ spin_lock_init(&stats->nid_brw_stats->hist[i].oh_lock);
rc = lprocfs_seq_create(stats->nid_proc, "brw_stats", 0644,
&ofd_per_nid_stats_fops, stats);
lsd->lsd_feature_compat |= OBD_COMPAT_OST;
/* sync is not needed here as lut_client_add will
* set exp_need_sync flag */
- lut_server_data_update(env, &ofd->ofd_lut, 0);
+ tgt_server_data_update(env, &ofd->ofd_lut, 0);
} else if (index != data->ocd_index) {
LCONSOLE_ERROR_MSG(0x136, "Connection from %s to index"
" %u doesn't match actual OST index"
memcpy(ted->ted_lcd->lcd_uuid, cluuid,
sizeof(ted->ted_lcd->lcd_uuid));
- rc = lut_client_new(env, exp);
+ rc = tgt_client_new(env, exp);
if (rc != 0)
GOTO(out, rc);
ofd_export_stats_init(ofd, exp, localdata);
/* Do not erase record for recoverable client. */
if (exp->exp_obd->obd_replayable &&
(!exp->exp_obd->obd_fail || exp->exp_failed))
- lut_client_del(&env, exp);
+ tgt_client_del(&env, exp);
lu_env_fini(&env);
class_export_put(exp);
{
int rc;
- cfs_spin_lock_init(&exp->exp_filter_data.fed_lock);
+ spin_lock_init(&exp->exp_filter_data.fed_lock);
CFS_INIT_LIST_HEAD(&exp->exp_filter_data.fed_mod_list);
- cfs_spin_lock(&exp->exp_lock);
+ spin_lock(&exp->exp_lock);
exp->exp_connecting = 1;
- cfs_spin_unlock(&exp->exp_lock);
+ spin_unlock(&exp->exp_lock);
/* self-export doesn't need client data and ldlm initialization */
if (unlikely(obd_uuid_equals(&exp->exp_obd->obd_uuid,
&exp->exp_client_uuid)))
return 0;
- rc = lut_client_alloc(exp);
+ rc = tgt_client_alloc(exp);
if (rc == 0)
ldlm_init_export(exp);
if (rc)
return 0;
ldlm_destroy_export(exp);
- lut_client_free(exp);
+ tgt_client_free(exp);
ofd_fmd_cleanup(exp);
return 0;
}
+int ofd_postrecov(const struct lu_env *env, struct ofd_device *ofd)
+{
+ struct lu_device *ldev = &ofd->ofd_dt_dev.dd_lu_dev;
+
+ CDEBUG(D_HA, "%s: recovery is over\n", ofd_obd(ofd)->obd_name);
+ return ldev->ld_ops->ldo_recovery_complete(env, ldev);
+}
+
int ofd_obd_postrecov(struct obd_device *obd)
{
struct lu_env env;
RETURN(rc);
ofd_info_init(&env, obd->obd_self_export);
- rc = ldev->ld_ops->ldo_recovery_complete(&env, ldev);
+ rc = ofd_postrecov(&env, ofd_dev(ldev));
+
lu_env_fini(&env);
RETURN(rc);
}
sptlrpc_target_update_exp_flavor(obd, &tmp_rset);
- cfs_write_lock(&fo->fo_sptlrpc_lock);
+ write_lock(&fo->fo_sptlrpc_lock);
sptlrpc_rule_set_free(&fo->fo_sptlrpc_rset);
fo->fo_sptlrpc_rset = tmp_rset;
- cfs_write_unlock(&fo->fo_sptlrpc_lock);
+ write_unlock(&fo->fo_sptlrpc_lock);
return 0;
}
} else if (KEY_IS(KEY_GRANT_SHRINK)) {
struct ost_body *body = val;
+ ofd_info_init(env, exp);
/** handle grant shrink, similar to a read request */
ofd_grant_prepare_read(env, exp, &body->oa);
} else {
{
int rc;
- cfs_spin_lock(&ofd->ofd_osfs_lock);
+ spin_lock(&ofd->ofd_osfs_lock);
if (cfs_time_before_64(ofd->ofd_osfs_age, max_age) || max_age == 0) {
obd_size unstable;
/* record value of inflight counter before running statfs to
* compute the diff once statfs is completed */
unstable = ofd->ofd_osfs_inflight;
- cfs_spin_unlock(&ofd->ofd_osfs_lock);
+ spin_unlock(&ofd->ofd_osfs_lock);
/* statfs can sleep ... hopefully not for too long since we can
* call it fairly often as space fills up */
if (unlikely(rc))
return rc;
- cfs_spin_lock(&ofd->ofd_grant_lock);
- cfs_spin_lock(&ofd->ofd_osfs_lock);
+ spin_lock(&ofd->ofd_grant_lock);
+ spin_lock(&ofd->ofd_osfs_lock);
/* calculate how much space was written while we released the
* ofd_osfs_lock */
unstable = ofd->ofd_osfs_inflight - unstable;
/* similarly, there is some uncertainty on write requests
* between prepare & commit */
ofd->ofd_osfs_unstable += ofd->ofd_tot_pending;
- cfs_spin_unlock(&ofd->ofd_grant_lock);
+ spin_unlock(&ofd->ofd_grant_lock);
/* finally udpate cached statfs data */
ofd->ofd_osfs = *osfs;
ofd->ofd_statfs_inflight--; /* stop tracking */
if (ofd->ofd_statfs_inflight == 0)
ofd->ofd_osfs_inflight = 0;
- cfs_spin_unlock(&ofd->ofd_osfs_lock);
+ spin_unlock(&ofd->ofd_osfs_lock);
if (from_cache)
*from_cache = 0;
} else {
/* use cached statfs data */
*osfs = ofd->ofd_osfs;
- cfs_spin_unlock(&ofd->ofd_osfs_lock);
+ spin_unlock(&ofd->ofd_osfs_lock);
if (from_cache)
*from_cache = 1;
}
{
struct ofd_thread_info *info = ofd_info(env);
struct lustre_handle lockh;
- int flags = LDLM_AST_DISCARD_DATA, rc = 0;
+ __u64 flags = LDLM_AST_DISCARD_DATA, rc = 0;
ldlm_policy_data_t policy = {
.l_extent = { 0, OBD_OBJECT_EOF }
};
ENTRY;
+ fo = ofd_object_find(env, ofd, fid);
+ if (IS_ERR(fo))
+ RETURN(PTR_ERR(fo));
+
/* Tell the clients that the object is gone now and that they should
* throw away any cached pages. */
ofd_build_resid(fid, &info->fti_resid);
rc = ldlm_cli_enqueue_local(ofd->ofd_namespace, &info->fti_resid,
LDLM_EXTENT, &policy, LCK_PW, &flags,
ldlm_blocking_ast, ldlm_completion_ast,
- NULL, NULL, 0, NULL, &lockh);
+ NULL, NULL, 0, LVB_T_NONE, NULL, &lockh);
/* We only care about the side-effects, just drop the lock. */
if (rc == ELDLM_OK)
ldlm_lock_decref(&lockh, LCK_PW);
- fo = ofd_object_find(env, ofd, fid);
- if (IS_ERR(fo))
- RETURN(PTR_ERR(fo));
LASSERT(fo != NULL);
rc = ofd_object_destroy(env, fo, orphan);
lrc = ofd_destroy_by_fid(env, ofd, &info->fti_fid, 0);
if (lrc == -ENOENT) {
CDEBUG(D_INODE,
- "destroying non-existent object "LPU64"\n",
- oa->o_id);
+ "%s: destroying non-existent object "DFID"\n",
+ ofd_obd(ofd)->obd_name, PFID(&info->fti_fid));
/* rewrite rc with -ENOENT only if it is 0 */
if (rc == 0)
rc = lrc;
} else if (lrc != 0) {
- CEMERG("error destroying object "LPU64": %d\n",
- oa->o_id, rc);
+ CERROR("%s: error destroying object "DFID": %d\n",
+ ofd_obd(ofd)->obd_name, PFID(&info->fti_fid),
+ rc);
rc = lrc;
}
count--;
skip_orphan = !!(exp->exp_connect_flags & OBD_CONNECT_SKIP_ORPHAN);
last = ofd_last_id(ofd, oa->o_seq);
- CWARN("%s: deleting orphan objects from "LPU64" to "LPU64"\n",
- ofd_obd(ofd)->obd_name, oa->o_id + 1, last);
+ LCONSOLE_INFO("%s: deleting orphan objects from "LPU64" to "LPU64"\n",
+ ofd_obd(ofd)->obd_name, oa->o_id + 1, last);
for (oi.oi_id = last; oi.oi_id > oa->o_id; oi.oi_id--) {
fid_ostid_unpack(&info->fti_fid, &oi, 0);
GOTO(out_nolock, rc = 0);
}
/* This causes inflight precreates to abort and drop lock */
- cfs_set_bit(oa->o_seq, &ofd->ofd_destroys_in_progress);
- cfs_mutex_lock(&ofd->ofd_create_locks[oa->o_seq]);
- if (!cfs_test_bit(oa->o_seq, &ofd->ofd_destroys_in_progress)) {
+ set_bit(oa->o_seq, &ofd->ofd_destroys_in_progress);
+ mutex_lock(&ofd->ofd_create_locks[oa->o_seq]);
+ if (!test_bit(oa->o_seq, &ofd->ofd_destroys_in_progress)) {
CERROR("%s:["LPU64"] destroys_in_progress already cleared\n",
exp->exp_obd->obd_name, oa->o_seq);
GOTO(out, rc = 0);
rc = 0;
} else if (diff < 0) {
rc = ofd_orphans_destroy(env, exp, ofd, oa);
- cfs_clear_bit(oa->o_seq, &ofd->ofd_destroys_in_progress);
+ clear_bit(oa->o_seq, &ofd->ofd_destroys_in_progress);
} else {
/* XXX: Used by MDS for the first time! */
- cfs_clear_bit(oa->o_seq, &ofd->ofd_destroys_in_progress);
+ clear_bit(oa->o_seq, &ofd->ofd_destroys_in_progress);
}
} else {
- cfs_mutex_lock(&ofd->ofd_create_locks[oa->o_seq]);
+ mutex_lock(&ofd->ofd_create_locks[oa->o_seq]);
if (oti->oti_conn_cnt < exp->exp_conn_cnt) {
CERROR("%s: dropping old precreate request\n",
ofd_obd(ofd)->obd_name);
created, diff + created,
created / DISK_TIMEOUT);
break;
- }
+ }
rc = ofd_precreate_objects(env, ofd, next_id,
oa->o_seq, count);
ofd_info2oti(info, oti);
out:
- cfs_mutex_unlock(&ofd->ofd_create_locks[oa->o_seq]);
+ mutex_unlock(&ofd->ofd_create_locks[oa->o_seq]);
out_nolock:
if (rc == 0 && ea != NULL) {
struct lov_stripe_md *lsm = *ea;
return !!rc;
}
-static int ofd_obd_notify(struct obd_device *obd, struct obd_device *unused,
- enum obd_notify_event ev, void *data)
-{
- switch (ev) {
- case OBD_NOTIFY_CONFIG:
- LASSERT(obd->obd_no_conn);
- cfs_spin_lock(&obd->obd_dev_lock);
- obd->obd_no_conn = 0;
- cfs_spin_unlock(&obd->obd_dev_lock);
- break;
- default:
- CDEBUG(D_INFO, "%s: Unhandled notification %#x\n",
- obd->obd_name, ev);
- }
- return 0;
-}
-
/*
* Handle quota control requests to consult current usage/limit.
*
.o_precleanup = ofd_precleanup,
.o_ping = ofd_ping,
.o_health_check = ofd_health_check,
- .o_notify = ofd_obd_notify,
.o_quotactl = ofd_quotactl,
};
git://git.whamcloud.com / fs / lustre-release.git / blobdiff