* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
lcd->lcd_last_close_result, rc);
return rc;
}
-EXPORT_SYMBOL(tgt_client_data_read);
int tgt_client_data_write(const struct lu_env *env, struct lu_target *tgt,
struct lsd_client_data *lcd, loff_t *off,
return dt_record_write(env, tgt->lut_last_rcvd, &tti->tti_buf, off, th);
}
-EXPORT_SYMBOL(tgt_client_data_write);
/**
* Update client data in last_rcvd
*/
-int tgt_client_data_update(const struct lu_env *env, struct obd_export *exp)
+static int tgt_client_data_update(const struct lu_env *env,
+ struct obd_export *exp)
{
struct tg_export_data *ted = &exp->exp_target_data;
struct lu_target *tgt = class_exp2tgt(exp);
if (IS_ERR(th))
RETURN(PTR_ERR(th));
+ tti_buf_lcd(tti);
rc = dt_declare_record_write(env, tgt->lut_last_rcvd,
- sizeof(struct lsd_client_data),
+ &tti->tti_buf,
ted->ted_lr_off, th);
if (rc)
GOTO(out, rc);
tgt->lut_lsd.lsd_uuid, tgt->lut_lsd.lsd_last_transno, rc);
return rc;
}
-EXPORT_SYMBOL(tgt_server_data_read);
int tgt_server_data_write(const struct lu_env *env, struct lu_target *tgt,
struct thandle *th)
RETURN(rc);
}
-EXPORT_SYMBOL(tgt_server_data_write);
/**
* Update server data in last_rcvd
th->th_sync = sync;
+ tti_buf_lsd(tti);
rc = dt_declare_record_write(env, tgt->lut_last_rcvd,
- sizeof(struct lr_server_data),
- tti->tti_off, th);
+ &tti->tti_buf, tti->tti_off, th);
if (rc)
GOTO(out, rc);
RETURN(rc);
}
-EXPORT_SYMBOL(tgt_truncate_last_rcvd);
-void tgt_client_epoch_update(const struct lu_env *env, struct obd_export *exp)
+static void tgt_client_epoch_update(const struct lu_env *env,
+ struct obd_export *exp)
{
struct lsd_client_data *lcd = exp->exp_target_data.ted_lcd;
struct lu_target *tgt = class_exp2tgt(exp);
struct lu_env env;
struct ptlrpc_request *req;
__u32 start_epoch;
- cfs_list_t client_list;
+ struct 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);
- CFS_INIT_LIST_HEAD(&client_list);
+ 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
*/
spin_lock(&tgt->lut_obd->obd_recovery_task_lock);
- cfs_list_splice_init(&tgt->lut_obd->obd_final_req_queue, &client_list);
+ list_splice_init(&tgt->lut_obd->obd_final_req_queue, &client_list);
spin_unlock(&tgt->lut_obd->obd_recovery_task_lock);
/**
* go through list of exports participated in recovery and
* set new epoch for them
*/
- cfs_list_for_each_entry(req, &client_list, rq_list) {
+ list_for_each_entry(req, &client_list, rq_list) {
LASSERT(!req->rq_export->exp_delayed);
if (!req->rq_export->exp_vbr_failed)
tgt_client_epoch_update(&env, req->rq_export);
}
/** return list back at once */
spin_lock(&tgt->lut_obd->obd_recovery_task_lock);
- cfs_list_splice_init(&client_list, &tgt->lut_obd->obd_final_req_queue);
+ list_splice_init(&client_list, &tgt->lut_obd->obd_final_req_queue);
spin_unlock(&tgt->lut_obd->obd_recovery_task_lock);
/** update server epoch */
tgt_server_data_update(&env, tgt, 1);
lu_env_fini(&env);
}
-EXPORT_SYMBOL(tgt_boot_epoch_update);
/**
* commit callback, need to update last_commited value
__u64 llcc_transno;
};
-void tgt_cb_last_committed(struct lu_env *env, struct thandle *th,
- struct dt_txn_commit_cb *cb, int err)
+static void tgt_cb_last_committed(struct lu_env *env, struct thandle *th,
+ struct dt_txn_commit_cb *cb, int err)
{
struct tgt_last_committed_callback *ccb;
dcb = &ccb->llcc_cb;
dcb->dcb_func = tgt_cb_last_committed;
- CFS_INIT_LIST_HEAD(&dcb->dcb_linkage);
- strncpy(dcb->dcb_name, "tgt_cb_last_committed", MAX_COMMIT_CB_STR_LEN);
- dcb->dcb_name[MAX_COMMIT_CB_STR_LEN - 1] = '\0';
+ INIT_LIST_HEAD(&dcb->dcb_linkage);
+ strlcpy(dcb->dcb_name, "tgt_cb_last_committed", sizeof(dcb->dcb_name));
rc = dt_trans_cb_add(th, dcb);
if (rc) {
return rc;
}
-EXPORT_SYMBOL(tgt_last_commit_cb_add);
struct tgt_new_client_callback {
struct dt_txn_commit_cb lncc_cb;
struct obd_export *lncc_exp;
};
-void tgt_cb_new_client(struct lu_env *env, struct thandle *th,
- struct dt_txn_commit_cb *cb, int err)
+static void tgt_cb_new_client(struct lu_env *env, struct thandle *th,
+ struct dt_txn_commit_cb *cb, int err)
{
struct tgt_new_client_callback *ccb;
ccb->lncc_exp->exp_client_uuid.uuid);
spin_lock(&ccb->lncc_exp->exp_lock);
- ccb->lncc_exp->exp_need_sync = 0;
+ /* XXX: Currently, we use per-export based sync/async policy for
+ * the update via OUT RPC, it is coarse-grained policy, and
+ * will be changed as per-request based by DNE II patches. */
+ if (!ccb->lncc_exp->exp_keep_sync)
+ ccb->lncc_exp->exp_need_sync = 0;
+
spin_unlock(&ccb->lncc_exp->exp_lock);
class_export_cb_put(ccb->lncc_exp);
dcb = &ccb->lncc_cb;
dcb->dcb_func = tgt_cb_new_client;
- CFS_INIT_LIST_HEAD(&dcb->dcb_linkage);
- strncpy(dcb->dcb_name, "tgt_cb_new_client", MAX_COMMIT_CB_STR_LEN);
- dcb->dcb_name[MAX_COMMIT_CB_STR_LEN - 1] = '\0';
+ INIT_LIST_HEAD(&dcb->dcb_linkage);
+ strlcpy(dcb->dcb_name, "tgt_cb_new_client", sizeof(dcb->dcb_name));
rc = dt_trans_cb_add(th, dcb);
if (rc) {
RETURN(0);
}
-EXPORT_SYMBOL(tgt_client_add);
int tgt_client_del(const struct lu_env *env, struct obd_export *exp)
{
/*
* last_rcvd & last_committed update callbacks
*/
-int tgt_last_rcvd_update(const struct lu_env *env, struct lu_target *tgt,
- struct dt_object *obj, __u64 opdata,
- struct thandle *th, struct ptlrpc_request *req)
+static int tgt_last_rcvd_update(const struct lu_env *env, struct lu_target *tgt,
+ struct dt_object *obj, __u64 opdata,
+ struct thandle *th, struct ptlrpc_request *req)
{
struct tgt_thread_info *tti = tgt_th_info(env);
struct tg_export_data *ted;
* It updates last_rcvd client slot and version of object in
* simple way but with all locks to simulate all drawbacks
*/
-int tgt_last_rcvd_update_echo(const struct lu_env *env, struct lu_target *tgt,
- struct dt_object *obj, struct thandle *th,
- struct obd_export *exp)
+static int tgt_last_rcvd_update_echo(const struct lu_env *env,
+ struct lu_target *tgt,
+ struct dt_object *obj,
+ struct thandle *th,
+ struct obd_export *exp)
{
struct tgt_thread_info *tti = tgt_th_info(env);
struct tg_export_data *ted = &exp->exp_target_data;
RETURN(rc);
}
-int tgt_clients_data_init(const struct lu_env *env, struct lu_target *tgt,
- unsigned long last_size)
+static int tgt_clients_data_init(const struct lu_env *env,
+ struct lu_target *tgt,
+ unsigned long last_size)
{
struct obd_device *obd = tgt->lut_obd;
struct lr_server_data *lsd = &tgt->lut_lsd;
OBD_INCOMPAT_MULTI_OI,
},
[LDD_F_SV_TYPE_OST] = {
- .rocompat = 0,
+ .rocompat = OBD_ROCOMPAT_IDX_IN_IDIF,
.incompat = OBD_INCOMPAT_OST | OBD_INCOMPAT_COMMON_LR |
OBD_INCOMPAT_FID,
- .rocinit = 0,
+ .rocinit = OBD_ROCOMPAT_IDX_IN_IDIF,
.incinit = OBD_INCOMPAT_OST | OBD_INCOMPAT_COMMON_LR,
}
};
lsd->lsd_feature_incompat & ~tgt_scd[type].incompat);
RETURN(-EINVAL);
}
+
+ if (type == LDD_F_SV_TYPE_MDT)
+ lsd->lsd_feature_incompat |= OBD_INCOMPAT_FID;
+
if (lsd->lsd_feature_rocompat & ~tgt_scd[type].rocompat) {
CERROR("%s: unsupported read-only filesystem feature(s) %x\n",
tgt_name(tgt),
lsd->lsd_feature_compat |= OBD_COMPAT_20;
}
- lsd->lsd_feature_incompat |= OBD_INCOMPAT_FID;
-
spin_lock(&tgt->lut_translock);
tgt->lut_last_transno = lsd->lsd_last_transno;
spin_unlock(&tgt->lut_translock);
{
struct lu_target *tgt = cookie;
struct tgt_session_info *tsi;
+ struct tgt_thread_info *tti = tgt_th_info(env);
int rc;
/* if there is no session, then this transaction is not result of
if (tsi->tsi_exp == NULL)
return 0;
+ tti_buf_lcd(tti);
rc = dt_declare_record_write(env, tgt->lut_last_rcvd,
- sizeof(struct lsd_client_data),
+ &tti->tti_buf,
tsi->tsi_exp->exp_target_data.ted_lr_off,
th);
if (rc)
return rc;
+ tti_buf_lsd(tti);
rc = dt_declare_record_write(env, tgt->lut_last_rcvd,
- sizeof(struct lr_server_data), 0, th);
+ &tti->tti_buf, 0, th);
if (rc)
return rc;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff