*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*
* Lustre Unified Target
* These are common function to work with last_received file
{
struct tgt_new_client_callback *ccb;
- ccb = container_of0(cb, struct tgt_new_client_callback, lncc_cb);
+ ccb = container_of(cb, struct tgt_new_client_callback, lncc_cb);
LASSERT(ccb->lncc_exp->exp_obd);
struct lu_env env;
struct ptlrpc_request *req;
__u32 start_epoch;
- struct list_head client_list;
+ LIST_HEAD(client_list);
int rc;
if (tgt->lut_obd->obd_stopping)
tgt->lut_lsd.lsd_start_epoch = start_epoch;
spin_unlock(&tgt->lut_translock);
- INIT_LIST_HEAD(&client_list);
/**
* The recovery is not yet finished and final queue can still be updated
* with resend requests. Move final list to separate one for processing
{
struct tgt_last_committed_callback *ccb;
- ccb = container_of0(cb, struct tgt_last_committed_callback, llcc_cb);
+ ccb = container_of(cb, struct tgt_last_committed_callback, llcc_cb);
LASSERT(ccb->llcc_exp);
LASSERT(ccb->llcc_tgt != NULL);
LASSERT(ccb->llcc_exp->exp_obd == ccb->llcc_tgt->lut_obd);
+ if (th->th_reserved_quota.lqi_space > 0) {
+ CDEBUG(D_QUOTA, "free quota %llu %llu\n",
+ th->th_reserved_quota.lqi_id.qid_gid,
+ th->th_reserved_quota.lqi_space);
+
+ /* env can be NULL for freeing reserved quota */
+ th->th_reserved_quota.lqi_space *= -1;
+ dt_reserve_or_free_quota(NULL, th->th_dev,
+ &th->th_reserved_quota);
+ }
+
/* error hit, don't update last committed to provide chance to
* replay data after fail */
if (err != 0)
return rc ? rc : exp->exp_need_sync;
}
+static int tgt_is_local_client(const struct lu_env *env,
+ struct obd_export *exp)
+{
+ struct lu_target *tgt = class_exp2tgt(exp);
+ struct tgt_session_info *tsi = tgt_ses_info(env);
+ struct ptlrpc_request *req = tgt_ses_req(tsi);
+ struct lnet_nid nid;
+
+ if (exp_connect_flags(exp) & OBD_CONNECT_MDS ||
+ exp_connect_flags(exp) & OBD_CONNECT_MDS_MDS)
+ return 0;
+ if (tgt->lut_local_recovery)
+ return 0;
+ if (!req)
+ return 0;
+ lnet_nid4_to_nid(req->rq_peer.nid, &nid);
+ if (!LNetIsPeerLocal(&nid))
+ return 0;
+
+ return 1;
+}
+
/**
* Add new client to the last_rcvd upon new connection.
*
if (exp_connect_flags(exp) & OBD_CONNECT_LIGHTWEIGHT)
RETURN(0);
+ if (tgt_is_local_client(env, exp)) {
+ LCONSOLE_WARN("%s: local client %s w/o recovery\n",
+ exp->exp_obd->obd_name, ted->ted_lcd->lcd_uuid);
+ exp->exp_no_recovery = 1;
+ RETURN(0);
+ }
+
/* the bitmap operations can handle cl_idx > sizeof(long) * 8, so
* there's no need for extra complication here
*/
/* XXX if lcd_uuid were a real obd_uuid, I could use obd_uuid_equals */
if (!strcmp((char *)ted->ted_lcd->lcd_uuid,
(char *)tgt->lut_obd->obd_uuid.uuid) ||
- exp_connect_flags(exp) & OBD_CONNECT_LIGHTWEIGHT)
+ exp_connect_flags(exp) & OBD_CONNECT_LIGHTWEIGHT ||
+ exp->exp_no_recovery)
RETURN(0);
/* Slot may be not yet assigned, use case is race between Client
{
struct lsd_reply_data *lrd;
int i;
+ int rc;
lrd = &trd->trd_reply;
/* update export last transno */
if (update_lrd_file) {
loff_t off;
- int rc;
/* write reply data to disk */
off = sizeof(struct lsd_reply_header) + sizeof(*lrd) * i;
if (unlikely(rc != 0)) {
CERROR("%s: can't update %s file: rc = %d\n",
tgt_name(tgt), REPLY_DATA, rc);
- RETURN(rc);
+ GOTO(free_slot, rc);
}
}
} else {
MSG_REPLAY : MSG_REPLAY|MSG_RESENT;
if (req->rq_obsolete) {
+ CDEBUG(D_INFO,
+ "drop reply data update for obsolete req xid=%llu,"
+ "transno=%llu, tag=%hu\n", req->rq_xid,
+ lrd->lrd_transno, trd->trd_tag);
mutex_unlock(&ted->ted_lcd_lock);
- RETURN(-EALREADY);
+ GOTO(free_slot, rc = -EBADR);
}
if (!(lustre_msg_get_flags(req->rq_reqmsg) & exclude))
trd->trd_tag, lrd->lrd_client_gen, trd->trd_index);
RETURN(0);
+
+free_slot:
+ if (tgt != NULL)
+ tgt_clear_reply_slot(tgt, trd->trd_index);
+ return rc;
}
int tgt_mk_reply_data(const struct lu_env *env,
struct lsd_reply_data *lrd;
__u64 *pre_versions = NULL;
int rc;
+ struct tgt_session_info *tsi = NULL;
OBD_ALLOC_PTR(trd);
if (unlikely(trd == NULL))
RETURN(-ENOMEM);
+ if (env != NULL)
+ tsi = tgt_ses_info(env);
+
/* fill reply data information */
lrd = &trd->trd_reply;
lrd->lrd_transno = transno;
lrd->lrd_result = th->th_result;
}
} else {
- struct tgt_session_info *tsi;
-
LASSERT(env != NULL);
- tsi = tgt_ses_info(env);
LASSERT(tsi->tsi_xid != 0);
lrd->lrd_xid = tsi->tsi_xid;
trd->trd_pre_versions[3] = pre_versions[3];
}
+ if (tsi && tsi->tsi_open_obj)
+ trd->trd_object = *lu_object_fid(&tsi->tsi_open_obj->do_lu);
+
rc = tgt_add_reply_data(env, tgt, ted, trd, req,
th, write_update);
- if (rc < 0)
+ if (rc < 0) {
OBD_FREE_PTR(trd);
+ if (rc == -EBADR)
+ rc = 0;
+ }
return rc;
}
{
struct tgt_thread_info *tti = tgt_th_info(env);
struct tgt_session_info *tsi = tgt_ses_info(env);
- struct obd_export *exp = tsi->tsi_exp;
- struct tg_export_data *ted;
- __u64 *transno_p;
- int rc = 0;
- bool lw_client;
+ struct obd_export *exp = tsi->tsi_exp;
+ struct tg_export_data *ted;
+ __u64 *transno_p;
+ bool nolcd = false;
+ int rc = 0;
ENTRY;
LASSERT(exp != NULL);
ted = &exp->exp_target_data;
- lw_client = exp_connect_flags(exp) & OBD_CONNECT_LIGHTWEIGHT;
- if (ted->ted_lr_idx < 0 && !lw_client)
- /* ofd connect may cause transaction before export has
- * last_rcvd slot */
- RETURN(0);
+ /* Some clients don't support recovery, and they don't have last_rcvd
+ * client data:
+ * 1. lightweight clients.
+ * 2. local clients on MDS which doesn't enable "localrecov".
+ * 3. OFD connect may cause transaction before export has last_rcvd
+ * slot.
+ */
+ if (ted->ted_lr_idx < 0)
+ nolcd = true;
if (req != NULL)
tti->tti_transno = lustre_msg_get_transno(req->rq_reqmsg);
/* if can't add callback, do sync write */
th->th_sync |= !!tgt_last_commit_cb_add(th, tgt, exp, tti->tti_transno);
- if (lw_client) {
- /* All operations performed by LW clients are synchronous and
- * we store the committed transno in the last_rcvd header */
+ if (nolcd) {
+ /* store transno in the last_rcvd header */
spin_lock(&tgt->lut_translock);
if (tti->tti_transno > tgt->lut_lsd.lsd_last_transno) {
tgt->lut_lsd.lsd_last_transno = tti->tti_transno;
spin_unlock(&tgt->lut_translock);
- /* Although lightweight (LW) connections have no slot
+ /* Although current connection doesn't have slot
* in the last_rcvd, we still want to maintain
* the in-memory lsd_client_data structure in order to
* properly handle reply reconstruction. */
}
}
- if (!lw_client) {
+ if (!nolcd) {
tti->tti_off = ted->ted_lr_off;
if (CFS_FAIL_CHECK(OBD_FAIL_TGT_RCVD_EIO))
rc = -EIO;
trd->trd_pre_versions[3] = 0;
trd->trd_index = idx;
trd->trd_tag = 0;
+ fid_zero(&trd->trd_object);
list_add(&trd->trd_list, &ted->ted_reply_list);
ted->ted_reply_cnt++;
if (ted->ted_reply_cnt > ted->ted_reply_max)