int slm_rmc_handle_getinode(struct pscrpc_request *rq) { const struct srm_get_inode_req *mq; struct srm_get_inode_rep *mp; struct fidc_membh *f; SL_RSX_ALLOCREP(rq, mq, mp); mp->rc = -slm_fcmh_get(&mq->fg, &f); if (mp->rc) return (0); slm_pack_inode(f, &mp->ino); fcmh_op_done(f); return (0); }
int slm_rmc_handle_link(struct pscrpc_request *rq) { struct fidc_membh *p = NULL, *c = NULL; struct srm_link_req *mq; struct srm_link_rep *mp; int vfsid; SL_RSX_ALLOCREP(rq, mq, mp); mp->rc = slfid_to_vfsid(mq->fg.fg_fid, &vfsid); if (mp->rc) PFL_GOTOERR(out, mp->rc); mp->rc = -slm_fcmh_get(&mq->pfg, &p); if (mp->rc) PFL_GOTOERR(out, mp->rc); mp->rc = -slm_fcmh_get(&mq->fg, &c); if (mp->rc) PFL_GOTOERR(out, mp->rc); mq->name[sizeof(mq->name) - 1] = '\0'; mds_reserve_slot(1); mp->rc = mdsio_link(vfsid, fcmh_2_mfid(c), fcmh_2_mfid(p), mq->name, &rootcreds, mdslog_namespace); mds_unreserve_slot(1); mdsio_fcmh_refreshattr(c, &mp->cattr); mdsio_fcmh_refreshattr(p, &mp->pattr); out: if (c) fcmh_op_done(c); if (p) fcmh_op_done(p); return (0); }
/* * Handle a BMAPCHWRMODE request to upgrade a client bmap lease from * READ-only to READ+WRITE. * @rq: RPC request. */ int slm_rmc_handle_bmap_chwrmode(struct pscrpc_request *rq) { struct bmap_mds_lease *bml = NULL; struct srm_bmap_chwrmode_req *mq; struct srm_bmap_chwrmode_rep *mp; struct fidc_membh *f = NULL; struct bmapc_memb *b = NULL; struct bmap_mds_info *bmi; SL_RSX_ALLOCREP(rq, mq, mp); mp->rc = -slm_fcmh_get(&mq->sbd.sbd_fg, &f); if (mp->rc) PFL_GOTOERR(out, mp->rc); mp->rc = bmap_lookup(f, mq->sbd.sbd_bmapno, &b); if (mp->rc) PFL_GOTOERR(out, mp->rc); bmi = bmap_2_bmi(b); bml = mds_bmap_getbml(b, mq->sbd.sbd_seq, mq->sbd.sbd_nid, mq->sbd.sbd_pid); if (bml == NULL) PFL_GOTOERR(out, mp->rc = -EINVAL); mp->rc = mds_bmap_bml_chwrmode(bml, mq->prefios[0]); if (mp->rc == -PFLERR_ALREADY) mp->rc = 0; else if (mp->rc) PFL_GOTOERR(out, mp->rc); mp->sbd = mq->sbd; mp->sbd.sbd_seq = bml->bml_seq; mp->sbd.sbd_key = bmi->bmi_assign->odtr_crc; psc_assert(bmi->bmi_wr_ion); mp->sbd.sbd_ios = rmmi2resm(bmi->bmi_wr_ion)->resm_res_id; out: if (bml) mds_bmap_bml_release(bml); if (b) bmap_op_done(b); if (f) fcmh_op_done(f); return (0); }
int slm_rmc_handle_lookup(struct pscrpc_request *rq) { struct fidc_membh *p = NULL; struct srm_lookup_req *mq; struct srm_lookup_rep *mp; int vfsid; SL_RSX_ALLOCREP(rq, mq, mp); mp->rc = slfid_to_vfsid(mq->pfg.fg_fid, &vfsid); if (mp->rc) PFL_GOTOERR(out, mp->rc); mp->rc = -slm_fcmh_get(&mq->pfg, &p); if (mp->rc) PFL_GOTOERR(out, mp->rc); mq->name[sizeof(mq->name) - 1] = '\0'; psclog_diag("lookup: pfid="SLPRI_FID" name=%s", fcmh_2_mfid(p), mq->name); if (fcmh_2_mfid(p) == SLFID_ROOT && strcmp(mq->name, SL_RPATH_META_DIR) == 0) PFL_GOTOERR(out, mp->rc = -EINVAL); if (mq->pfg.fg_fid == SLFID_ROOT && use_global_mount) { uint64_t fid; struct sl_site *site; mp->rc = -ENOENT; CONF_LOCK(); CONF_FOREACH_SITE(site) { if (strcmp(mq->name, site->site_name) != 0) continue; fid = SLFID_ROOT; FID_SET_SITEID(fid, site->site_id); mp->xattrsize = 0; mp->attr.sst_fg.fg_fid = fid; mp->attr.sst_fg.fg_gen = 2; slm_root_attributes(&mp->attr); mp->rc = 0; break; } CONF_ULOCK(); goto out; }
int slm_rmc_handle_extendbmapls(struct pscrpc_request *rq) { struct srm_leasebmapext_req *mq; struct srm_leasebmapext_rep *mp; struct fidc_membh *f; SL_RSX_ALLOCREP(rq, mq, mp); mp->rc = -slm_fcmh_get(&mq->sbd.sbd_fg, &f); if (mp->rc) return (0); mp->rc = mds_lease_renew(f, &mq->sbd, &mp->sbd, rq->rq_export); fcmh_op_done(f); return (0); }
int slm_rmc_handle_reassignbmapls(struct pscrpc_request *rq) { struct srm_reassignbmap_req *mq; struct srm_reassignbmap_rep *mp; struct fidc_membh *f; SL_RSX_ALLOCREP(rq, mq, mp); mp->rc = -slm_fcmh_get(&mq->sbd.sbd_fg, &f); if (mp->rc) return (0); mp->rc = mds_lease_reassign(f, &mq->sbd, mq->pios, mq->prev_sliods, mq->nreassigns, &mp->sbd, rq->rq_export); fcmh_op_done(f); return (0); }
int slm_rmc_handle_getattr(struct pscrpc_request *rq) { const struct srm_getattr_req *mq; struct srm_getattr_rep *mp; struct fidc_membh *f; int vfsid; SL_RSX_ALLOCREP(rq, mq, mp); psclog_diag("pfid="SLPRI_FID, mq->fg.fg_fid); if (mq->fg.fg_fid == SLFID_ROOT && use_global_mount) { mp->attr.sst_fg.fg_fid = SLFID_ROOT; mp->attr.sst_fg.fg_gen = FGEN_ANY-1; slm_root_attributes(&mp->attr); return (0); } mp->rc = -slm_fcmh_get(&mq->fg, &f); if (mp->rc) PFL_GOTOERR(out, mp->rc); mp->rc = slfid_to_vfsid(mq->fg.fg_fid, &vfsid); if (mp->rc) PFL_GOTOERR(out, mp->rc); mp->xattrsize = mdsio_hasxattrs(vfsid, &rootcreds, fcmh_2_mfid(f)); FCMH_LOCK(f); mp->attr = f->fcmh_sstb; out: if (f) fcmh_op_done(f); return (0); }
int slm_rmc_handle_getbmap(struct pscrpc_request *rq) { const struct srm_leasebmap_req *mq; struct srm_leasebmap_rep *mp; struct fidc_membh *f; int rc = 0; SL_RSX_ALLOCREP(rq, mq, mp); if (mq->rw == SL_WRITE) OPSTAT_INCR("getbmap-lease-write"); else if (mq->rw == SL_READ) OPSTAT_INCR("getbmap-lease-read"); else { mp->rc = -EINVAL; return (0); } mp->rc = -slm_fcmh_get(&mq->fg, &f); if (mp->rc) return (0); mp->flags = mq->flags; mp->rc = mds_bmap_load_cli(f, mq->bmapno, mq->flags, mq->rw, mq->prefios[0], &mp->sbd, rq->rq_export, mp->repls, 0); if (mp->rc) PFL_GOTOERR(out, mp->rc); if (mp->flags & SRM_LEASEBMAPF_GETINODE) slm_pack_inode(f, &mp->ino); out: fcmh_op_done(f); return (rc ? rc : mp->rc); }
/* * Handle a NAMESPACE_FORWARD request from another MDS. */ int slm_rmm_handle_namespace_forward(struct pscrpc_request *rq) { char *from, *to, *name, *linkname; struct fidc_membh *p = NULL, *op = NULL, *np = NULL; struct srm_forward_req *mq; struct srm_forward_rep *mp; struct slash_creds cr; struct srt_stat sstb; void *mfh; int vfsid; p = op = np = NULL; SL_RSX_ALLOCREP(rq, mq, mp); if (mq->op != SLM_FORWARD_MKDIR && mq->op != SLM_FORWARD_RMDIR && mq->op != SLM_FORWARD_CREATE && mq->op != SLM_FORWARD_UNLINK && mq->op != SLM_FORWARD_SYMLINK && mq->op != SLM_FORWARD_RENAME && mq->op != SLM_FORWARD_SETATTR) { mp->rc = -EINVAL; return (0); } psclog_info("op=%d, name=%s", mq->op, mq->req.name); mp->rc = slfid_to_vfsid(mq->fg.fg_fid, &vfsid); if (mp->rc) return (0); if (current_vfsid != vfsid) { mp->rc = -EINVAL; return (0); } cr.scr_uid = mq->creds.scr_uid; cr.scr_gid = mq->creds.scr_gid; mds_reserve_slot(2); switch (mq->op) { case SLM_FORWARD_MKDIR: mp->rc = slm_fcmh_get(&mq->fg, &p); if (mp->rc) break; sstb.sst_mode = mq->mode; sstb.sst_uid = mq->creds.scr_uid; sstb.sst_gid = mq->creds.scr_gid; mp->rc = -mdsio_mkdir(vfsid, fcmh_2_mfid(p), mq->req.name, &sstb, 0, 0, &mp->attr, NULL, mdslog_namespace, slm_get_next_slashfid, 0); break; case SLM_FORWARD_CREATE: mp->rc = slm_fcmh_get(&mq->fg, &p); if (mp->rc) break; mp->rc = mdsio_opencreate(vfsid, fcmh_2_mfid(p), &cr, O_CREAT | O_EXCL | O_RDWR, mq->mode, mq->req.name, NULL, &mp->attr, &mfh, mdslog_namespace, slm_get_next_slashfid, 0); if (!mp->rc) mdsio_release(vfsid, &rootcreds, mfh); break; case SLM_FORWARD_RMDIR: mp->rc = slm_fcmh_get(&mq->fg, &p); if (mp->rc) break; mp->rc = mdsio_rmdir(vfsid, fcmh_2_mfid(p), NULL, mq->req.name, &rootcreds, mdslog_namespace); break; case SLM_FORWARD_UNLINK: mp->rc = slm_fcmh_get(&mq->fg, &p); if (mp->rc) break; mp->rc = -mdsio_unlink(vfsid, fcmh_2_mfid(p), NULL, mq->req.name, &rootcreds, mdslog_namespace, &mp->attr); break; case SLM_FORWARD_RENAME: mp->rc = slm_fcmh_get(&mq->fg, &op); if (mp->rc) break; mp->rc = slm_fcmh_get(&mq->nfg, &np); if (mp->rc) break; from = mq->req.name; to = mq->req.name + strlen(mq->req.name) + 1; mp->rc = mdsio_rename(vfsid, fcmh_2_mfid(op), from, fcmh_2_mfid(np), to, &rootcreds, mdslog_namespace, &mp->attr); break; case SLM_FORWARD_SETATTR: /* * This is tough because we have some logic at the fcmh * layer dealing with (partial) truncates. It is not a * pure namespace operation. */ mp->rc = slm_fcmh_get(&mq->fg, &p); if (mp->rc) break; mp->rc = -mdsio_setattr(vfsid, fcmh_2_mfid(p), &mq->req.sstb, mq->to_set, &rootcreds, &mp->attr, fcmh_2_mfh(p), mdslog_namespace); break; case SLM_FORWARD_SYMLINK: mp->rc = slm_fcmh_get(&mq->fg, &p); if (mp->rc) break; name = mq->req.name; linkname = mq->req.name + strlen(mq->req.name) + 1; mp->rc = mdsio_symlink(vfsid, linkname, fcmh_2_mfid(p), name, &cr, &mp->attr, NULL, NULL, slm_get_next_slashfid, 0); break; } mds_unreserve_slot(2); if (p) fcmh_op_done(p); if (op) fcmh_op_done(op); if (np) fcmh_op_done(np); return (0); }
int mds_repl_delrq(const struct sl_fidgen *fgp, sl_bmapno_t bmapno, sl_bmapno_t *nbmaps, sl_replica_t *iosv, int nios) { int tract[NBREPLST], rc, iosidx[SL_MAX_REPLICAS], flags; sl_bmapno_t nbmaps_processed = 0; struct slm_repl_valid replv; struct fidc_membh *f = NULL; struct bmap *b; if (nios < 1 || nios > SL_MAX_REPLICAS || *nbmaps == 0) return (-EINVAL); rc = slm_fcmh_get(fgp, &f); if (rc) return (-rc); FCMH_LOCK(f); if (fcmh_isdir(f)) flags = IOSV_LOOKUPF_DEL; else flags = IOSV_LOOKUPF_LOOKUP; /* Find replica IOS indexes. */ rc = -_mds_repl_iosv_lookup(current_vfsid, fcmh_2_inoh(f), iosv, iosidx, nios, flags); if (fcmh_isdir(f) || rc) PFL_GOTOERR(out, rc); replv.nios = nios; replv.idx = iosidx; brepls_init(tract, -1); tract[BREPLST_REPL_QUEUED] = BREPLST_GARBAGE_QUEUED; tract[BREPLST_REPL_SCHED] = BREPLST_GARBAGE_QUEUED; tract[BREPLST_VALID] = BREPLST_GARBAGE_QUEUED; /* Wildcards shouldn't result in errors on zero-length files. */ if (*nbmaps != (sl_bmapno_t)-1) rc = -SLERR_BMAP_INVALID; /* * The following loop will bail out on the very first error. * However, its previous action, if any, has already taken * effect. */ for (; *nbmaps && bmapno < fcmh_nvalidbmaps(f); bmapno++, --*nbmaps, nbmaps_processed++) { if (nbmaps_processed >= SLM_REPLRQ_NBMAPS_MAX) PFL_GOTOERR(out, rc = -PFLERR_WOULDBLOCK); rc = -bmap_get(f, bmapno, SL_WRITE, &b); if (rc) PFL_GOTOERR(out, rc); /* * Before blindly doing the transition, we have to check * to ensure this operation would retain at least one * valid replica. */ replv.n = 0; mds_repl_bmap_walkcb(b, NULL, NULL, 0, slm_repl_countvalid_cb, &replv); flags = 0; if (replv.n == 0) rc = -SLERR_LASTREPL; else { rc = _mds_repl_bmap_walk(b, tract, NULL, 0, iosidx, nios, slm_repl_delrq_cb, &flags); psc_assert(!rc); if (flags & FLAG_DIRTY) rc = mds_bmap_write_logrepls(b); } bmap_op_done_type(b, BMAP_OPCNT_LOOKUP); if (rc) PFL_GOTOERR(out, rc); } out: if (f) fcmh_op_done(f); *nbmaps = nbmaps_processed; return (rc); }
/* * Handle a request to do replication from a client. May also * reinitialize some parameters of the replication, such as priority, if * the request already exists in the system. */ int mds_repl_addrq(const struct sl_fidgen *fgp, sl_bmapno_t bmapno, sl_bmapno_t *nbmaps, sl_replica_t *iosv, int nios, int sys_prio, int usr_prio) { int tract[NBREPLST], ret_hasvalid[NBREPLST]; int iosidx[SL_MAX_REPLICAS], rc, flags; sl_bmapno_t nbmaps_processed = 0; struct fidc_membh *f = NULL; struct bmap *b; /* Perform sanity checks on request. */ if (nios < 1 || nios > SL_MAX_REPLICAS || *nbmaps == 0) return (-EINVAL); rc = slm_fcmh_get(fgp, &f); if (rc) return (-rc); if (!fcmh_isdir(f) && !fcmh_isreg(f)) PFL_GOTOERR(out, rc = -PFLERR_NOTSUP); /* Lookup replica(s)' indexes in our replica table. */ rc = -mds_repl_iosv_lookup_add(current_vfsid, fcmh_2_inoh(f), iosv, iosidx, nios); if (rc) PFL_GOTOERR(out, rc); /* * If we are modifying a directory, we are done as just the * replica table needs to be updated. */ if (fcmh_isdir(f)) PFL_GOTOERR(out, 0); /* * Setup structure to ensure at least one VALID replica exists. */ brepls_init(ret_hasvalid, 0); ret_hasvalid[BREPLST_VALID] = 1; /* * Setup transitions to enqueue a replication. */ brepls_init(tract, -1); tract[BREPLST_INVALID] = BREPLST_REPL_QUEUED; tract[BREPLST_GARBAGE_SCHED] = BREPLST_REPL_QUEUED; tract[BREPLST_GARBAGE_QUEUED] = BREPLST_REPL_QUEUED; /* Wildcards shouldn't result in errors on zero-length files. */ if (*nbmaps != (sl_bmapno_t)-1) rc = -SLERR_BMAP_INVALID; for (; *nbmaps && bmapno < fcmh_nvalidbmaps(f); bmapno++, --*nbmaps, nbmaps_processed++) { if (nbmaps_processed >= SLM_REPLRQ_NBMAPS_MAX) { rc = -PFLERR_WOULDBLOCK; break; } rc = -bmap_get(f, bmapno, SL_WRITE, &b); if (rc) PFL_GOTOERR(out, rc); /* * If no VALID replicas exist, the bmap must be * uninitialized/all zeroes; skip it. */ if (mds_repl_bmap_walk_all(b, NULL, ret_hasvalid, REPL_WALKF_SCIRCUIT) == 0) { bmap_op_done(b); continue; } /* * We do not follow the standard "retifset" API here * because we need to preserve DIRTY if it gets set * instead of some other state getting returned. */ flags = 0; _mds_repl_bmap_walk(b, tract, NULL, 0, iosidx, nios, slm_repl_addrq_cb, &flags); /* both default to -1 in parse_replrq() */ bmap_2_bmi(b)->bmi_sys_prio = sys_prio; bmap_2_bmi(b)->bmi_usr_prio = usr_prio; if (flags & FLAG_DIRTY) mds_bmap_write_logrepls(b); else if (sys_prio != -1 || usr_prio != -1) slm_repl_upd_write(b, 0); bmap_op_done_type(b, BMAP_OPCNT_LOOKUP); if (flags & FLAG_REPLICA_STATE_INVALID) { /* See pfl_register_errno() */ rc = -SLERR_REPLICA_STATE_INVALID; break; } } out: if (f) fcmh_op_done(f); *nbmaps = nbmaps_processed; return (rc); }