int slc_fcmh_ctor(struct fidc_membh *f, __unusedx int flags) { struct fcmh_cli_info *fci; struct sl_resource *res; struct sl_site *s; sl_siteid_t siteid; int i; fci = fcmh_get_pri(f); slc_fcmh_refresh_age(f); INIT_PSC_LISTENTRY(&fci->fci_lentry); siteid = FID_GET_SITEID(fcmh_2_fid(f)); psc_assert(f->fcmh_flags & FCMH_INITING); if (fcmh_2_fid(f) != SLFID_ROOT && siteid != msl_rmc_resm->resm_siteid) { s = libsl_siteid2site(siteid); if (s == NULL) { psclog_errorx("fid "SLPRI_FID" has " "invalid site ID %d", fcmh_2_fid(f), siteid); return (ESTALE); } SITE_FOREACH_RES(s, res, i) if (res->res_type == SLREST_MDS) { fci->fci_resm = psc_dynarray_getpos( &res->res_members, 0); return (0); } psclog_errorx("fid "SLPRI_FID" has invalid site ID %d", fcmh_2_fid(f), siteid); return (ESTALE); }
/* * Handle a request for MDS from another MDS. */ int slm_rmm_handler(struct pscrpc_request *rq) { int rc; rq->rq_status = SL_EXP_REGISTER_RESM(rq->rq_export, slm_getmcsvcx(_resm, rq->rq_export)); if (rq->rq_status) return (pscrpc_error(rq)); switch (rq->rq_reqmsg->opc) { case SRMT_CONNECT: rc = slrpc_handle_connect(rq, SRMM_MAGIC, SRMM_VERSION, SLCONNT_MDS); break; case SRMT_BATCH_RP: rc = sl_handle_batchrp(rq); break; case SRMT_NAMESPACE_UPDATE: rc = slm_rmm_handle_namespace_update(rq); break; case SRMT_NAMESPACE_FORWARD: rc = slm_rmm_handle_namespace_forward(rq); break; default: psclog_errorx("unexpected opcode %d", rq->rq_reqmsg->opc); rq->rq_status = -PFLERR_NOSYS; return (pscrpc_error(rq)); } slrpc_rep_out(rq); pscrpc_target_send_reply_msg(rq, rc, 0); return (rc); }
int sli_rmi_setmds(const char *name) { struct slashrpc_cservice *csvc; struct sl_resource *res; // struct sl_resm *old; lnet_nid_t nid; /* XXX kill any old MDS and purge any bmap updates being held */ // slconnthr_unwatch(rmi_resm->resm_csvc); // old = rmi_resm; // sl_csvc_disable(old->resm_csvc); nid = libcfs_str2nid(name); if (nid == LNET_NID_ANY) { res = libsl_str2res(name); if (res == NULL) return (SLERR_RES_UNKNOWN); rmi_resm = psc_dynarray_getpos(&res->res_members, 0); } else rmi_resm = libsl_nid2resm(nid); if (sli_rmi_getcsvc(&csvc)) psclog_errorx("error connecting to MDS"); else { slconnthr_watch(sliconnthr, csvc, CSVCF_PING, NULL, NULL); sl_csvc_decref(csvc); } return (0); }
void pjournal_dump_entry(uint32_t slot, struct psc_journal_enthdr *pje) { union { struct slmds_jent_assign_rep *logentry; struct slmds_jent_bmap_assign *sjba; struct slmds_jent_bmap_repls *sjbr; struct slmds_jent_ino_repls *sjir; struct slmds_jent_namespace *sjnm; struct slmds_jent_bmap_crc *sjbc; struct slmds_jent_bmapseq *sjsq; void *p; } u; int type, nlen, n2len; const char *n, *n2; u.p = PJE_DATA(pje); type = pje->pje_type & ~(_PJE_FLSHFT - 1); printf("%6d: %3x %4"PRIx64" %4"PRIx64" ", slot, type, pje->pje_xid, pje->pje_txg); switch (type) { case MDS_LOG_BMAP_REPLS: printf("fid=%016"PRIx64" bmap_repls", u.sjbr->sjbr_fid); break; case MDS_LOG_BMAP_CRC: printf("fid=%016"PRIx64" bmap_crc", u.sjbc->sjbc_fid); break; case MDS_LOG_BMAP_SEQ: printf("lwm=%"PRIx64" hwm=%"PRIx64, u.sjsq->sjbsq_low_wm, u.sjsq->sjbsq_high_wm); break; case MDS_LOG_INO_REPLS: printf("fid=%016"PRIx64" ino_repls", u.sjir->sjir_fid); break; case MDS_LOG_BMAP_ASSIGN: if (u.logentry->sjar_flags & SLJ_ASSIGN_REP_FREE) printf("bia item=%d", u.logentry->sjar_elem); else { printf("fid=%016"PRIx64" bia flags=%x", u.logentry->sjar_bmap.sjba_fid, u.logentry->sjar_flags); } break; case MDS_LOG_NAMESPACE: printf("fid=%016"PRIx64" ", u.sjnm->sjnm_target_fid); n = u.sjnm->sjnm_name; nlen = u.sjnm->sjnm_namelen; n2len = u.sjnm->sjnm_namelen2; n2 = n + nlen; switch (u.sjnm->sjnm_op) { case NS_OP_RECLAIM: printf("op=reclaim"); break; case NS_OP_CREATE: printf("op=create name=%.*s", nlen, n); break; case NS_OP_MKDIR: printf("op=mkdir name=%.*s", nlen, n); break; case NS_OP_LINK: printf("op=link name=%.*s", nlen, n); break; case NS_OP_SYMLINK: printf("op=symlink name=%.*s", nlen, n); break; case NS_OP_RENAME: printf("op=rename oldname=%.*s newname=%.*s", nlen, n, n2len, n2); break; case NS_OP_UNLINK: printf("op=unlink name=%.*s", nlen, n); break; case NS_OP_RMDIR: printf("op=rmdir name=%.*s", nlen, n); break; case NS_OP_SETSIZE: printf("op=setsize"); break; case NS_OP_SETATTR: printf("op=setattr mask=%#x", u.sjnm->sjnm_mask); break; default: psclog_errorx("op=INVALID (%d)", u.sjnm->sjnm_op); } break; default: psclog_errorx("invalid type"); break; } printf("\n"); }
int sli_rmi_issue_repl_schedwk(struct sli_repl_workrq *w) { struct slashrpc_cservice *csvc = NULL; struct pscrpc_request *rq = NULL; int rc; if (w->srw_op == SLI_REPLWKOP_REPL) { w->srw_pp->rc = w->srw_status; if (psc_atomic32_inc_getnew(&w->srw_bchrp->ndone) < w->srw_bchrp->total) return (0); } rc = sli_rmi_getcsvc(&csvc); if (rc) goto out; if (w->srw_op == SLI_REPLWKOP_PTRUNC) { struct srm_bmap_ptrunc_req *mq; struct srm_bmap_ptrunc_rep *mp; rc = SL_RSX_NEWREQ(csvc, SRMT_BMAP_PTRUNC, rq, mq, mp); if (rc) goto out; mq->bmapno = w->srw_bmapno; mq->bgen = w->srw_bgen; mq->rc = w->srw_status; mq->fg = w->srw_fg; rc = SL_RSX_WAITREP(csvc, rq, mp); if (rc == 0) rc = mp->rc; } else { struct srm_batch_req *mq; struct srm_batch_rep *mp; struct iovec iov; rc = SL_RSX_NEWREQ(csvc, SRMT_BATCH_RP, rq, mq, mp); if (rc) goto out; mq->opc = SRMT_REPL_SCHEDWK; mq->len = w->srw_bchrp->total * sizeof(*w->srw_pp); mq->bid = w->srw_bchrp->id; iov.iov_base = w->srw_bchrp->buf; iov.iov_len = mq->len; rc = slrpc_bulkclient(rq, BULK_GET_SOURCE, SRMI_BULK_PORTAL, &iov, 1); if (rc == 0) rc = SL_RSX_WAITREP(csvc, rq, mp); if (rc == 0) rc = mp->rc; } if (w->srw_status) psclog_errorx("sent error rc=%d", w->srw_status); out: if (rq) pscrpc_req_finished(rq); if (csvc) sl_csvc_decref(csvc); return (rc); }
/* * For the given bmap, change the status of all its replicas marked * "valid" to "invalid" except for the replica specified. * * This is a high-level convenience call provided to easily update * status after an ION has received some new I/O, which would make all * other existing copies of the bmap on any other replicas old. * @b: the bmap. * @iosidx: the index of the only ION resource in the inode replica * table that should be marked "valid". * * Note: All callers must journal log these bmap replica changes * themselves. In addition, they must log any changes to the inode * _before_ the bmap changes. Otherwise, we could end up actually * having bmap replicas that are not recognized by the information * stored in the inode during log replay. */ int mds_repl_inv_except(struct bmap *b, int iosidx) { int rc, logit = 0, tract[NBREPLST], retifset[NBREPLST]; uint32_t policy; /* Ensure replica on active IOS is marked valid. */ brepls_init(tract, -1); tract[BREPLST_INVALID] = BREPLST_VALID; tract[BREPLST_GARBAGE_SCHED] = BREPLST_VALID; tract[BREPLST_GARBAGE_QUEUED] = BREPLST_VALID; /* * The old state for this bmap on the given IOS is * either valid or invalid. */ brepls_init_idx(retifset); retifset[BREPLST_INVALID] = 0; retifset[BREPLST_VALID] = 0; /* * XXX on full truncate, the metafile will exist, which means * the bmap states will exist, which means a new IOS will be * selected which will probably be GARBAGE after truncate * happens a few times. */ rc = mds_repl_bmap_walk(b, tract, retifset, 0, &iosidx, 1); if (rc) { psclog_errorx("bcs_repls has active IOS marked in a " "weird state while invalidating other replicas; " "fid="SLPRI_FID" bmap=%d iosidx=%d state=%d", fcmh_2_fid(b->bcm_fcmh), b->bcm_bmapno, iosidx, rc); } policy = bmap_2_replpol(b); /* * Invalidate all other replicas. * Note: if the status is SCHED here, don't do anything; once * the replication status update comes from the ION, we will * know he copied an old bmap and mark it OLD then. */ brepls_init(tract, -1); tract[BREPLST_VALID] = policy == BRPOL_PERSIST ? BREPLST_REPL_QUEUED : BREPLST_GARBAGE_QUEUED; tract[BREPLST_REPL_SCHED] = BREPLST_REPL_QUEUED; brepls_init(retifset, 0); retifset[BREPLST_VALID] = 1; retifset[BREPLST_REPL_SCHED] = 1; if (_mds_repl_bmap_walk(b, tract, retifset, REPL_WALKF_MODOTH, &iosidx, 1, NULL, NULL)) { logit = 1; BHGEN_INCREMENT(b); } if (logit) rc = mds_bmap_write_logrepls(b); else rc = mds_bmap_write(b, NULL, NULL); /* * If this bmap is marked for persistent replication, the repl * request must exist and should be marked such that the * replication monitors do not release it in the midst of * processing it as this activity now means they have more to * do. */ if (policy == BRPOL_PERSIST) upsch_enqueue(&bmap_2_bmi(b)->bmi_upd); return (rc); }