*rootfid = body->fid1;
CDEBUG(D_NET,
- "root fid="DFID", last_committed="LPU64", last_xid="LPU64"\n",
+ "root fid="DFID", last_committed="LPU64"\n",
PFID(rootfid),
- lustre_msg_get_last_committed(req->rq_repmsg),
- lustre_msg_get_last_xid(req->rq_repmsg));
+ lustre_msg_get_last_committed(req->rq_repmsg));
EXIT;
out:
ptlrpc_req_finished(req);
RETURN(0);
}
-int mdc_getattr(struct obd_export *exp, const struct lu_fid *fid,
- struct obd_capa *oc, obd_valid valid, int ea_size,
+int mdc_getattr(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request)
{
struct ptlrpc_request *req;
if (req == NULL)
RETURN(-ENOMEM);
- mdc_set_capa_size(req, &RMF_CAPA1, oc);
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GETATTR);
if (rc) {
RETURN(rc);
}
- /* MDS_BFLAG_EXT_FLAGS: request "new" flags(bug 9486) */
- mdc_pack_body(req, fid, oc, valid, ea_size, -1, MDS_BFLAG_EXT_FLAGS);
+ mdc_pack_body(req, &op_data->op_fid1, op_data->op_capa1,
+ op_data->op_valid, op_data->op_mode, -1, 0);
- req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, ea_size);
- if (valid & OBD_MD_FLRMTPERM) {
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
+ op_data->op_mode);
+ if (op_data->op_valid & OBD_MD_FLRMTPERM) {
LASSERT(client_is_remote(exp));
req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER,
sizeof(struct mdt_remote_perm));
RETURN(rc);
}
-int mdc_getattr_name(struct obd_export *exp, const struct lu_fid *fid,
- struct obd_capa *oc, const char *filename, int namelen,
- obd_valid valid, int ea_size, __u32 suppgid,
+int mdc_getattr_name(struct obd_export *exp, struct md_op_data *op_data,
struct ptlrpc_request **request)
{
struct ptlrpc_request *req;
if (req == NULL)
RETURN(-ENOMEM);
- mdc_set_capa_size(req, &RMF_CAPA1, oc);
- req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, namelen);
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ op_data->op_namelen + 1);
rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GETATTR_NAME);
if (rc) {
RETURN(rc);
}
- /* MDS_BFLAG_EXT_FLAGS: request "new" flags(bug 9486) */
- mdc_pack_body(req, fid, oc, valid, ea_size, suppgid,
- MDS_BFLAG_EXT_FLAGS);
+ mdc_pack_body(req, &op_data->op_fid1, op_data->op_capa1,
+ op_data->op_valid, op_data->op_mode,
+ op_data->op_suppgids[0], 0);
- if (filename) {
+ if (op_data->op_name) {
char *name = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
- LASSERT(strnlen(filename, namelen) == namelen - 1);
- memcpy(name, filename, namelen);
+ LASSERT(strnlen(op_data->op_name, op_data->op_namelen) ==
+ op_data->op_namelen);
+ memcpy(name, op_data->op_name, op_data->op_namelen);
}
- req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, ea_size);
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
+ op_data->op_mode);
ptlrpc_request_set_replen(req);
rc = mdc_getattr_common(exp, req);
* cfs_curproc_fs{u,g}id() should replace
* current->fs{u,g}id for portability.
*/
- rec->sx_fsuid = current->fsuid;
- rec->sx_fsgid = current->fsgid;
+ rec->sx_fsuid = cfs_curproc_fsuid();
+ rec->sx_fsgid = cfs_curproc_fsgid();
rec->sx_cap = cfs_curproc_cap_pack();
rec->sx_suppgid1 = suppgid;
rec->sx_suppgid2 = -1;
close_req = mod->mod_close_req;
if (close_req != NULL) {
__u32 opc = lustre_msg_get_opc(close_req->rq_reqmsg);
- struct mdt_epoch *epoch;
+ struct mdt_ioepoch *epoch;
LASSERT(opc == MDS_CLOSE || opc == MDS_DONE_WRITING);
epoch = req_capsule_client_get(&close_req->rq_pill,
* freed after that when md_open_data::mod_och will put the reference.
*/
+ /**
+ * Do not let open request to disappear as it still may be needed
+ * for close rpc to happen (it may happen on evict only, otherwise
+ * ptlrpc_request::rq_replay does not let mdc_commit_open() to be
+ * called), just mark this rpc as committed to distinguish these 2
+ * cases, see mdc_close() for details. The open request reference will
+ * be put along with freeing \var mod.
+ */
+ ptlrpc_request_addref(req);
+ cfs_spin_lock(&req->rq_lock);
+ req->rq_committed = 1;
+ cfs_spin_unlock(&req->rq_lock);
req->rq_cb_data = NULL;
- mod->mod_open_req = NULL;
obd_mod_put(mod);
}
RETURN(0);
}
- spin_lock(&open_req->rq_lock);
+ /**
+ * Take a reference on \var mod, to be freed on mdc_close().
+ * It protects \var mod from being freed on eviction (commit
+ * callback is called despite rq_replay flag).
+ * Another reference for \var och.
+ */
+ obd_mod_get(mod);
+ obd_mod_get(mod);
+
+ cfs_spin_lock(&open_req->rq_lock);
och->och_mod = mod;
mod->mod_och = och;
- obd_mod_get(mod);
mod->mod_open_req = open_req;
open_req->rq_cb_data = mod;
open_req->rq_commit_cb = mdc_commit_open;
- spin_unlock(&open_req->rq_lock);
+ cfs_spin_unlock(&open_req->rq_lock);
}
rec->cr_fid2 = body->fid1;
RETURN(0);
}
+/* Prepares the request for the replay by the given reply */
+static void mdc_close_handle_reply(struct ptlrpc_request *req,
+ struct md_op_data *op_data, int rc) {
+ struct mdt_body *repbody;
+ struct mdt_ioepoch *epoch;
+
+ if (req && rc == -EAGAIN) {
+ repbody = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+ epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH);
+
+ epoch->flags |= MF_SOM_AU;
+ if (repbody->valid & OBD_MD_FLGETATTRLOCK)
+ op_data->op_flags |= MF_GETATTR_LOCK;
+ }
+}
+
int mdc_close(struct obd_export *exp, struct md_op_data *op_data,
struct md_open_data *mod, struct ptlrpc_request **request)
{
/* Ensure that this close's handle is fixed up during replay. */
if (likely(mod != NULL)) {
- LASSERTF(mod->mod_open_req->rq_type != LI_POISON,
+ LASSERTF(mod->mod_open_req != NULL &&
+ mod->mod_open_req->rq_type != LI_POISON,
"POISONED open %p!\n", mod->mod_open_req);
mod->mod_close_req = req;
- obd_mod_get(mod);
DEBUG_REQ(D_HA, mod->mod_open_req, "matched open");
/* We no longer want to preserve this open for replay even
* though the open was committed. b=3632, b=3633 */
- spin_lock(&mod->mod_open_req->rq_lock);
+ cfs_spin_lock(&mod->mod_open_req->rq_lock);
mod->mod_open_req->rq_replay = 0;
- spin_unlock(&mod->mod_open_req->rq_lock);
+ cfs_spin_unlock(&mod->mod_open_req->rq_lock);
} else {
CDEBUG(D_HA, "couldn't find open req; expecting close error\n");
}
* server failed before close was sent. Let's check if mod
* exists and return no error in that case
*/
- if (mod && (mod->mod_open_req == NULL))
- rc = 0;
+ if (mod) {
+ LASSERT(mod->mod_open_req != NULL);
+ if (mod->mod_open_req->rq_committed)
+ rc = 0;
+ }
}
if (mod) {
obd_mod_put(mod);
}
*request = req;
+ mdc_close_handle_reply(req, op_data, rc);
RETURN(rc);
}
}
if (mod != NULL) {
- LASSERTF(mod->mod_open_req->rq_type != LI_POISON,
+ LASSERTF(mod->mod_open_req != NULL &&
+ mod->mod_open_req->rq_type != LI_POISON,
"POISONED setattr %p!\n", mod->mod_open_req);
mod->mod_close_req = req;
- obd_mod_get(mod);
DEBUG_REQ(D_HA, mod->mod_open_req, "matched setattr");
/* We no longer want to preserve this setattr for replay even
* though the open was committed. b=3632, b=3633 */
- spin_lock(&mod->mod_open_req->rq_lock);
+ cfs_spin_lock(&mod->mod_open_req->rq_lock);
mod->mod_open_req->rq_replay = 0;
- spin_unlock(&mod->mod_open_req->rq_lock);
+ cfs_spin_unlock(&mod->mod_open_req->rq_lock);
}
mdc_close_pack(req, op_data);
* committed and server failed before close was sent.
* Let's check if mod exists and return no error in that case
*/
- if (mod && (mod->mod_open_req == NULL))
- rc = 0;
+ if (mod) {
+ LASSERT(mod->mod_open_req != NULL);
+ if (mod->mod_open_req->rq_committed)
+ rc = 0;
+ }
}
if (mod) {
* thus DW req does not keep a reference on mod anymore. */
obd_mod_put(mod);
}
+
+ mdc_close_handle_reply(req, op_data, rc);
ptlrpc_req_finished(req);
RETURN(rc);
}
RETURN(0);
}
+static int mdc_statfs(struct obd_device *obd, struct obd_statfs *osfs,
+ __u64 max_age, __u32 flags)
+{
+ struct ptlrpc_request *req;
+ struct obd_statfs *msfs;
+ struct obd_import *imp = NULL;
+ int rc;
+ ENTRY;
+
+ /*
+ * Since the request might also come from lprocfs, so we need
+ * sync this with client_disconnect_export Bug15684
+ */
+ cfs_down_read(&obd->u.cli.cl_sem);
+ if (obd->u.cli.cl_import)
+ imp = class_import_get(obd->u.cli.cl_import);
+ cfs_up_read(&obd->u.cli.cl_sem);
+ if (!imp)
+ RETURN(-ENODEV);
+
+ req = ptlrpc_request_alloc_pack(imp, &RQF_MDS_STATFS,
+ LUSTRE_MDS_VERSION, MDS_STATFS);
+ if (req == NULL)
+ GOTO(output, rc = -ENOMEM);
+
+ ptlrpc_request_set_replen(req);
+
+ if (flags & OBD_STATFS_NODELAY) {
+ /* procfs requests not want stay in wait for avoid deadlock */
+ req->rq_no_resend = 1;
+ req->rq_no_delay = 1;
+ }
+
+ rc = ptlrpc_queue_wait(req);
+ if (rc) {
+ /* check connection error first */
+ if (imp->imp_connect_error)
+ rc = imp->imp_connect_error;
+ GOTO(out, rc);
+ }
+
+ msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS);
+ if (msfs == NULL)
+ GOTO(out, rc = -EPROTO);
+
+ *osfs = *msfs;
+ EXIT;
+out:
+ ptlrpc_req_finished(req);
+output:
+ class_import_put(imp);
+ return rc;
+}
+
static int mdc_ioc_fid2path(struct obd_export *exp, struct getinfo_fid2path *gf)
{
__u32 keylen, vallen;
RETURN(-EOVERFLOW);
/* Key is KEY_FID2PATH + getinfo_fid2path description */
- keylen = size_round(sizeof(KEY_FID2PATH)) + sizeof(*gf);
+ keylen = cfs_size_round(sizeof(KEY_FID2PATH)) + sizeof(*gf);
OBD_ALLOC(key, keylen);
if (key == NULL)
RETURN(-ENOMEM);
memcpy(key, KEY_FID2PATH, sizeof(KEY_FID2PATH));
- memcpy(key + size_round(sizeof(KEY_FID2PATH)), gf, sizeof(*gf));
+ memcpy(key + cfs_size_round(sizeof(KEY_FID2PATH)), gf, sizeof(*gf));
CDEBUG(D_IOCTL, "path get "DFID" from "LPU64" #%d\n",
PFID(&gf->gf_fid), gf->gf_recno, gf->gf_linkno);
return rc;
}
+static struct kuc_hdr *changelog_kuc_hdr(char *buf, int len, int flags)
+{
+ struct kuc_hdr *lh = (struct kuc_hdr *)buf;
+
+ LASSERT(len <= CR_MAXSIZE);
+
+ lh->kuc_magic = KUC_MAGIC;
+ lh->kuc_transport = KUC_TRANSPORT_CHANGELOG;
+ lh->kuc_flags = flags;
+ lh->kuc_msgtype = CL_RECORD;
+ lh->kuc_msglen = len;
+ return lh;
+}
+
+#define D_CHANGELOG 0
+
+struct changelog_show {
+ __u64 cs_startrec;
+ __u32 cs_flags;
+ cfs_file_t *cs_fp;
+ char *cs_buf;
+ struct obd_device *cs_obd;
+};
+
+static int changelog_show_cb(struct llog_handle *llh, struct llog_rec_hdr *hdr,
+ void *data)
+{
+ struct changelog_show *cs = data;
+ struct llog_changelog_rec *rec = (struct llog_changelog_rec *)hdr;
+ struct kuc_hdr *lh;
+ int len, rc;
+ ENTRY;
+
+ if ((rec->cr_hdr.lrh_type != CHANGELOG_REC) ||
+ (rec->cr.cr_type >= CL_LAST)) {
+ CERROR("Not a changelog rec %d/%d\n", rec->cr_hdr.lrh_type,
+ rec->cr.cr_type);
+ RETURN(-EINVAL);
+ }
+
+ if (rec->cr.cr_index < cs->cs_startrec) {
+ /* Skip entries earlier than what we are interested in */
+ CDEBUG(D_CHANGELOG, "rec="LPU64" start="LPU64"\n",
+ rec->cr.cr_index, cs->cs_startrec);
+ RETURN(0);
+ }
+
+ CDEBUG(D_CHANGELOG, LPU64" %02d%-5s "LPU64" 0x%x t="DFID" p="DFID
+ " %.*s\n", rec->cr.cr_index, rec->cr.cr_type,
+ changelog_type2str(rec->cr.cr_type), rec->cr.cr_time,
+ rec->cr.cr_flags & CLF_FLAGMASK,
+ PFID(&rec->cr.cr_tfid), PFID(&rec->cr.cr_pfid),
+ rec->cr.cr_namelen, rec->cr.cr_name);
+
+ len = sizeof(*lh) + sizeof(rec->cr) + rec->cr.cr_namelen;
+
+ /* Set up the message */
+ lh = changelog_kuc_hdr(cs->cs_buf, len, cs->cs_flags);
+ memcpy(lh + 1, &rec->cr, len - sizeof(*lh));
+
+ rc = libcfs_kkuc_msg_put(cs->cs_fp, lh);
+ CDEBUG(D_CHANGELOG, "kucmsg fp %p len %d rc %d\n", cs->cs_fp, len,rc);
+
+ RETURN(rc);
+}
+
+static int mdc_changelog_send_thread(void *csdata)
+{
+ struct changelog_show *cs = csdata;
+ struct llog_ctxt *ctxt = NULL;
+ struct llog_handle *llh = NULL;
+ struct kuc_hdr *kuch;
+ int rc;
+
+ CDEBUG(D_CHANGELOG, "changelog to fp=%p start "LPU64"\n",
+ cs->cs_fp, cs->cs_startrec);
+
+ OBD_ALLOC(cs->cs_buf, CR_MAXSIZE);
+ if (cs->cs_buf == NULL)
+ GOTO(out, rc = -ENOMEM);
+
+ /* Set up the remote catalog handle */
+ ctxt = llog_get_context(cs->cs_obd, LLOG_CHANGELOG_REPL_CTXT);
+ if (ctxt == NULL)
+ GOTO(out, rc = -ENOENT);
+ rc = llog_create(ctxt, &llh, NULL, CHANGELOG_CATALOG);
+ if (rc) {
+ CERROR("llog_create() failed %d\n", rc);
+ GOTO(out, rc);
+ }
+ rc = llog_init_handle(llh, LLOG_F_IS_CAT, NULL);
+ if (rc) {
+ CERROR("llog_init_handle failed %d\n", rc);
+ GOTO(out, rc);
+ }
+
+ /* We need the pipe fd open, so llog_process can't daemonize */
+ rc = llog_cat_process_flags(llh, changelog_show_cb, cs,
+ LLOG_FLAG_NODEAMON, 0, 0);
+
+ /* Send EOF no matter what our result */
+ if ((kuch = changelog_kuc_hdr(cs->cs_buf, sizeof(*kuch),
+ cs->cs_flags))) {
+ kuch->kuc_msgtype = CL_EOF;
+ libcfs_kkuc_msg_put(cs->cs_fp, kuch);
+ }
+
+out:
+ cfs_put_file(cs->cs_fp);
+ if (llh)
+ llog_cat_put(llh);
+ if (ctxt)
+ llog_ctxt_put(ctxt);
+ if (cs->cs_buf)
+ OBD_FREE(cs->cs_buf, CR_MAXSIZE);
+ OBD_FREE_PTR(cs);
+ return rc;
+}
+
+static int mdc_ioc_changelog_send(struct obd_device *obd,
+ struct ioc_changelog *icc)
+{
+ struct changelog_show *cs;
+ int rc;
+
+ /* Freed in mdc_changelog_send_thread */
+ OBD_ALLOC_PTR(cs);
+ if (!cs)
+ return -ENOMEM;
+
+ cs->cs_obd = obd;
+ cs->cs_startrec = icc->icc_recno;
+ /* matching cfs_put_file in mdc_changelog_send_thread */
+ cs->cs_fp = cfs_get_fd(icc->icc_id);
+ cs->cs_flags = icc->icc_flags;
+
+ /* New thread because we should return to user app before
+ writing into our pipe */
+ rc = cfs_kernel_thread(mdc_changelog_send_thread, cs,
+ CLONE_VM | CLONE_FILES);
+ if (rc >= 0) {
+ CDEBUG(D_CHANGELOG, "start changelog thread: %d\n", rc);
+ return 0;
+ }
+
+ CERROR("Failed to start changelog thread: %d\n", rc);
+ OBD_FREE_PTR(cs);
+ return rc;
+}
+
+static int mdc_ioc_hsm_ct_start(struct obd_export *exp,
+ struct lustre_kernelcomm *lk);
+
static int mdc_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
void *karg, void *uarg)
{
int rc;
ENTRY;
- if (!try_module_get(THIS_MODULE)) {
+ if (!cfs_try_module_get(THIS_MODULE)) {
CERROR("Can't get module. Is it alive?");
return -EINVAL;
}
switch (cmd) {
+ case LL_IOC_HSM_CT_START:
+ rc = mdc_ioc_hsm_ct_start(exp, karg);
+ GOTO(out, rc);
+ case OBD_IOC_CHANGELOG_SEND:
+ rc = mdc_ioc_changelog_send(obd, karg);
+ GOTO(out, rc);
case OBD_IOC_CHANGELOG_CLEAR: {
- struct ioc_changelog_clear *icc = karg;
+ struct ioc_changelog *icc = karg;
struct changelog_setinfo cs =
- {icc->icc_recno, icc->icc_id};
+ {.cs_recno = icc->icc_recno, .cs_id = icc->icc_id};
rc = obd_set_info_async(exp, strlen(KEY_CHANGELOG_CLEAR),
KEY_CHANGELOG_CLEAR, sizeof(cs), &cs,
NULL);
case OBD_IOC_PING_TARGET:
rc = ptlrpc_obd_ping(obd);
GOTO(out, rc);
+ /*
+ * Normally IOC_OBD_STATFS iocontrol is handled by LMV instead of MDC.
+ * But when the cluster is upgraded from 1.8, there'd be no LMV layer
+ * thus we might be called here. Eventually this code should be removed.
+ * bz20731.
+ */
+ case IOC_OBD_STATFS: {
+ struct obd_statfs stat_buf = {0};
+
+ if (*((__u32 *) data->ioc_inlbuf2) != 0)
+ GOTO(out, rc = -ENODEV);
+
+ rc = mdc_statfs(obd, &stat_buf,
+ cfs_time_current_64() - CFS_HZ, 0);
+ if (rc != 0)
+ GOTO(out, rc);
+
+ if (cfs_copy_to_user(data->ioc_pbuf1, &stat_buf,
+ data->ioc_plen1))
+ GOTO(out, rc = -EFAULT);
+ if (cfs_copy_to_user(data->ioc_pbuf2, obd2cli_tgt(obd),
+ data->ioc_plen2))
+ GOTO(out, rc = -EFAULT);
+
+ GOTO(out, rc = 0);
+ }
default:
CERROR("mdc_ioctl(): unrecognised ioctl %#x\n", cmd);
GOTO(out, rc = -ENOTTY);
}
out:
- module_put(THIS_MODULE);
+ cfs_module_put(THIS_MODULE);
return rc;
}
}
}
+static int mdc_ioc_hsm_ct_start(struct obd_export *exp,
+ struct lustre_kernelcomm *lk)
+{
+ int rc = 0;
+
+ if (lk->lk_group != KUC_GRP_HSM) {
+ CERROR("Bad copytool group %d\n", lk->lk_group);
+ return -EINVAL;
+ }
+
+ CDEBUG(D_HSM, "CT start r%d w%d u%d g%d f%#x\n", lk->lk_rfd, lk->lk_wfd,
+ lk->lk_uid, lk->lk_group, lk->lk_flags);
+
+ if (lk->lk_flags & LK_FLG_STOP)
+ rc = libcfs_kkuc_group_rem(lk->lk_uid,lk->lk_group);
+ else {
+ cfs_file_t *fp = cfs_get_fd(lk->lk_wfd);
+ rc = libcfs_kkuc_group_add(fp, lk->lk_uid,lk->lk_group);
+ if (rc && fp)
+ cfs_put_file(fp);
+ }
+
+ /* lk_data is archive number mask */
+ /* TODO: register archive num with mdt so coordinator can choose
+ correct agent. */
+
+ return rc;
+}
+
/**
- * Send a message to any listening copytools, nonblocking
- * @param val LNL message (lnl_hdr + hsm_action_list)
+ * Send a message to any listening copytools
+ * @param val KUC message (kuc_hdr + hsm_action_list)
* @param len total length of message
*/
static int mdc_hsm_copytool_send(int len, void *val)
{
- struct lnl_hdr *lh = (struct lnl_hdr *)val;
+ struct kuc_hdr *lh = (struct kuc_hdr *)val;
struct hsm_action_list *hal = (struct hsm_action_list *)(lh + 1);
int rc;
ENTRY;
(int) (sizeof(*lh) + sizeof(*hal)));
RETURN(-EPROTO);
}
- if (lh->lnl_magic == __swab16(LNL_MAGIC)) {
- lustre_swab_lnlh(lh);
+ if (lh->kuc_magic == __swab16(KUC_MAGIC)) {
+ lustre_swab_kuch(lh);
lustre_swab_hal(hal);
- } else if (lh->lnl_magic != LNL_MAGIC) {
- CERROR("Bad magic %x!=%x\n", lh->lnl_magic, LNL_MAGIC);
+ } else if (lh->kuc_magic != KUC_MAGIC) {
+ CERROR("Bad magic %x!=%x\n", lh->kuc_magic, KUC_MAGIC);
RETURN(-EPROTO);
}
- CDEBUG(D_IOCTL, " Received message mg=%x t=%d m=%d l=%d actions=%d\n",
- lh->lnl_magic, lh->lnl_transport, lh->lnl_msgtype,
- lh->lnl_msglen, hal->hal_count);
+ CDEBUG(D_HSM, " Received message mg=%x t=%d m=%d l=%d actions=%d\n",
+ lh->kuc_magic, lh->kuc_transport, lh->kuc_msgtype,
+ lh->kuc_msglen, hal->hal_count);
/* Broadcast to HSM listeners */
- rc = libcfs_klnl_msg_put(0, LNL_GRP_HSM, lh);
+ rc = libcfs_kkuc_group_put(KUC_GRP_HSM, lh);
RETURN(rc);
}
if (KEY_IS(KEY_INIT_RECOV)) {
if (vallen != sizeof(int))
RETURN(-EINVAL);
- spin_lock(&imp->imp_lock);
+ cfs_spin_lock(&imp->imp_lock);
imp->imp_initial_recov = *(int *)val;
- spin_unlock(&imp->imp_lock);
+ cfs_spin_unlock(&imp->imp_lock);
CDEBUG(D_HA, "%s: set imp_initial_recov = %d\n",
exp->exp_obd->obd_name, imp->imp_initial_recov);
RETURN(0);
if (KEY_IS(KEY_INIT_RECOV_BACKUP)) {
if (vallen != sizeof(int))
RETURN(-EINVAL);
- spin_lock(&imp->imp_lock);
+ cfs_spin_lock(&imp->imp_lock);
imp->imp_initial_recov_bk = *(int *)val;
if (imp->imp_initial_recov_bk)
imp->imp_initial_recov = 1;
- spin_unlock(&imp->imp_lock);
+ cfs_spin_unlock(&imp->imp_lock);
CDEBUG(D_HA, "%s: set imp_initial_recov_bk = %d\n",
exp->exp_obd->obd_name, imp->imp_initial_recov_bk);
RETURN(0);
if (vallen != sizeof(int))
RETURN(-EINVAL);
- spin_lock(&imp->imp_lock);
+ cfs_spin_lock(&imp->imp_lock);
if (*((int *)val)) {
imp->imp_connect_flags_orig |= OBD_CONNECT_RDONLY;
imp->imp_connect_data.ocd_connect_flags |= OBD_CONNECT_RDONLY;
imp->imp_connect_flags_orig &= ~OBD_CONNECT_RDONLY;
imp->imp_connect_data.ocd_connect_flags &= ~OBD_CONNECT_RDONLY;
}
- spin_unlock(&imp->imp_lock);
+ cfs_spin_unlock(&imp->imp_lock);
- rc = target_set_info_rpc(imp, MDS_SET_INFO,
- keylen, key, vallen, val, set);
+ rc = do_set_info_async(imp, MDS_SET_INFO, LUSTRE_MDS_VERSION,
+ keylen, key, vallen, val, set);
RETURN(rc);
}
if (KEY_IS(KEY_SPTLRPC_CONF)) {
}
if (KEY_IS(KEY_MDS_CONN)) {
/* mds-mds import */
- spin_lock(&imp->imp_lock);
+ cfs_spin_lock(&imp->imp_lock);
imp->imp_server_timeout = 1;
- spin_unlock(&imp->imp_lock);
+ cfs_spin_unlock(&imp->imp_lock);
imp->imp_client->cli_request_portal = MDS_MDS_PORTAL;
CDEBUG(D_OTHER, "%s: timeout / 2\n", exp->exp_obd->obd_name);
RETURN(0);
}
if (KEY_IS(KEY_CHANGELOG_CLEAR)) {
- rc = target_set_info_rpc(imp, MDS_SET_INFO,
- keylen, key, vallen, val, set);
+ rc = do_set_info_async(imp, MDS_SET_INFO, LUSTRE_MDS_VERSION,
+ keylen, key, vallen, val, set);
RETURN(rc);
}
if (KEY_IS(KEY_HSM_COPYTOOL_SEND)) {
RETURN(rc);
}
-static int mdc_statfs(struct obd_device *obd, struct obd_statfs *osfs,
- __u64 max_age, __u32 flags)
-{
- struct ptlrpc_request *req;
- struct obd_statfs *msfs;
- struct obd_import *imp = NULL;
- int rc;
- ENTRY;
-
-
- /*Since the request might also come from lprocfs, so we need
- *sync this with client_disconnect_export Bug15684*/
- down_read(&obd->u.cli.cl_sem);
- if (obd->u.cli.cl_import)
- imp = class_import_get(obd->u.cli.cl_import);
- up_read(&obd->u.cli.cl_sem);
- if (!imp)
- RETURN(-ENODEV);
-
- req = ptlrpc_request_alloc_pack(imp, &RQF_MDS_STATFS,
- LUSTRE_MDS_VERSION, MDS_STATFS);
- if (req == NULL)
- GOTO(output, rc = -ENOMEM);
-
- ptlrpc_request_set_replen(req);
-
- if (flags & OBD_STATFS_NODELAY) {
- /* procfs requests not want stay in wait for avoid deadlock */
- req->rq_no_resend = 1;
- req->rq_no_delay = 1;
- }
-
- rc = ptlrpc_queue_wait(req);
- if (rc) {
- /* check connection error first */
- if (imp->imp_connect_error)
- rc = imp->imp_connect_error;
- GOTO(out, rc);
- }
-
- msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS);
- if (msfs == NULL)
- GOTO(out, rc = -EPROTO);
-
- *osfs = *msfs;
- EXIT;
-out:
- ptlrpc_req_finished(req);
-output:
- class_import_put(imp);
- return rc;
-}
-
static int mdc_pin(struct obd_export *exp, const struct lu_fid *fid,
struct obd_capa *oc, struct obd_client_handle *handle,
int flags)
CERROR("failed to setup llogging subsystems\n");
}
- /* ignore errors */
- libcfs_klnl_start(LNL_TRANSPORT_HSM);
- libcfs_klnl_start(LNL_TRANSPORT_CHANGELOG);
-
RETURN(rc);
err_close_lock:
switch (stage) {
case OBD_CLEANUP_EARLY:
+ break;
case OBD_CLEANUP_EXPORTS:
+ /* Failsafe, ok if racy */
+ if (obd->obd_type->typ_refcnt <= 1)
+ libcfs_kkuc_group_rem(0, KUC_GRP_HSM);
+
/* If we set up but never connected, the
client import will not have been cleaned. */
if (obd->u.cli.cl_import) {
struct obd_import *imp;
- down_write(&obd->u.cli.cl_sem);
+ cfs_down_write(&obd->u.cli.cl_sem);
imp = obd->u.cli.cl_import;
CERROR("client import never connected\n");
ptlrpc_invalidate_import(imp);
class_destroy_import(imp);
- up_write(&obd->u.cli.cl_sem);
+ cfs_up_write(&obd->u.cli.cl_sem);
obd->u.cli.cl_import = NULL;
}
rc = obd_llog_finish(obd, 0);
{
struct client_obd *cli = &obd->u.cli;
- libcfs_klnl_stop(LNL_TRANSPORT_HSM, LNL_GRP_HSM);
- libcfs_klnl_stop(LNL_TRANSPORT_CHANGELOG, 0);
-
OBD_FREE(cli->cl_rpc_lock, sizeof (*cli->cl_rpc_lock));
OBD_FREE(cli->cl_setattr_lock, sizeof (*cli->cl_setattr_lock));
OBD_FREE(cli->cl_close_lock, sizeof (*cli->cl_close_lock));
/* mds-mds import features */
if (data && (data->ocd_connect_flags & OBD_CONNECT_MDS_MDS)) {
- spin_lock(&imp->imp_lock);
+ cfs_spin_lock(&imp->imp_lock);
imp->imp_server_timeout = 1;
- spin_unlock(&imp->imp_lock);
+ cfs_spin_unlock(&imp->imp_lock);
imp->imp_client->cli_request_portal = MDS_MDS_PORTAL;
CDEBUG(D_OTHER, "%s: Set 'mds' portal and timeout\n",
obd->obd_name);
struct lprocfs_static_vars lvars = { 0 };
lprocfs_mdc_init_vars(&lvars);
- request_module("lquota");
+ cfs_request_module("lquota");
quota_interface = PORTAL_SYMBOL_GET(mdc_quota_interface);
init_obd_quota_ops(quota_interface, &mdc_obd_ops);