# include <liblustre.h>
#endif
#include <obd.h>
-#include <lustre_mds.h>
+#include <obd_class.h>
#include <lustre_dlm.h>
#include <lustre_net.h>
#include <lustre_sec.h>
{
return import_set_conn(imp, uuid, priority, 1);
}
+EXPORT_SYMBOL(client_import_add_conn);
int client_import_del_conn(struct obd_import *imp, struct obd_uuid *uuid)
{
CERROR("connection %s not found\n", uuid->uuid);
RETURN(rc);
}
+EXPORT_SYMBOL(client_import_del_conn);
/**
* Find conn uuid by peer nid. @peer is a server nid. This function is used
/* In a more perfect world, we would hang a ptlrpc_client off of
* obd_type and just use the values from there. */
- if (!strcmp(name, LUSTRE_OSC_NAME)) {
+ if (!strcmp(name, LUSTRE_OSC_NAME) ||
+ (!strcmp(name, LUSTRE_OSP_NAME) &&
+ !is_osp_on_ost(lustre_cfg_buf(lcfg, 0)))) {
rq_portal = OST_REQUEST_PORTAL;
rp_portal = OSC_REPLY_PORTAL;
connect_op = OST_CONNECT;
cli->cl_sp_to = LUSTRE_SP_OST;
ns_type = LDLM_NS_TYPE_OSC;
- } else if (!strcmp(name, LUSTRE_MDC_NAME)) {
+ } else if (!strcmp(name, LUSTRE_MDC_NAME) ||
+ (!strcmp(name, LUSTRE_OSP_NAME) &&
+ is_osp_on_ost(lustre_cfg_buf(lcfg, 0)))) {
rq_portal = MDS_REQUEST_PORTAL;
rp_portal = MDC_REPLY_PORTAL;
connect_op = MDS_CONNECT;
cli->cl_flvr_mgc.sf_rpc = SPTLRPC_FLVR_INVALID;
ns_type = LDLM_NS_TYPE_MGC;
+ } else if (!strcmp(name, LUSTRE_OSP_NAME)) {
+ rq_portal = OST_REQUEST_PORTAL;
+ rp_portal = OSC_REPLY_PORTAL;
+ connect_op = OST_CONNECT;
+ cli->cl_sp_me = LUSTRE_SP_CLI;
+ cli->cl_sp_to = LUSTRE_SP_OST;
+ ns_type = LDLM_NS_TYPE_OSC;
+
} else {
CERROR("unknown client OBD type \"%s\", can't setup\n",
name);
cfs_spin_lock_init(&cli->cl_write_page_hist.oh_lock);
cfs_spin_lock_init(&cli->cl_read_offset_hist.oh_lock);
cfs_spin_lock_init(&cli->cl_write_offset_hist.oh_lock);
+
+ /* lru for osc. */
+ CFS_INIT_LIST_HEAD(&cli->cl_lru_osc);
+ cfs_atomic_set(&cli->cl_lru_shrinkers, 0);
+ cfs_atomic_set(&cli->cl_lru_busy, 0);
+ cfs_atomic_set(&cli->cl_lru_in_list, 0);
+ CFS_INIT_LIST_HEAD(&cli->cl_lru_list);
+ client_obd_list_lock_init(&cli->cl_lru_list_lock);
+
cfs_waitq_init(&cli->cl_destroy_waitq);
cfs_atomic_set(&cli->cl_destroy_in_flight, 0);
#ifdef ENABLE_CHECKSUM
RETURN(rc);
}
+EXPORT_SYMBOL(client_obd_setup);
int client_obd_cleanup(struct obd_device *obddev)
{
ldlm_put_ref();
RETURN(0);
}
+EXPORT_SYMBOL(client_obd_cleanup);
/* ->o_connect() method for client side (OSC and MDC and MGC) */
int client_connect_import(const struct lu_env *env,
return rc;
}
+EXPORT_SYMBOL(client_connect_import);
int client_disconnect_export(struct obd_export *exp)
{
RETURN(rc);
}
+EXPORT_SYMBOL(client_disconnect_export);
#ifdef HAVE_SERVER_SUPPORT
int server_disconnect_export(struct obd_export *exp)
RETURN(rc);
}
+EXPORT_SYMBOL(server_disconnect_export);
/* --------------------------------------------------------------------------
* from old lib/target.c
int rc = 0;
char *target_start;
int target_len;
- int mds_conn = 0;
+ bool mds_conn = false, lw_client = false;
struct obd_connect_data *data, *tmpdata;
int size, tmpsize;
lnet_nid_t *client_nid = NULL;
- bool mne_swab_client_ver;
ENTRY;
OBD_RACE(OBD_FAIL_TGT_CONN_RACE);
if (rc)
GOTO(out, rc);
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 6, 50, 0)
- /* Check if the client might be missing the LU-1252 fix to swab
- * the IR mne_length entries. Do this as early as possible in case
- * the version code is modified. See LU-1644 for details. */
- mne_swab_client_ver = OBD_OCD_VERSION_MAJOR(data->ocd_version) == 2 &&
- OBD_OCD_VERSION_MINOR(data->ocd_version) == 2 &&
- OBD_OCD_VERSION_PATCH(data->ocd_version) < 55;
-#endif
-
if (lustre_msg_get_op_flags(req->rq_reqmsg) & MSG_CONNECT_LIBCLIENT) {
if (!data) {
DEBUG_REQ(D_WARNING, req, "Refusing old (unversioned) "
if ((lustre_msg_get_op_flags(req->rq_reqmsg) & MSG_CONNECT_INITIAL) &&
(data->ocd_connect_flags & OBD_CONNECT_MDS))
- mds_conn = 1;
+ mds_conn = true;
+
+ if ((data->ocd_connect_flags & OBD_CONNECT_LIGHTWEIGHT) != 0)
+ lw_client = true;
/* lctl gets a backstage, all-access pass. */
if (obd_uuid_equals(&cluuid, &target->obd_uuid))
goto no_export;
/* we've found an export in the hash */
+
+ cfs_spin_lock(&export->exp_lock);
+
if (export->exp_connecting) { /* bug 9635, et. al. */
+ cfs_spin_unlock(&export->exp_lock);
LCONSOLE_WARN("%s: Export %p already connecting from %s\n",
export->exp_obd->obd_name, export,
libcfs_nid2str(req->rq_peer.nid));
export = NULL;
rc = -EALREADY;
} else if (mds_conn && export->exp_connection) {
+ cfs_spin_unlock(&export->exp_lock);
if (req->rq_peer.nid != export->exp_connection->c_peer.nid)
/* mds reconnected after failover */
LCONSOLE_WARN("%s: Received MDS connection from "
req->rq_peer.nid != export->exp_connection->c_peer.nid &&
(lustre_msg_get_op_flags(req->rq_reqmsg) &
MSG_CONNECT_INITIAL)) {
+ cfs_spin_unlock(&export->exp_lock);
/* in mds failover we have static uuid but nid can be
* changed*/
LCONSOLE_WARN("%s: Client %s seen on new nid %s when "
class_export_put(export);
export = NULL;
} else {
- cfs_spin_lock(&export->exp_lock);
- export->exp_connecting = 1;
- cfs_spin_unlock(&export->exp_lock);
- LASSERT(export->exp_obd == target);
+ export->exp_connecting = 1;
+ cfs_spin_unlock(&export->exp_lock);
+ LASSERT(export->exp_obd == target);
- rc = target_handle_reconnect(&conn, export, &cluuid);
- }
+ rc = target_handle_reconnect(&conn, export, &cluuid);
+ }
/* If we found an export, we already unlocked. */
if (!export) {
export ? (long)export->exp_last_request_time : 0);
/* If this is the first time a client connects, reset the recovery
- * timer */
- if (rc == 0 && target->obd_recovering)
+ * timer. Discard lightweight connections which might be local */
+ if (!lw_client && rc == 0 && target->obd_recovering)
check_and_start_recovery_timer(target, req, export == NULL);
/* We want to handle EALREADY but *not* -EALREADY from
client_nid = &req->rq_peer.nid;
if (export == NULL) {
- if (target->obd_recovering) {
+ /* allow lightweight connections during recovery */
+ if (target->obd_recovering && !lw_client) {
cfs_time_t t;
int c; /* connected */
int i; /* in progress */
* OBD_CONNECT_MNE_SWAB flag around forever, just so long as we need
* interop with unpatched 2.2 clients. For newer clients, servers
* will never do MNE swabbing, let the client handle that. LU-1644 */
- export->exp_need_mne_swab =
- !(data->ocd_connect_flags & OBD_CONNECT_MNE_SWAB) &&
- mne_swab_client_ver && !ptlrpc_req_need_swab(req);
+ export->exp_need_mne_swab = !ptlrpc_req_need_swab(req) &&
+ !(data->ocd_connect_flags & OBD_CONNECT_MNE_SWAB);
#else
#warning "LU-1644: Remove old OBD_CONNECT_MNE_SWAB fixup and exp_need_mne_swab"
#endif
cfs_spin_lock(&export->exp_lock);
if (export->exp_conn_cnt >= lustre_msg_get_conn_cnt(req->rq_reqmsg)) {
cfs_spin_unlock(&export->exp_lock);
- CDEBUG(D_RPCTRACE, "%s: %s already connected at higher "
- "conn_cnt: %d > %d\n",
+ CDEBUG(D_RPCTRACE, "%s: %s already connected at greater "
+ "or equal conn_cnt: %d >= %d\n",
cluuid.uuid, libcfs_nid2str(req->rq_peer.nid),
export->exp_conn_cnt,
lustre_msg_get_conn_cnt(req->rq_reqmsg));
&export->exp_nid_hash);
}
- if (target->obd_recovering && !export->exp_in_recovery) {
+ if (target->obd_recovering && !export->exp_in_recovery && !lw_client) {
int has_transno;
__u64 transno = data->ocd_transno;
}
/* Tell the client we're in recovery, when client is involved in it. */
- if (target->obd_recovering)
+ if (target->obd_recovering && !lw_client)
lustre_msg_add_op_flags(req->rq_repmsg, MSG_CONNECT_RECOVERING);
tmp = req_capsule_client_get(&req->rq_pill, &RMF_CONN);
}
cfs_spin_lock(&export->exp_lock);
- if (export->exp_imp_reverse != NULL) {
+ if (export->exp_imp_reverse != NULL)
/* destroyed import can be still referenced in ctxt */
- obd_set_info_async(req->rq_svc_thread->t_env, export,
- sizeof(KEY_REVIMP_UPD), KEY_REVIMP_UPD,
- 0, NULL, NULL);
tmp_imp = export->exp_imp_reverse;
- }
export->exp_imp_reverse = revimp;
cfs_spin_unlock(&export->exp_lock);
* ptlrpc_handle_server_req_in->lustre_unpack_msg() */
revimp->imp_msg_magic = req->rq_reqmsg->lm_magic;
- if ((export->exp_connect_flags & OBD_CONNECT_AT) &&
- (revimp->imp_msg_magic != LUSTRE_MSG_MAGIC_V1))
- revimp->imp_msghdr_flags |= MSGHDR_AT_SUPPORT;
- else
- revimp->imp_msghdr_flags &= ~MSGHDR_AT_SUPPORT;
+ if ((data->ocd_connect_flags & OBD_CONNECT_AT) &&
+ (revimp->imp_msg_magic != LUSTRE_MSG_MAGIC_V1))
+ revimp->imp_msghdr_flags |= MSGHDR_AT_SUPPORT;
+ else
+ revimp->imp_msghdr_flags &= ~MSGHDR_AT_SUPPORT;
- if ((export->exp_connect_flags & OBD_CONNECT_FULL20) &&
+ if ((data->ocd_connect_flags & OBD_CONNECT_FULL20) &&
(revimp->imp_msg_magic != LUSTRE_MSG_MAGIC_V1))
revimp->imp_msghdr_flags |= MSGHDR_CKSUM_INCOMPAT18;
else
req->rq_status = rc;
RETURN(rc);
}
+EXPORT_SYMBOL(target_handle_connect);
int target_handle_disconnect(struct ptlrpc_request *req)
{
RETURN(0);
}
+EXPORT_SYMBOL(target_handle_disconnect);
void target_destroy_export(struct obd_export *exp)
{
LASSERT_ATOMIC_ZERO(&exp->exp_cb_count);
LASSERT_ATOMIC_ZERO(&exp->exp_replay_count);
}
+EXPORT_SYMBOL(target_destroy_export);
/*
* Recovery functions
#ifdef __KERNEL__
static void target_finish_recovery(struct obd_device *obd)
{
- time_t elapsed_time = max_t(time_t, 1, cfs_time_current_sec() -
- obd->obd_recovery_start);
ENTRY;
- LCONSOLE_INFO("%s: Recovery over after %d:%.02d, of %d clients "
- "%d recovered and %d %s evicted.\n", obd->obd_name,
- (int)elapsed_time / 60, (int)elapsed_time % 60,
- obd->obd_max_recoverable_clients,
- cfs_atomic_read(&obd->obd_connected_clients),
- obd->obd_stale_clients,
- obd->obd_stale_clients == 1 ? "was" : "were");
+ /* only log a recovery message when recovery has occurred */
+ if (obd->obd_recovery_start) {
+ time_t elapsed_time = max_t(time_t, 1, cfs_time_current_sec() -
+ obd->obd_recovery_start);
+ LCONSOLE_INFO("%s: Recovery over after %d:%.02d, of %d clients "
+ "%d recovered and %d %s evicted.\n", obd->obd_name,
+ (int)elapsed_time / 60, (int)elapsed_time % 60,
+ obd->obd_max_recoverable_clients,
+ cfs_atomic_read(&obd->obd_connected_clients),
+ obd->obd_stale_clients,
+ obd->obd_stale_clients == 1 ? "was" : "were");
+ }
ldlm_reprocess_all_ns(obd->obd_namespace);
cfs_spin_lock(&obd->obd_recovery_task_lock);
EXIT;
}
+EXPORT_SYMBOL(target_cleanup_recovery);
/* obd_recovery_task_lock should be held */
void target_cancel_recovery_timer(struct obd_device *obd)
CDEBUG(D_HA, "%s: cancel recovery timer\n", obd->obd_name);
cfs_timer_disarm(&obd->obd_recovery_timer);
}
+EXPORT_SYMBOL(target_cancel_recovery_timer);
static void target_start_recovery_timer(struct obd_device *obd)
{
LASSERT(obt->obt_magic == OBT_MAGIC);
lsi = s2lsi(obt->obt_sb);
- if (!(lsi->lsi_flags | LSI_IR_CAPABLE))
+ if (!(lsi->lsi_flags | LDD_F_IR_CAPABLE))
service_time += 2 * (CONNECTION_SWITCH_MAX +
CONNECTION_SWITCH_INC);
if (service_time > obd->obd_recovery_timeout && !new_client)
to = max((int)at_est2timeout(
at_get(&svcpt->scp_at_estimate)),
(int)lustre_msg_get_timeout(req->rq_reqmsg));
- /* Add net_latency (see ptlrpc_replay_req) */
- to += lustre_msg_get_service_time(req->rq_reqmsg);
+ /* Add 2 net_latency, one for balance rq_deadline
+ * (see ptl_send_rpc), one for resend the req to server,
+ * Note: client will pack net_latency in replay req
+ * (see ptlrpc_replay_req) */
+ to += 2 * lustre_msg_get_service_time(req->rq_reqmsg);
}
extend_recovery_timer(class_exp2obd(req->rq_export), to, true);
}
*/
CDEBUG(D_INFO, "3: final stage - process recovery completion pings\n");
/** Update server last boot epoch */
- lut_boot_epoch_update(lut);
+ tgt_boot_epoch_update(lut);
/* We drop recoverying flag to forward all new requests
* to regular mds_handle() since now */
cfs_spin_lock(&obd->obd_dev_lock);
cfs_wait_for_completion(&trd->trd_finishing);
}
}
+EXPORT_SYMBOL(target_stop_recovery_thread);
void target_recovery_fini(struct obd_device *obd)
{
struct obd_device *obd = lut->lut_obd;
if (obd->obd_max_recoverable_clients == 0) {
/** Update server last boot epoch */
- lut_boot_epoch_update(lut);
+ tgt_boot_epoch_update(lut);
return;
}
cfs_waitq_signal(&obd->obd_next_transno_waitq);
RETURN(0);
}
+EXPORT_SYMBOL(target_queue_recovery_request);
int target_handle_ping(struct ptlrpc_request *req)
{
obd_ping(req->rq_svc_thread->t_env, req->rq_export);
return req_capsule_server_pack(&req->rq_pill);
}
+EXPORT_SYMBOL(target_handle_ping);
void target_committed_to_req(struct ptlrpc_request *req)
{
RETURN(0);
}
+EXPORT_SYMBOL(target_pack_pool_reply);
int target_send_reply_msg(struct ptlrpc_request *req, int rc, int fail_id)
{
rs->rs_xid = req->rq_xid;
rs->rs_transno = req->rq_transno;
rs->rs_export = exp;
- rs->rs_opc = lustre_msg_get_opc(rs->rs_msg);
+ rs->rs_opc = lustre_msg_get_opc(req->rq_reqmsg);
cfs_spin_lock(&exp->exp_uncommitted_replies_lock);
CDEBUG(D_NET, "rs transno = "LPU64", last committed = "LPU64"\n",
cfs_spin_unlock(&svcpt->scp_rep_lock);
EXIT;
}
-
-int target_handle_qc_callback(struct ptlrpc_request *req)
-{
- struct obd_quotactl *oqctl;
- struct client_obd *cli = &req->rq_export->exp_obd->u.cli;
-
- oqctl = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
- if (oqctl == NULL) {
- CERROR("Can't unpack obd_quotactl\n");
- RETURN(-EPROTO);
- }
-
- cli->cl_qchk_stat = oqctl->qc_stat;
-
- return 0;
-}
-
-#ifdef HAVE_QUOTA_SUPPORT
-int target_handle_dqacq_callback(struct ptlrpc_request *req)
-{
-#ifdef __KERNEL__
- struct obd_device *obd = req->rq_export->exp_obd;
- struct obd_device *master_obd = NULL, *lov_obd = NULL;
- struct obd_device_target *obt;
- struct lustre_quota_ctxt *qctxt;
- struct qunit_data *qdata = NULL;
- int rc = 0;
- ENTRY;
-
- if (OBD_FAIL_CHECK(OBD_FAIL_MDS_DROP_QUOTA_REQ))
- RETURN(rc);
-
- rc = req_capsule_server_pack(&req->rq_pill);
- if (rc) {
- CERROR("packing reply failed!: rc = %d\n", rc);
- RETURN(rc);
- }
-
- LASSERT(req->rq_export);
-
- qdata = quota_get_qdata(req, QUOTA_REQUEST, QUOTA_EXPORT);
- if (IS_ERR(qdata)) {
- rc = PTR_ERR(qdata);
- CDEBUG(D_ERROR, "Can't unpack qunit_data(rc: %d)\n", rc);
- req->rq_status = rc;
- GOTO(out, rc);
- }
-
- /* we use the observer */
- if (obd_pin_observer(obd, &lov_obd) ||
- obd_pin_observer(lov_obd, &master_obd)) {
- CERROR("Can't find the observer, it is recovering\n");
- req->rq_status = -EAGAIN;
- GOTO(out, rc);
- }
-
- obt = &master_obd->u.obt;
- qctxt = &obt->obt_qctxt;
-
- if (!qctxt->lqc_setup || !qctxt->lqc_valid) {
- /* quota_type has not been processed yet, return EAGAIN
- * until we know whether or not quotas are supposed to
- * be enabled */
- CDEBUG(D_QUOTA, "quota_type not processed yet, return "
- "-EAGAIN\n");
- req->rq_status = -EAGAIN;
- GOTO(out, rc);
- }
-
- cfs_down_read(&obt->obt_rwsem);
- if (qctxt->lqc_lqs_hash == NULL) {
- cfs_up_read(&obt->obt_rwsem);
- /* quota_type has not been processed yet, return EAGAIN
- * until we know whether or not quotas are supposed to
- * be enabled */
- CDEBUG(D_QUOTA, "quota_ctxt is not ready yet, return "
- "-EAGAIN\n");
- req->rq_status = -EAGAIN;
- GOTO(out, rc);
- }
-
- LASSERT(qctxt->lqc_handler);
- rc = qctxt->lqc_handler(master_obd, qdata,
- lustre_msg_get_opc(req->rq_reqmsg));
- cfs_up_read(&obt->obt_rwsem);
- if (rc && rc != -EDQUOT)
- CDEBUG(rc == -EBUSY ? D_QUOTA : D_ERROR,
- "dqacq/dqrel failed! (rc:%d)\n", rc);
- req->rq_status = rc;
-
- rc = quota_copy_qdata(req, qdata, QUOTA_REPLY, QUOTA_EXPORT);
- if (rc < 0) {
- CERROR("Can't pack qunit_data(rc: %d)\n", rc);
- GOTO(out, rc);
- }
-
- /* Block the quota req. b=14840 */
- OBD_FAIL_TIMEOUT(OBD_FAIL_MDS_BLOCK_QUOTA_REQ, obd_timeout);
- EXIT;
-
-out:
- if (master_obd)
- obd_unpin_observer(lov_obd);
- if (lov_obd)
- obd_unpin_observer(obd);
-
- rc = ptlrpc_reply(req);
- return rc;
-#else
- return 0;
-#endif /* !__KERNEL__ */
-}
-#endif /* HAVE_QUOTA_SUPPORT */
+EXPORT_SYMBOL(target_send_reply);
ldlm_mode_t lck_compat_array[] = {
[LCK_EX] LCK_COMPAT_EX,
git://git.whamcloud.com / fs / lustre-release.git / blobdiff