static int out_create(struct mdt_thread_info *info) { struct update *update = info->mti_u.update.mti_update; struct dt_object *obj = info->mti_u.update.mti_dt_object; struct dt_object_format *dof = &info->mti_u.update.mti_update_dof; struct obdo *lobdo = &info->mti_u.update.mti_obdo; struct lu_attr *attr = &info->mti_attr.ma_attr; struct lu_fid *fid = NULL; struct obdo *wobdo; int size; int rc; ENTRY; wobdo = update_param_buf(update, 0, &size); if (wobdo == NULL || size != sizeof(*wobdo)) { CERROR("%s: obdo is NULL, invalid RPC: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } obdo_le_to_cpu(wobdo, wobdo); lustre_get_wire_obdo(lobdo, wobdo); la_from_obdo(attr, lobdo, lobdo->o_valid); dof->dof_type = dt_mode_to_dft(attr->la_mode); if (S_ISDIR(attr->la_mode)) { int size; fid = update_param_buf(update, 1, &size); if (fid == NULL || size != sizeof(*fid)) { CERROR("%s: invalid fid: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } fid_le_to_cpu(fid, fid); if (!fid_is_sane(fid)) { CERROR("%s: invalid fid "DFID": rc = %d\n", mdt_obd_name(info->mti_mdt), PFID(fid), -EPROTO); RETURN(err_serious(-EPROTO)); } } rc = out_tx_create(info, obj, attr, fid, dof, &info->mti_handle, info->mti_u.update.mti_update_reply, info->mti_u.update.mti_update_reply_index); RETURN(rc); }
static int out_attr_set(struct mdt_thread_info *info) { struct update *update = info->mti_u.update.mti_update; struct lu_attr *attr = &info->mti_attr.ma_attr; struct dt_object *obj = info->mti_u.update.mti_dt_object; struct obdo *lobdo = &info->mti_u.update.mti_obdo; struct obdo *wobdo; int size; int rc; ENTRY; wobdo = update_param_buf(update, 0, &size); if (wobdo == NULL || size != sizeof(*wobdo)) { CERROR("%s: empty obdo in the update: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } attr->la_valid = 0; attr->la_valid = 0; obdo_le_to_cpu(wobdo, wobdo); lustre_get_wire_obdo(lobdo, wobdo); la_from_obdo(attr, lobdo, lobdo->o_valid); rc = out_tx_attr_set(info, obj, attr, &info->mti_handle, info->mti_u.update.mti_update_reply, info->mti_u.update.mti_update_reply_index); RETURN(rc); }
static int out_tx_index_insert_undo(struct mdt_thread_info *info, struct thandle *th, struct tx_arg *arg) { struct dt_object *dt_obj = arg->object; int rc; LASSERT(dt_obj != NULL && !IS_ERR(dt_obj)); CDEBUG(D_OTHER, "index delete "DFID" name: %s\n", PFID(lu_object_fid(&arg->object->do_lu)), (char *)arg->u.insert.key); if (dt_try_as_dir(info->mti_env, dt_obj) == 0) { CERROR("%s: "DFID" is not directory: rc = %d\n", mdt_obd_name(info->mti_mdt), PFID(lu_object_fid(&dt_obj->do_lu)), -ENOTDIR); return -ENOTDIR; } dt_write_lock(info->mti_env, dt_obj, MOR_TGT_CHILD); rc = dt_delete(info->mti_env, dt_obj, arg->u.insert.key, th, NULL); dt_write_unlock(info->mti_env, dt_obj); update_insert_reply(arg->reply, NULL, 0, arg->index, rc); return rc; }
static int out_xattr_get(struct mdt_thread_info *info) { struct update *update = info->mti_u.update.mti_update; const struct lu_env *env = info->mti_env; struct lu_buf *lbuf = &info->mti_buf; struct update_reply *reply = info->mti_u.update.mti_update_reply; struct dt_object *obj = info->mti_u.update.mti_dt_object; char *name; void *ptr; int rc; ENTRY; name = (char *)update_param_buf(update, 0, NULL); if (name == NULL) { CERROR("%s: empty name for xattr get: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } ptr = update_get_buf_internal(reply, 0, NULL); LASSERT(ptr != NULL); /* The first 4 bytes(int) are used to store the result */ lbuf->lb_buf = (char *)ptr + sizeof(int); lbuf->lb_len = UPDATE_BUFFER_SIZE - sizeof(struct update_reply); dt_read_lock(env, obj, MOR_TGT_CHILD); rc = dt_xattr_get(env, obj, lbuf, name, NULL); dt_read_unlock(env, obj); if (rc < 0) { lbuf->lb_len = 0; GOTO(out, rc); } if (rc == 0) { lbuf->lb_len = 0; GOTO(out, rc = -ENOENT); } lbuf->lb_len = rc; rc = 0; CDEBUG(D_INFO, "%s: "DFID" get xattr %s len %d\n", mdt_obd_name(info->mti_mdt), PFID(lu_object_fid(&obj->do_lu)), name, (int)lbuf->lb_len); out: *(int *)ptr = rc; reply->ur_lens[0] = lbuf->lb_len + sizeof(int); RETURN(rc); }
static int out_xattr_set(struct mdt_thread_info *info) { struct update *update = info->mti_u.update.mti_update; struct dt_object *obj = info->mti_u.update.mti_dt_object; struct lu_buf *lbuf = &info->mti_buf; char *name; char *buf; char *tmp; int buf_len = 0; int flag; int rc; ENTRY; name = update_param_buf(update, 0, NULL); if (name == NULL) { CERROR("%s: empty name for xattr set: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } buf = (char *)update_param_buf(update, 1, &buf_len); if (buf == NULL || buf_len == 0) { CERROR("%s: empty buf for xattr set: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } lbuf->lb_buf = buf; lbuf->lb_len = buf_len; tmp = (char *)update_param_buf(update, 2, NULL); if (tmp == NULL) { CERROR("%s: empty flag for xattr set: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } flag = le32_to_cpu(*(int *)tmp); rc = out_tx_xattr_set(info, obj, lbuf, name, flag, &info->mti_handle, info->mti_u.update.mti_update_reply, info->mti_u.update.mti_update_reply_index); RETURN(rc); }
static int out_tx_attr_set_undo(struct mdt_thread_info *info, struct thandle *th, struct tx_arg *arg) { CERROR("%s: attr set undo "DFID" unimplemented yet!: rc = %d\n", mdt_obd_name(info->mti_mdt), PFID(lu_object_fid(&arg->object->do_lu)), -ENOTSUPP); return -ENOTSUPP; }
static int out_index_insert(struct mdt_thread_info *info) { struct update *update = info->mti_u.update.mti_update; struct dt_object *obj = info->mti_u.update.mti_dt_object; struct lu_fid *fid; char *name; int rc = 0; int size; ENTRY; name = (char *)update_param_buf(update, 0, NULL); if (name == NULL) { CERROR("%s: empty name for index insert: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } fid = (struct lu_fid *)update_param_buf(update, 1, &size); if (fid == NULL || size != sizeof(*fid)) { CERROR("%s: invalid fid: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } fid_le_to_cpu(fid, fid); if (!fid_is_sane(fid)) { CERROR("%s: invalid FID "DFID": rc = %d\n", mdt_obd_name(info->mti_mdt), PFID(fid), -EPROTO); RETURN(err_serious(-EPROTO)); } rc = out_tx_index_insert(info, obj, name, fid, &info->mti_handle, info->mti_u.update.mti_update_reply, info->mti_u.update.mti_update_reply_index); RETURN(rc); }
static int out_index_lookup(struct mdt_thread_info *info) { struct update *update = info->mti_u.update.mti_update; const struct lu_env *env = info->mti_env; struct dt_object *obj = info->mti_u.update.mti_dt_object; char *name; int rc; ENTRY; if (!lu_object_exists(&obj->do_lu)) RETURN(-ENOENT); name = (char *)update_param_buf(update, 0, NULL); if (name == NULL) { CERROR("%s: empty name for lookup: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } dt_read_lock(env, obj, MOR_TGT_CHILD); if (!dt_try_as_dir(env, obj)) GOTO(out_unlock, rc = -ENOTDIR); rc = dt_lookup(env, obj, (struct dt_rec *)&info->mti_tmp_fid1, (struct dt_key *)name, NULL); if (rc < 0) GOTO(out_unlock, rc); if (rc == 0) rc += 1; CDEBUG(D_INFO, "lookup "DFID" %s get "DFID" rc %d\n", PFID(lu_object_fid(&obj->do_lu)), name, PFID(&info->mti_tmp_fid1), rc); fid_cpu_to_le(&info->mti_tmp_fid1, &info->mti_tmp_fid1); out_unlock: dt_read_unlock(env, obj); update_insert_reply(info->mti_u.update.mti_update_reply, &info->mti_tmp_fid1, sizeof(info->mti_tmp_fid1), 0, rc); RETURN(rc); }
/** * All of the xxx_undo will be used once execution failed, * But because all of the required resource has been reserved in * declare phase, i.e. if declare succeed, it should make sure * the following executing phase succeed in anyway, so these undo * should be useless for most of the time in Phase I **/ int out_tx_create_undo(struct mdt_thread_info *info, struct thandle *th, struct tx_arg *arg) { struct dt_object *dt_obj = arg->object; int rc; LASSERT(dt_obj != NULL && !IS_ERR(dt_obj)); dt_write_lock(info->mti_env, dt_obj, MOR_TGT_CHILD); rc = dt_destroy(info->mti_env, dt_obj, th); dt_write_unlock(info->mti_env, dt_obj); /* we don't like double failures */ if (rc != 0) CERROR("%s: undo failure, we are doomed!: rc = %d\n", mdt_obd_name(info->mti_mdt), rc); return rc; }
int out_tx_end(struct mdt_thread_info *info, struct thandle_exec_args *th) { struct thandle_exec_args *_th = &info->mti_handle; int i = 0, rc; LASSERT(th == _th); LASSERT(th->ta_dev); LASSERT(th->ta_handle); if (th->ta_err != 0 || th->ta_argno == 0) GOTO(stop, rc = th->ta_err); rc = out_trans_start(info->mti_env, th->ta_dev, th->ta_handle); if (unlikely(rc)) GOTO(stop, rc); for (i = 0; i < th->ta_argno; i++) { rc = th->ta_args[i].exec_fn(info, th->ta_handle, &th->ta_args[i]); if (unlikely(rc)) { CDEBUG(D_INFO, "error during execution of #%u from" " %s:%d: rc = %d\n", i, th->ta_args[i].file, th->ta_args[i].line, rc); while (--i >= 0) { LASSERTF(th->ta_args[i].undo_fn != NULL, "can't undo changes, hope for failover!\n"); th->ta_args[i].undo_fn(info, th->ta_handle, &th->ta_args[i]); } break; } } stop: CDEBUG(D_INFO, "%s: executed %u/%u: rc = %d\n", mdt_obd_name(info->mti_mdt), i, th->ta_argno, rc); out_trans_stop(info->mti_env, th, rc); th->ta_handle = NULL; th->ta_argno = 0; th->ta_err = 0; RETURN(rc); }
static int out_index_delete(struct mdt_thread_info *info) { struct update *update = info->mti_u.update.mti_update; struct dt_object *obj = info->mti_u.update.mti_dt_object; char *name; int rc = 0; if (!lu_object_exists(&obj->do_lu)) RETURN(-ENOENT); name = (char *)update_param_buf(update, 0, NULL); if (name == NULL) { CERROR("%s: empty name for index delete: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } rc = out_tx_index_delete(info, obj, name, &info->mti_handle, info->mti_u.update.mti_update_reply, info->mti_u.update.mti_update_reply_index); RETURN(rc); }
static int mdt_reint_create(struct mdt_thread_info *info, struct mdt_lock_handle *lhc) { struct ptlrpc_request *req = mdt_info_req(info); int rc; ENTRY; if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_CREATE)) RETURN(err_serious(-ESTALE)); if (info->mti_dlm_req) ldlm_request_cancel(mdt_info_req(info), info->mti_dlm_req, 0); LASSERT(info->mti_rr.rr_namelen > 0); switch (info->mti_attr.ma_attr.la_mode & S_IFMT) { case S_IFDIR: mdt_counter_incr(req, LPROC_MDT_MKDIR); break; case S_IFREG: case S_IFLNK: case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK: /* Special file should stay on the same node as parent. */ mdt_counter_incr(req, LPROC_MDT_MKNOD); break; default: CERROR("%s: Unsupported mode %o\n", mdt_obd_name(info->mti_mdt), info->mti_attr.ma_attr.la_mode); RETURN(err_serious(-EOPNOTSUPP)); } rc = mdt_md_create(info); RETURN(rc); }
/** * Retrieve undergoing HSM requests for the fid provided in RPC body. * Current requests are read from coordinator states. * * This is MDS_HSM_ACTION RPC handler. */ int mdt_hsm_action(struct tgt_session_info *tsi) { struct mdt_thread_info *info; struct hsm_current_action *hca; struct hsm_action_list *hal = NULL; struct hsm_action_item *hai; int hal_size; int rc; ENTRY; hca = req_capsule_server_get(tsi->tsi_pill, &RMF_MDS_HSM_CURRENT_ACTION); if (hca == NULL) RETURN(err_serious(-EPROTO)); if (tsi->tsi_mdt_body == NULL) RETURN(-EPROTO); info = tsi2mdt_info(tsi); /* Only valid if client is remote */ rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body); if (rc) GOTO(out, rc = err_serious(rc)); /* Coordinator information */ hal_size = sizeof(*hal) + cfs_size_round(MTI_NAME_MAXLEN) /* fsname */ + cfs_size_round(sizeof(*hai)); MDT_HSM_ALLOC(hal, hal_size); if (hal == NULL) GOTO(out_ucred, rc = -ENOMEM); hal->hal_version = HAL_VERSION; hal->hal_archive_id = 0; hal->hal_flags = 0; obd_uuid2fsname(hal->hal_fsname, mdt_obd_name(info->mti_mdt), MTI_NAME_MAXLEN); hal->hal_count = 1; hai = hai_first(hal); hai->hai_action = HSMA_NONE; hai->hai_cookie = 0; hai->hai_gid = 0; hai->hai_fid = info->mti_body->mbo_fid1; hai->hai_len = sizeof(*hai); rc = mdt_hsm_get_actions(info, hal); if (rc) GOTO(out_free, rc); /* cookie is used to give back request status */ if (hai->hai_cookie == 0) hca->hca_state = HPS_WAITING; else hca->hca_state = HPS_RUNNING; switch (hai->hai_action) { case HSMA_NONE: hca->hca_action = HUA_NONE; break; case HSMA_ARCHIVE: hca->hca_action = HUA_ARCHIVE; break; case HSMA_RESTORE: hca->hca_action = HUA_RESTORE; break; case HSMA_REMOVE: hca->hca_action = HUA_REMOVE; break; case HSMA_CANCEL: hca->hca_action = HUA_CANCEL; break; default: hca->hca_action = HUA_NONE; CERROR("%s: Unknown hsm action: %d on "DFID"\n", mdt_obd_name(info->mti_mdt), hai->hai_action, PFID(&hai->hai_fid)); break; } hca->hca_location = hai->hai_extent; EXIT; out_free: MDT_HSM_FREE(hal, hal_size); out_ucred: mdt_exit_ucred(info); out: mdt_thread_info_fini(info); return rc; }
static int mdt_lvbo_fill(struct ldlm_lock *lock, void *lvb, int lvblen) { struct lu_env env; struct mdt_thread_info *info; struct mdt_device *mdt; struct lu_fid *fid; struct mdt_object *obj = NULL; struct md_object *child = NULL; int rc; ENTRY; mdt = ldlm_lock_to_ns(lock)->ns_lvbp; if (IS_LQUOTA_RES(lock->l_resource)) { if (mdt->mdt_qmt_dev == NULL) RETURN(0); /* call lvbo fill function of quota master */ rc = qmt_hdls.qmth_lvbo_fill(mdt->mdt_qmt_dev, lock, lvb, lvblen); RETURN(rc); } if (!ldlm_has_layout(lock)) RETURN(0); /* layout lock will be granted to client, fill in lvb with layout */ /* XXX create an env to talk to mdt stack. We should get this env from * ptlrpc_thread->t_env. */ rc = lu_env_init(&env, LCT_MD_THREAD); /* Likely ENOMEM */ if (rc) RETURN(rc); info = lu_context_key_get(&env.le_ctx, &mdt_thread_key); /* Likely ENOMEM */ if (info == NULL) GOTO(out, rc = -ENOMEM); memset(info, 0, sizeof *info); info->mti_env = &env; info->mti_exp = lock->l_export; info->mti_mdt = mdt; /* XXX get fid by resource id. why don't include fid in ldlm_resource */ fid = &info->mti_tmp_fid2; fid_extract_from_res_name(fid, &lock->l_resource->lr_name); obj = mdt_object_find(&env, info->mti_mdt, fid); if (IS_ERR(obj)) GOTO(out, rc = PTR_ERR(obj)); if (!mdt_object_exists(obj) || mdt_object_remote(obj)) GOTO(out, rc = -ENOENT); child = mdt_object_child(obj); /* get the length of lsm */ rc = mo_xattr_get(&env, child, &LU_BUF_NULL, XATTR_NAME_LOV); if (rc < 0) GOTO(out, rc); if (rc > 0) { struct lu_buf *lmm = NULL; if (lvblen < rc) { CERROR("%s: expected %d actual %d.\n", mdt_obd_name(mdt), rc, lvblen); GOTO(out, rc = -ERANGE); } lmm = &info->mti_buf; lmm->lb_buf = lvb; lmm->lb_len = rc; rc = mo_xattr_get(&env, child, lmm, XATTR_NAME_LOV); if (rc < 0) GOTO(out, rc); } out: if (obj != NULL && !IS_ERR(obj)) mdt_object_put(&env, obj); lu_env_fini(&env); RETURN(rc < 0 ? 0 : rc); }
/* return EADATA length to the caller. negative value means error */ static int mdt_getxattr_pack_reply(struct mdt_thread_info * info) { struct req_capsule *pill = info->mti_pill; struct ptlrpc_request *req = mdt_info_req(info); const char *xattr_name; u64 valid; static const char user_string[] = "user."; int size; int rc = 0; int rc2; ENTRY; valid = info->mti_body->mbo_valid & (OBD_MD_FLXATTR | OBD_MD_FLXATTRLS); /* Determine how many bytes we need */ if (valid == OBD_MD_FLXATTR) { xattr_name = req_capsule_client_get(pill, &RMF_NAME); if (!xattr_name) RETURN(-EFAULT); if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR) && !strncmp(xattr_name, user_string, sizeof(user_string) - 1)) RETURN(-EOPNOTSUPP); size = mo_xattr_get(info->mti_env, mdt_object_child(info->mti_object), &LU_BUF_NULL, xattr_name); if (size == -ENODATA) { /* XXX: Some client code will not handle -ENODATA * for XATTR_NAME_LOV (trusted.lov) properly. */ if (strcmp(xattr_name, XATTR_NAME_LOV) == 0) rc = 0; else rc = -ENODATA; size = 0; } } else if (valid == OBD_MD_FLXATTRLS) { xattr_name = "list"; size = mo_xattr_list(info->mti_env, mdt_object_child(info->mti_object), &LU_BUF_NULL); } else if (valid == OBD_MD_FLXATTRALL) { xattr_name = "all"; /* N.B. eadatasize = 0 is not valid for FLXATTRALL */ /* We could calculate accurate sizes, but this would * introduce a lot of overhead, let's do it later... */ size = info->mti_body->mbo_eadatasize; req_capsule_set_size(pill, &RMF_EAVALS, RCL_SERVER, size); req_capsule_set_size(pill, &RMF_EAVALS_LENS, RCL_SERVER, size); } else { CDEBUG(D_INFO, "Valid bits: %#llx\n", info->mti_body->mbo_valid); RETURN(-EINVAL); } if (size < 0) { if (size != -EOPNOTSUPP && size != -ENOENT) CERROR("%s: error geting EA size for '%s': rc = %d\n", mdt_obd_name(info->mti_mdt), xattr_name, size); RETURN(size); } if (req_capsule_has_field(pill, &RMF_ACL, RCL_SERVER)) req_capsule_set_size(pill, &RMF_ACL, RCL_SERVER, LUSTRE_POSIX_ACL_MAX_SIZE_OLD); req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER, info->mti_body->mbo_eadatasize == 0 ? 0 : size); rc2 = req_capsule_server_pack(pill); if (rc2 < 0) RETURN(rc2); if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETXATTR_PACK)) RETURN(-ENOMEM); RETURN(rc < 0 ? rc : size); }
int mdt_reint_setxattr(struct mdt_thread_info *info, struct mdt_lock_handle *unused) { struct ptlrpc_request *req = mdt_info_req(info); struct mdt_lock_handle *lh; const struct lu_env *env = info->mti_env; struct lu_buf *buf = &info->mti_buf; struct mdt_reint_record *rr = &info->mti_rr; struct md_attr *ma = &info->mti_attr; struct lu_attr *attr = &info->mti_attr.ma_attr; struct mdt_object *obj; struct md_object *child; __u64 valid = attr->la_valid; const char *xattr_name = rr->rr_name.ln_name; int xattr_len = rr->rr_eadatalen; __u64 lockpart = MDS_INODELOCK_UPDATE; int rc; ENTRY; CDEBUG(D_INODE, "setxattr for "DFID": %s %s\n", PFID(rr->rr_fid1), valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name); if (info->mti_dlm_req) ldlm_request_cancel(req, info->mti_dlm_req, 0, LATF_SKIP); if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR)) RETURN(err_serious(-ENOMEM)); rc = mdt_init_ucred_reint(info); if (rc != 0) RETURN(rc); if (strncmp(xattr_name, XATTR_USER_PREFIX, sizeof(XATTR_USER_PREFIX) - 1) == 0) { if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR)) GOTO(out, rc = -EOPNOTSUPP); } else if (strncmp(xattr_name, XATTR_TRUSTED_PREFIX, sizeof(XATTR_TRUSTED_PREFIX) - 1) == 0) { /* setxattr(LMV) with lum is used to shrink dir layout */ if (strcmp(xattr_name, XATTR_NAME_LMV) == 0) { __u32 *magic = rr->rr_eadata; /* we don't let to remove LMV? */ if (!rr->rr_eadata) GOTO(out, rc = 0); if (le32_to_cpu(*magic) == LMV_USER_MAGIC || le32_to_cpu(*magic) == LMV_USER_MAGIC_SPECIFIC) { rc = mdt_dir_layout_shrink(info); GOTO(out, rc); } } if (!md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN)) GOTO(out, rc = -EPERM); if (strcmp(xattr_name, XATTR_NAME_LOV) == 0 || strcmp(xattr_name, XATTR_NAME_LMA) == 0 || strcmp(xattr_name, XATTR_NAME_LMV) == 0 || strcmp(xattr_name, XATTR_NAME_LINK) == 0 || strcmp(xattr_name, XATTR_NAME_FID) == 0 || strcmp(xattr_name, XATTR_NAME_VERSION) == 0 || strcmp(xattr_name, XATTR_NAME_SOM) == 0 || strcmp(xattr_name, XATTR_NAME_HSM) == 0 || strcmp(xattr_name, XATTR_NAME_LFSCK_NAMESPACE) == 0) GOTO(out, rc = 0); } else if ((valid & OBD_MD_FLXATTR) && (strcmp(xattr_name, XATTR_NAME_ACL_ACCESS) == 0 || strcmp(xattr_name, XATTR_NAME_ACL_DEFAULT) == 0)) { rc = mdt_nodemap_map_acl(info, rr->rr_eadata, xattr_len, xattr_name, NODEMAP_CLIENT_TO_FS); if (rc < 0) GOTO(out, rc); /* ACLs were mapped out, return an error so the user knows */ if (rc != xattr_len) GOTO(out, rc = -EPERM); } else if ((strlen(xattr_name) > strlen(XATTR_LUSTRE_LOV) + 1) && strncmp(xattr_name, XATTR_LUSTRE_LOV, strlen(XATTR_LUSTRE_LOV)) == 0) { if (strncmp(xattr_name, XATTR_LUSTRE_LOV".add", strlen(XATTR_LUSTRE_LOV".add")) && strncmp(xattr_name, XATTR_LUSTRE_LOV".set", strlen(XATTR_LUSTRE_LOV".set")) && strncmp(xattr_name, XATTR_LUSTRE_LOV".del", strlen(XATTR_LUSTRE_LOV".del"))) { CERROR("%s: invalid xattr name: %s\n", mdt_obd_name(info->mti_mdt), xattr_name); GOTO(out, rc = -EINVAL); } lockpart |= MDS_INODELOCK_LAYOUT; } /* Revoke all clients' lookup lock, since the access * permissions for this inode is changed when ACL_ACCESS is * set. This isn't needed for ACL_DEFAULT, since that does * not change the access permissions of this inode, nor any * other existing inodes. It is setting the ACLs inherited * by new directories/files at create time. */ /* We need revoke both LOOKUP|PERM lock here, see mdt_attr_set. */ if (!strcmp(xattr_name, XATTR_NAME_ACL_ACCESS)) lockpart |= MDS_INODELOCK_PERM | MDS_INODELOCK_LOOKUP; /* We need to take the lock on behalf of old clients so that newer * clients flush their xattr caches */ else lockpart |= MDS_INODELOCK_XATTR; lh = &info->mti_lh[MDT_LH_PARENT]; /* ACLs were sent to clients under LCK_CR locks, so taking LCK_EX * to cancel them. */ mdt_lock_reg_init(lh, LCK_EX); obj = mdt_object_find_lock(info, rr->rr_fid1, lh, lockpart); if (IS_ERR(obj)) GOTO(out, rc = PTR_ERR(obj)); tgt_vbr_obj_set(env, mdt_obj2dt(obj)); rc = mdt_version_get_check_save(info, obj, 0); if (rc) GOTO(out_unlock, rc); if (unlikely(!(valid & OBD_MD_FLCTIME))) { /* This isn't strictly an error, but all current clients * should set OBD_MD_FLCTIME when setting attributes. */ CWARN("%s: client miss to set OBD_MD_FLCTIME when " "setxattr %s: [object "DFID"] [valid %llu]\n", mdt_obd_name(info->mti_mdt), xattr_name, PFID(rr->rr_fid1), valid); attr->la_ctime = ktime_get_real_seconds(); } attr->la_valid = LA_CTIME; child = mdt_object_child(obj); if (valid & OBD_MD_FLXATTR) { int flags = 0; if (attr->la_flags & XATTR_REPLACE) flags |= LU_XATTR_REPLACE; if (attr->la_flags & XATTR_CREATE) flags |= LU_XATTR_CREATE; mdt_fail_write(env, info->mti_mdt->mdt_bottom, OBD_FAIL_MDS_SETXATTR_WRITE); buf->lb_buf = rr->rr_eadata; buf->lb_len = xattr_len; rc = mo_xattr_set(env, child, buf, xattr_name, flags); /* update ctime after xattr changed */ if (rc == 0) { ma->ma_attr_flags |= MDS_PERM_BYPASS; mo_attr_set(env, child, ma); } } else if (valid & OBD_MD_FLXATTRRM) { rc = mo_xattr_del(env, child, xattr_name); /* update ctime after xattr changed */ if (rc == 0) { ma->ma_attr_flags |= MDS_PERM_BYPASS; mo_attr_set(env, child, ma); } } else { CDEBUG(D_INFO, "valid bits: %#llx\n", valid); rc = -EINVAL; } if (rc == 0) mdt_counter_incr(req, LPROC_MDT_SETXATTR); EXIT; out_unlock: mdt_object_unlock_put(info, obj, lh, rc); out: mdt_exit_ucred(info); return rc; }
/* shrink dir layout after migration */ static int mdt_dir_layout_shrink(struct mdt_thread_info *info) { const struct lu_env *env = info->mti_env; struct mdt_device *mdt = info->mti_mdt; struct lu_ucred *uc = mdt_ucred(info); struct mdt_reint_record *rr = &info->mti_rr; struct lmv_user_md *lmu = rr->rr_eadata; __u32 lum_stripe_count = lmu->lum_stripe_count; struct lu_buf *buf = &info->mti_buf; struct lmv_mds_md_v1 *lmv; struct md_attr *ma = &info->mti_attr; struct ldlm_enqueue_info *einfo = &info->mti_einfo[0]; struct mdt_object *pobj = NULL; struct mdt_object *obj; struct mdt_lock_handle *lhp = NULL; struct mdt_lock_handle *lhc; int rc; ENTRY; if (!mdt->mdt_enable_dir_migration) RETURN(-EPERM); if (!md_capable(uc, CFS_CAP_SYS_ADMIN) && uc->uc_gid != mdt->mdt_enable_remote_dir_gid && mdt->mdt_enable_remote_dir_gid != -1) RETURN(-EPERM); /* mti_big_lmm is used to save LMV, but it may be uninitialized. */ if (unlikely(!info->mti_big_lmm)) { info->mti_big_lmmsize = lmv_mds_md_size(64, LMV_MAGIC); OBD_ALLOC(info->mti_big_lmm, info->mti_big_lmmsize); if (!info->mti_big_lmm) RETURN(-ENOMEM); } obj = mdt_object_find(env, mdt, rr->rr_fid1); if (IS_ERR(obj)) RETURN(PTR_ERR(obj)); /* get parent from PFID */ rc = mdt_attr_get_pfid(info, obj, &ma->ma_pfid); if (rc) GOTO(put_obj, rc); pobj = mdt_object_find(env, mdt, &ma->ma_pfid); if (IS_ERR(pobj)) GOTO(put_obj, rc = PTR_ERR(pobj)); /* revoke object remote LOOKUP lock */ if (mdt_object_remote(pobj)) { rc = mdt_revoke_remote_lookup_lock(info, pobj, obj); if (rc) GOTO(put_pobj, rc); } /* * lock parent if dir will be shrunk to 1 stripe, because dir will be * converted to normal directory, as will change dir fid and update * namespace of parent. */ lhp = &info->mti_lh[MDT_LH_PARENT]; mdt_lock_reg_init(lhp, LCK_PW); if (le32_to_cpu(lmu->lum_stripe_count) < 2) { rc = mdt_reint_object_lock(info, pobj, lhp, MDS_INODELOCK_UPDATE, true); if (rc) GOTO(put_pobj, rc); } /* lock object */ lhc = &info->mti_lh[MDT_LH_CHILD]; mdt_lock_reg_init(lhc, LCK_EX); rc = mdt_reint_striped_lock(info, obj, lhc, MDS_INODELOCK_FULL, einfo, true); if (rc) GOTO(unlock_pobj, rc); ma->ma_lmv = info->mti_big_lmm; ma->ma_lmv_size = info->mti_big_lmmsize; ma->ma_valid = 0; rc = mdt_stripe_get(info, obj, ma, XATTR_NAME_LMV); if (rc) GOTO(unlock_obj, rc); /* user may run 'lfs migrate' multiple times, so it's shrunk already */ if (!(ma->ma_valid & MA_LMV)) GOTO(unlock_obj, rc = -EALREADY); lmv = &ma->ma_lmv->lmv_md_v1; /* ditto */ if (!(le32_to_cpu(lmv->lmv_hash_type) & LMV_HASH_FLAG_MIGRATION)) GOTO(unlock_obj, rc = -EALREADY); lum_stripe_count = lmu->lum_stripe_count; if (!lum_stripe_count) lum_stripe_count = cpu_to_le32(1); if (lmv->lmv_migrate_offset != lum_stripe_count) { CERROR("%s: "DFID" migrate mdt count mismatch %u != %u\n", mdt_obd_name(info->mti_mdt), PFID(rr->rr_fid1), lmv->lmv_migrate_offset, lmu->lum_stripe_count); GOTO(unlock_obj, rc = -EINVAL); } if (lmv->lmv_master_mdt_index != lmu->lum_stripe_offset) { CERROR("%s: "DFID" migrate mdt index mismatch %u != %u\n", mdt_obd_name(info->mti_mdt), PFID(rr->rr_fid1), lmv->lmv_master_mdt_index, lmu->lum_stripe_offset); GOTO(unlock_obj, rc = -EINVAL); } if (lum_stripe_count > 1 && (lmv->lmv_hash_type & cpu_to_le32(LMV_HASH_TYPE_MASK)) != lmu->lum_hash_type) { CERROR("%s: "DFID" migrate mdt hash mismatch %u != %u\n", mdt_obd_name(info->mti_mdt), PFID(rr->rr_fid1), lmv->lmv_hash_type, lmu->lum_hash_type); GOTO(unlock_obj, rc = -EINVAL); } buf->lb_buf = rr->rr_eadata; buf->lb_len = rr->rr_eadatalen; rc = mo_xattr_set(env, mdt_object_child(obj), buf, XATTR_NAME_LMV, 0); GOTO(unlock_obj, rc); unlock_obj: mdt_reint_striped_unlock(info, obj, lhc, einfo, rc); unlock_pobj: mdt_object_unlock(info, pobj, lhp, rc); put_pobj: mdt_object_put(env, pobj); put_obj: mdt_object_put(env, obj); return rc; }
/* * VBR: save parent version in reply and child version getting by its name. * Version of child is getting and checking during its lookup. If */ static int mdt_reint_unlink(struct mdt_thread_info *info, struct mdt_lock_handle *lhc) { struct mdt_reint_record *rr = &info->mti_rr; struct ptlrpc_request *req = mdt_info_req(info); struct md_attr *ma = &info->mti_attr; struct lu_fid *child_fid = &info->mti_tmp_fid1; struct mdt_object *mp; struct mdt_object *mc; struct mdt_lock_handle *parent_lh; struct mdt_lock_handle *child_lh; struct lu_name *lname; int rc; int no_name = 0; ENTRY; DEBUG_REQ(D_INODE, req, "unlink "DFID"/%s", PFID(rr->rr_fid1), rr->rr_name); if (info->mti_dlm_req) ldlm_request_cancel(req, info->mti_dlm_req, 0); if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK)) RETURN(err_serious(-ENOENT)); if (fid_is_obf(rr->rr_fid1) || fid_is_dot_lustre(rr->rr_fid1)) RETURN(-EPERM); /* * step 1: Found the parent. */ mp = mdt_object_find(info->mti_env, info->mti_mdt, rr->rr_fid1); if (IS_ERR(mp)) { rc = PTR_ERR(mp); GOTO(out, rc); } parent_lh = &info->mti_lh[MDT_LH_PARENT]; lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen); if (mdt_object_remote(mp)) { mdt_lock_reg_init(parent_lh, LCK_EX); rc = mdt_remote_object_lock(info, mp, &parent_lh->mlh_rreg_lh, parent_lh->mlh_rreg_mode, MDS_INODELOCK_UPDATE); if (rc != ELDLM_OK) GOTO(put_parent, rc); } else { mdt_lock_pdo_init(parent_lh, LCK_PW, rr->rr_name, rr->rr_namelen); rc = mdt_object_lock(info, mp, parent_lh, MDS_INODELOCK_UPDATE, MDT_LOCAL_LOCK); if (rc) GOTO(put_parent, rc); rc = mdt_version_get_check_save(info, mp, 0); if (rc) GOTO(unlock_parent, rc); } /* step 2: find & lock the child */ /* lookup child object along with version checking */ fid_zero(child_fid); rc = mdt_lookup_version_check(info, mp, lname, child_fid, 1); if (rc != 0) { /* Name might not be able to find during resend of * remote unlink, considering following case. * dir_A is a remote directory, the name entry of * dir_A is on MDT0, the directory is on MDT1, * * 1. client sends unlink req to MDT1. * 2. MDT1 sends name delete update to MDT0. * 3. name entry is being deleted in MDT0 synchronously. * 4. MDT1 is restarted. * 5. client resends unlink req to MDT1. So it can not * find the name entry on MDT0 anymore. * In this case, MDT1 only needs to destory the local * directory. * */ if (mdt_object_remote(mp) && rc == -ENOENT && !fid_is_zero(rr->rr_fid2) && lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) { no_name = 1; *child_fid = *rr->rr_fid2; } else { GOTO(unlock_parent, rc); } } if (fid_is_obf(child_fid) || fid_is_dot_lustre(child_fid)) GOTO(unlock_parent, rc = -EPERM); mdt_reint_init_ma(info, ma); /* We will lock the child regardless it is local or remote. No harm. */ mc = mdt_object_find(info->mti_env, info->mti_mdt, child_fid); if (IS_ERR(mc)) GOTO(unlock_parent, rc = PTR_ERR(mc)); child_lh = &info->mti_lh[MDT_LH_CHILD]; mdt_lock_reg_init(child_lh, LCK_EX); if (mdt_object_remote(mc)) { struct mdt_body *repbody; if (!fid_is_zero(rr->rr_fid2)) { CDEBUG(D_INFO, "%s: name %s can not find "DFID"\n", mdt_obd_name(info->mti_mdt), (char *)rr->rr_name, PFID(mdt_object_fid(mc))); GOTO(put_child, rc = -ENOENT); } CDEBUG(D_INFO, "%s: name %s: "DFID" is another MDT\n", mdt_obd_name(info->mti_mdt), (char *)rr->rr_name, PFID(mdt_object_fid(mc))); if (!mdt_is_dne_client(req->rq_export)) /* Return -EIO for old client */ GOTO(put_child, rc = -EIO); if (info->mti_spec.sp_rm_entry) { struct lu_ucred *uc = mdt_ucred(info); if (!md_capable(uc, CFS_CAP_SYS_ADMIN)) { CERROR("%s: unlink remote entry is only " "permitted for administrator: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPERM); GOTO(put_child, rc = -EPERM); } ma->ma_need = MA_INODE; ma->ma_valid = 0; mdt_set_capainfo(info, 1, child_fid, BYPASS_CAPA); rc = mdo_unlink(info->mti_env, mdt_object_child(mp), NULL, lname, ma, no_name); GOTO(put_child, rc); } /* Revoke the LOOKUP lock of the remote object granted by * this MDT. Since the unlink will happen on another MDT, * it will release the LOOKUP lock right away. Then What * would happen if another client try to grab the LOOKUP * lock at the same time with unlink XXX */ mdt_object_lock(info, mc, child_lh, MDS_INODELOCK_LOOKUP, MDT_CROSS_LOCK); repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); LASSERT(repbody != NULL); repbody->fid1 = *mdt_object_fid(mc); repbody->valid |= (OBD_MD_FLID | OBD_MD_MDS); GOTO(unlock_child, rc = -EREMOTE); } else if (info->mti_spec.sp_rm_entry) { rc = -EPERM; CDEBUG(D_INFO, "%s: no rm_entry on local dir '%s': rc = %d\n", mdt_obd_name(info->mti_mdt), (char *)rr->rr_name, rc); GOTO(put_child, rc); } /* We used to acquire MDS_INODELOCK_FULL here but we can't do * this now because a running HSM restore on the child (unlink * victim) will hold the layout lock. See LU-4002. */ rc = mdt_object_lock(info, mc, child_lh, MDS_INODELOCK_LOOKUP | MDS_INODELOCK_UPDATE, MDT_CROSS_LOCK); if (rc != 0) GOTO(put_child, rc); mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom, OBD_FAIL_MDS_REINT_UNLINK_WRITE); /* save version when object is locked */ mdt_version_get_save(info, mc, 1); /* * Now we can only make sure we need MA_INODE, in mdd layer, will check * whether need MA_LOV and MA_COOKIE. */ ma->ma_need = MA_INODE; ma->ma_valid = 0; mdt_set_capainfo(info, 1, child_fid, BYPASS_CAPA); mutex_lock(&mc->mot_lov_mutex); rc = mdo_unlink(info->mti_env, mdt_object_child(mp), mdt_object_child(mc), lname, ma, no_name); mutex_unlock(&mc->mot_lov_mutex); if (rc == 0 && !lu_object_is_dying(&mc->mot_header)) rc = mdt_attr_get_complex(info, mc, ma); if (rc == 0) mdt_handle_last_unlink(info, mc, ma); if (ma->ma_valid & MA_INODE) { switch (ma->ma_attr.la_mode & S_IFMT) { case S_IFDIR: mdt_counter_incr(req, LPROC_MDT_RMDIR); break; case S_IFREG: case S_IFLNK: case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK: mdt_counter_incr(req, LPROC_MDT_UNLINK); break; default: LASSERTF(0, "bad file type %o unlinking\n", ma->ma_attr.la_mode); } } EXIT; unlock_child: mdt_object_unlock(info, mc, child_lh, rc); put_child: mdt_object_put(info->mti_env, mc); unlock_parent: mdt_object_unlock(info, mp, parent_lh, rc); put_parent: mdt_object_put(info->mti_env, mp); out: return rc; }
/* * VBR: save versions in reply: 0 - parent; 1 - child by fid; 2 - target by * name. */ static int mdt_reint_link(struct mdt_thread_info *info, struct mdt_lock_handle *lhc) { struct mdt_reint_record *rr = &info->mti_rr; struct ptlrpc_request *req = mdt_info_req(info); struct md_attr *ma = &info->mti_attr; struct mdt_object *ms; struct mdt_object *mp; struct mdt_lock_handle *lhs; struct mdt_lock_handle *lhp; struct lu_name *lname; int rc; ENTRY; DEBUG_REQ(D_INODE, req, "link "DFID" to "DFID"/%s", PFID(rr->rr_fid1), PFID(rr->rr_fid2), rr->rr_name); if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_LINK)) RETURN(err_serious(-ENOENT)); if (info->mti_dlm_req) ldlm_request_cancel(req, info->mti_dlm_req, 0); /* Invalid case so return error immediately instead of * processing it */ if (lu_fid_eq(rr->rr_fid1, rr->rr_fid2)) RETURN(-EPERM); if (fid_is_obf(rr->rr_fid1) || fid_is_dot_lustre(rr->rr_fid1) || fid_is_obf(rr->rr_fid2) || fid_is_dot_lustre(rr->rr_fid2)) RETURN(-EPERM); /* step 1: find & lock the target parent dir */ lhp = &info->mti_lh[MDT_LH_PARENT]; mdt_lock_pdo_init(lhp, LCK_PW, rr->rr_name, rr->rr_namelen); mp = mdt_object_find_lock(info, rr->rr_fid2, lhp, MDS_INODELOCK_UPDATE); if (IS_ERR(mp)) RETURN(PTR_ERR(mp)); rc = mdt_version_get_check_save(info, mp, 0); if (rc) GOTO(out_unlock_parent, rc); /* step 2: find & lock the source */ lhs = &info->mti_lh[MDT_LH_CHILD]; mdt_lock_reg_init(lhs, LCK_EX); ms = mdt_object_find(info->mti_env, info->mti_mdt, rr->rr_fid1); if (IS_ERR(ms)) GOTO(out_unlock_parent, rc = PTR_ERR(ms)); if (mdt_object_remote(ms)) { mdt_object_put(info->mti_env, ms); CERROR("%s: source inode "DFID" on remote MDT from "DFID"\n", mdt_obd_name(info->mti_mdt), PFID(rr->rr_fid1), PFID(rr->rr_fid2)); GOTO(out_unlock_parent, rc = -EXDEV); } rc = mdt_object_lock(info, ms, lhs, MDS_INODELOCK_UPDATE | MDS_INODELOCK_XATTR, MDT_CROSS_LOCK); if (rc != 0) { mdt_object_put(info->mti_env, ms); GOTO(out_unlock_parent, rc); } /* step 3: link it */ mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom, OBD_FAIL_MDS_REINT_LINK_WRITE); tgt_vbr_obj_set(info->mti_env, mdt_obj2dt(ms)); rc = mdt_version_get_check_save(info, ms, 1); if (rc) GOTO(out_unlock_child, rc); lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen); /** check target version by name during replay */ rc = mdt_lookup_version_check(info, mp, lname, &info->mti_tmp_fid1, 2); if (rc != 0 && rc != -ENOENT) GOTO(out_unlock_child, rc); /* save version of file name for replay, it must be ENOENT here */ if (!req_is_replay(mdt_info_req(info))) { if (rc != -ENOENT) { CDEBUG(D_INFO, "link target %.*s existed!\n", rr->rr_namelen, (char *)rr->rr_name); GOTO(out_unlock_child, rc = -EEXIST); } info->mti_ver[2] = ENOENT_VERSION; mdt_version_save(mdt_info_req(info), info->mti_ver[2], 2); } rc = mdo_link(info->mti_env, mdt_object_child(mp), mdt_object_child(ms), lname, ma); if (rc == 0) mdt_counter_incr(req, LPROC_MDT_LINK); EXIT; out_unlock_child: mdt_object_unlock_put(info, ms, lhs, rc); out_unlock_parent: mdt_object_unlock_put(info, mp, lhp, rc); return rc; }
/** * Object updates between Targets. Because all the updates has been * dis-assemblied into object updates in master MDD layer, so out * will skip MDD layer, and call OSD API directly to execute these * updates. * * In phase I, all of the updates in the request need to be executed * in one transaction, and the transaction has to be synchronously. * * Please refer to lustre/include/lustre/lustre_idl.h for req/reply * format. */ int out_handle(struct mdt_thread_info *info) { struct req_capsule *pill = info->mti_pill; struct update_buf *ubuf; struct update *update; struct thandle_exec_args *th = &info->mti_handle; int bufsize; int count; unsigned off; int i; int rc = 0; int rc1 = 0; ENTRY; req_capsule_set(pill, &RQF_UPDATE_OBJ); bufsize = req_capsule_get_size(pill, &RMF_UPDATE, RCL_CLIENT); if (bufsize != UPDATE_BUFFER_SIZE) { CERROR("%s: invalid bufsize %d: rc = %d\n", mdt_obd_name(info->mti_mdt), bufsize, -EPROTO); RETURN(err_serious(-EPROTO)); } ubuf = req_capsule_client_get(pill, &RMF_UPDATE); if (ubuf == NULL) { CERROR("%s: No buf!: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } if (le32_to_cpu(ubuf->ub_magic) != UPDATE_BUFFER_MAGIC) { CERROR("%s: invalid magic %x expect %x: rc = %d\n", mdt_obd_name(info->mti_mdt), le32_to_cpu(ubuf->ub_magic), UPDATE_BUFFER_MAGIC, -EPROTO); RETURN(err_serious(-EPROTO)); } count = le32_to_cpu(ubuf->ub_count); if (count <= 0) { CERROR("%s: No update!: rc = %d\n", mdt_obd_name(info->mti_mdt), -EPROTO); RETURN(err_serious(-EPROTO)); } req_capsule_set_size(pill, &RMF_UPDATE_REPLY, RCL_SERVER, UPDATE_BUFFER_SIZE); rc = req_capsule_server_pack(pill); if (rc != 0) { CERROR("%s: Can't pack response: rc = %d\n", mdt_obd_name(info->mti_mdt), rc); RETURN(rc); } /* Prepare the update reply buffer */ info->mti_u.update.mti_update_reply = req_capsule_server_get(pill, &RMF_UPDATE_REPLY); update_init_reply_buf(info->mti_u.update.mti_update_reply, count); rc = out_tx_start(info->mti_env, info->mti_mdt, th); if (rc != 0) RETURN(rc); /* Walk through updates in the request to execute them synchronously */ off = cfs_size_round(offsetof(struct update_buf, ub_bufs[0])); for (i = 0; i < count; i++) { struct out_handler *h; struct dt_object *dt_obj; update = (struct update *)((char *)ubuf + off); fid_le_to_cpu(&update->u_fid, &update->u_fid); if (!fid_is_sane(&update->u_fid)) { CERROR("%s: invalid FID "DFID": rc = %d\n", mdt_obd_name(info->mti_mdt), PFID(&update->u_fid), -EPROTO); GOTO(out, rc = err_serious(-EPROTO)); } dt_obj = out_object_find(info, &update->u_fid); if (IS_ERR(dt_obj)) GOTO(out, rc = PTR_ERR(dt_obj)); info->mti_u.update.mti_dt_object = dt_obj; info->mti_u.update.mti_update = update; info->mti_u.update.mti_update_reply_index = i; h = mdt_handler_find(update->u_type, out_handlers); if (likely(h != NULL)) { rc = h->mh_act(info); } else { CERROR("%s: The unsupported opc: 0x%x\n", mdt_obd_name(info->mti_mdt), update->u_type); lu_object_put(info->mti_env, &dt_obj->do_lu); GOTO(out, rc = -ENOTSUPP); } lu_object_put(info->mti_env, &dt_obj->do_lu); if (rc < 0) GOTO(out, rc); off += cfs_size_round(update_size(update)); } out: rc1 = out_tx_end(info, th); rc = rc == 0 ? rc1 : rc; info->mti_fail_id = OBD_FAIL_UPDATE_OBJ_NET; RETURN(rc); }
/** * Process the HSM actions described in a struct hsm_user_request. * * The action described in hur will be send to coordinator to be saved and * processed later or either handled directly if hur.hur_action is HUA_RELEASE. * * This is MDS_HSM_REQUEST RPC handler. */ int mdt_hsm_request(struct tgt_session_info *tsi) { struct mdt_thread_info *info; struct req_capsule *pill = tsi->tsi_pill; struct hsm_request *hr; struct hsm_user_item *hui; struct hsm_action_list *hal; struct hsm_action_item *hai; const void *data; int hui_list_size; int data_size; enum hsm_copytool_action action = HSMA_NONE; __u64 compound_id; int hal_size, i, rc; ENTRY; hr = req_capsule_client_get(pill, &RMF_MDS_HSM_REQUEST); hui = req_capsule_client_get(pill, &RMF_MDS_HSM_USER_ITEM); data = req_capsule_client_get(pill, &RMF_GENERIC_DATA); if (tsi->tsi_mdt_body == NULL || hr == NULL || hui == NULL || data == NULL) RETURN(-EPROTO); /* Sanity check. Nothing to do with an empty list */ if (hr->hr_itemcount == 0) RETURN(0); hui_list_size = req_capsule_get_size(pill, &RMF_MDS_HSM_USER_ITEM, RCL_CLIENT); if (hui_list_size < hr->hr_itemcount * sizeof(*hui)) RETURN(-EPROTO); data_size = req_capsule_get_size(pill, &RMF_GENERIC_DATA, RCL_CLIENT); if (data_size != hr->hr_data_len) RETURN(-EPROTO); info = tsi2mdt_info(tsi); /* Only valid if client is remote */ rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body); if (rc) GOTO(out, rc); switch (hr->hr_action) { /* code to be removed in hsm1_merge and final patch */ case HUA_RELEASE: CERROR("Release action is not working in hsm1_coord\n"); GOTO(out_ucred, rc = -EINVAL); break; /* end of code to be removed */ case HUA_ARCHIVE: action = HSMA_ARCHIVE; break; case HUA_RESTORE: action = HSMA_RESTORE; break; case HUA_REMOVE: action = HSMA_REMOVE; break; case HUA_CANCEL: action = HSMA_CANCEL; break; default: CERROR("Unknown hsm action: %d\n", hr->hr_action); GOTO(out_ucred, rc = -EINVAL); } hal_size = sizeof(*hal) + cfs_size_round(MTI_NAME_MAXLEN) /* fsname */ + (sizeof(*hai) + cfs_size_round(hr->hr_data_len)) * hr->hr_itemcount; MDT_HSM_ALLOC(hal, hal_size); if (hal == NULL) GOTO(out_ucred, rc = -ENOMEM); hal->hal_version = HAL_VERSION; hal->hal_archive_id = hr->hr_archive_id; hal->hal_flags = hr->hr_flags; obd_uuid2fsname(hal->hal_fsname, mdt_obd_name(info->mti_mdt), MTI_NAME_MAXLEN); hal->hal_count = 0; hai = hai_first(hal); for (i = 0; i < hr->hr_itemcount; i++, hai = hai_next(hai)) { /* Get rid of duplicate entries. Otherwise we get * duplicated work in the llog. */ if (is_fid_in_hal(hal, &hui[i].hui_fid)) continue; hai->hai_action = action; hai->hai_cookie = 0; hai->hai_gid = 0; hai->hai_fid = hui[i].hui_fid; hai->hai_extent = hui[i].hui_extent; memcpy(hai->hai_data, data, hr->hr_data_len); hai->hai_len = sizeof(*hai) + hr->hr_data_len; hal->hal_count++; } rc = mdt_hsm_add_actions(info, hal, &compound_id); MDT_HSM_FREE(hal, hal_size); GOTO(out_ucred, rc); out_ucred: mdt_exit_ucred(info); out: mdt_thread_info_fini(info); return rc; }
int mdt_reint_setxattr(struct mdt_thread_info *info, struct mdt_lock_handle *unused) { struct ptlrpc_request *req = mdt_info_req(info); struct lu_ucred *uc = lu_ucred(info->mti_env); struct mdt_lock_handle *lh; const struct lu_env *env = info->mti_env; struct lu_buf *buf = &info->mti_buf; struct mdt_reint_record *rr = &info->mti_rr; struct md_attr *ma = &info->mti_attr; struct lu_attr *attr = &info->mti_attr.ma_attr; struct mdt_object *obj; struct md_object *child; __u64 valid = attr->la_valid; const char *xattr_name = rr->rr_name.ln_name; int xattr_len = rr->rr_eadatalen; __u64 lockpart; int rc; posix_acl_xattr_header *new_xattr = NULL; __u32 remote = exp_connect_rmtclient(info->mti_exp); __u32 perm; ENTRY; CDEBUG(D_INODE, "setxattr for "DFID"\n", PFID(rr->rr_fid1)); if (info->mti_dlm_req) ldlm_request_cancel(req, info->mti_dlm_req, 0); if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR)) RETURN(err_serious(-ENOMEM)); CDEBUG(D_INODE, "%s xattr %s\n", valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name); rc = mdt_init_ucred_reint(info); if (rc != 0) RETURN(rc); if (valid & OBD_MD_FLRMTRSETFACL) { if (unlikely(!remote)) GOTO(out, rc = err_serious(-EINVAL)); perm = mdt_identity_get_perm(uc->uc_identity, remote, req->rq_peer.nid); if (!(perm & CFS_RMTACL_PERM)) GOTO(out, rc = err_serious(-EPERM)); } if (strncmp(xattr_name, XATTR_USER_PREFIX, sizeof(XATTR_USER_PREFIX) - 1) == 0) { if (!(exp_connect_flags(req->rq_export) & OBD_CONNECT_XATTR)) GOTO(out, rc = -EOPNOTSUPP); } else if (strncmp(xattr_name, XATTR_TRUSTED_PREFIX, sizeof(XATTR_TRUSTED_PREFIX) - 1) == 0) { if (!md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN)) GOTO(out, rc = -EPERM); if (strcmp(xattr_name, XATTR_NAME_LOV) == 0 || strcmp(xattr_name, XATTR_NAME_LMA) == 0 || strcmp(xattr_name, XATTR_NAME_LMV) == 0 || strcmp(xattr_name, XATTR_NAME_LINK) == 0 || strcmp(xattr_name, XATTR_NAME_FID) == 0 || strcmp(xattr_name, XATTR_NAME_VERSION) == 0 || strcmp(xattr_name, XATTR_NAME_SOM) == 0 || strcmp(xattr_name, XATTR_NAME_HSM) == 0 || strcmp(xattr_name, XATTR_NAME_LFSCK_NAMESPACE) == 0) GOTO(out, rc = 0); } else if ((valid & OBD_MD_FLXATTR) && (strcmp(xattr_name, XATTR_NAME_ACL_ACCESS) == 0 || strcmp(xattr_name, XATTR_NAME_ACL_DEFAULT) == 0)) { /* currently lustre limit acl access size */ if (xattr_len > LUSTRE_POSIX_ACL_MAX_SIZE) GOTO(out, rc = -ERANGE); } lockpart = MDS_INODELOCK_UPDATE; /* Revoke all clients' lookup lock, since the access * permissions for this inode is changed when ACL_ACCESS is * set. This isn't needed for ACL_DEFAULT, since that does * not change the access permissions of this inode, nor any * other existing inodes. It is setting the ACLs inherited * by new directories/files at create time. */ /* We need revoke both LOOKUP|PERM lock here, see mdt_attr_set. */ if (!strcmp(xattr_name, XATTR_NAME_ACL_ACCESS)) lockpart |= MDS_INODELOCK_PERM | MDS_INODELOCK_LOOKUP; /* We need to take the lock on behalf of old clients so that newer * clients flush their xattr caches */ else lockpart |= MDS_INODELOCK_XATTR; lh = &info->mti_lh[MDT_LH_PARENT]; /* ACLs were sent to clients under LCK_CR locks, so taking LCK_EX * to cancel them. */ mdt_lock_reg_init(lh, LCK_EX); obj = mdt_object_find_lock(info, rr->rr_fid1, lh, lockpart); if (IS_ERR(obj)) GOTO(out, rc = PTR_ERR(obj)); tgt_vbr_obj_set(env, mdt_obj2dt(obj)); rc = mdt_version_get_check_save(info, obj, 0); if (rc) GOTO(out_unlock, rc); if (unlikely(!(valid & OBD_MD_FLCTIME))) { /* This isn't strictly an error, but all current clients * should set OBD_MD_FLCTIME when setting attributes. */ CWARN("%s: client miss to set OBD_MD_FLCTIME when " "setxattr %s: [object "DFID"] [valid "LPU64"]\n", mdt_obd_name(info->mti_mdt), xattr_name, PFID(rr->rr_fid1), valid); attr->la_ctime = cfs_time_current_sec(); } attr->la_valid = LA_CTIME; child = mdt_object_child(obj); if (valid & OBD_MD_FLXATTR) { char *xattr = (void *)rr->rr_eadata; if (xattr_len > 0) { int flags = 0; if (valid & OBD_MD_FLRMTLSETFACL) { if (unlikely(!remote)) GOTO(out_unlock, rc = -EINVAL); xattr_len = mdt_rmtlsetfacl(info, child, xattr_name, (ext_acl_xattr_header *)xattr, &new_xattr); if (xattr_len < 0) GOTO(out_unlock, rc = xattr_len); xattr = (char *)new_xattr; } if (attr->la_flags & XATTR_REPLACE) flags |= LU_XATTR_REPLACE; if (attr->la_flags & XATTR_CREATE) flags |= LU_XATTR_CREATE; mdt_fail_write(env, info->mti_mdt->mdt_bottom, OBD_FAIL_MDS_SETXATTR_WRITE); buf->lb_buf = xattr; buf->lb_len = xattr_len; rc = mo_xattr_set(env, child, buf, xattr_name, flags); /* update ctime after xattr changed */ if (rc == 0) { ma->ma_attr_flags |= MDS_PERM_BYPASS; mo_attr_set(env, child, ma); } } } else if (valid & OBD_MD_FLXATTRRM) { rc = mo_xattr_del(env, child, xattr_name); /* update ctime after xattr changed */ if (rc == 0) { ma->ma_attr_flags |= MDS_PERM_BYPASS; mo_attr_set(env, child, ma); } } else { CDEBUG(D_INFO, "valid bits: "LPX64"\n", valid); rc = -EINVAL; } if (rc == 0) mdt_counter_incr(req, LPROC_MDT_SETXATTR); EXIT; out_unlock: mdt_object_unlock_put(info, obj, lh, rc); if (unlikely(new_xattr != NULL)) lustre_posix_acl_xattr_free(new_xattr, xattr_len); out: mdt_exit_ucred(info); return rc; }
/* * VBR: we save three versions in reply: * 0 - parent. Check that parent version is the same during replay. * 1 - name. Version of 'name' if file exists with the same name or * ENOENT_VERSION, it is needed because file may appear due to missed replays. * 2 - child. Version of child by FID. Must be ENOENT. It is mostly sanity * check. */ static int mdt_md_create(struct mdt_thread_info *info) { struct mdt_device *mdt = info->mti_mdt; struct mdt_object *parent; struct mdt_object *child; struct mdt_lock_handle *lh; struct mdt_body *repbody; struct md_attr *ma = &info->mti_attr; struct mdt_reint_record *rr = &info->mti_rr; struct lu_name *lname; int rc; ENTRY; DEBUG_REQ(D_INODE, mdt_info_req(info), "Create (%s->"DFID") in "DFID, rr->rr_name, PFID(rr->rr_fid2), PFID(rr->rr_fid1)); if (fid_is_obf(rr->rr_fid1) || fid_is_dot_lustre(rr->rr_fid1)) RETURN(-EPERM); repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY); lh = &info->mti_lh[MDT_LH_PARENT]; mdt_lock_pdo_init(lh, LCK_PW, rr->rr_name, rr->rr_namelen); parent = mdt_object_find_lock(info, rr->rr_fid1, lh, MDS_INODELOCK_UPDATE); if (IS_ERR(parent)) RETURN(PTR_ERR(parent)); rc = mdt_version_get_check_save(info, parent, 0); if (rc) GOTO(out_put_parent, rc); /* * Check child name version during replay. * During create replay a file may exist with same name. */ lname = mdt_name(info->mti_env, (char *)rr->rr_name, rr->rr_namelen); rc = mdt_lookup_version_check(info, parent, lname, &info->mti_tmp_fid1, 1); if (rc == 0) GOTO(out_put_parent, rc = -EEXIST); /* -ENOENT is expected here */ if (rc != -ENOENT) GOTO(out_put_parent, rc); /* save version of file name for replay, it must be ENOENT here */ mdt_enoent_version_save(info, 1); child = mdt_object_new(info->mti_env, mdt, rr->rr_fid2); if (likely(!IS_ERR(child))) { struct md_object *next = mdt_object_child(parent); if (mdt_object_remote(child)) { struct seq_server_site *ss; struct lu_ucred *uc = mdt_ucred(info); if (!md_capable(uc, CFS_CAP_SYS_ADMIN)) { if (uc->uc_gid != mdt->mdt_enable_remote_dir_gid && mdt->mdt_enable_remote_dir_gid != -1) { CERROR("%s: Creating remote dir is only" " permitted for administrator or" " set mdt_enable_remote_dir_gid:" " rc = %d\n", mdt_obd_name(mdt), -EPERM); GOTO(out_put_child, rc = -EPERM); } } ss = mdt_seq_site(mdt); if (ss->ss_node_id != 0 && mdt->mdt_enable_remote_dir == 0) { CERROR("%s: remote dir is only permitted on" " MDT0 or set_param" " mdt.*.enable_remote_dir=1\n", mdt_obd_name(mdt)); GOTO(out_put_child, rc = -EPERM); } if (!mdt_is_dne_client(mdt_info_req(info)->rq_export)) { /* Return -EIO for old client */ GOTO(out_put_child, rc = -EIO); } } ma->ma_need = MA_INODE; ma->ma_valid = 0; /* capa for cross-ref will be stored here */ ma->ma_capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1); LASSERT(ma->ma_capa); mdt_fail_write(info->mti_env, info->mti_mdt->mdt_bottom, OBD_FAIL_MDS_REINT_CREATE_WRITE); /* Version of child will be updated on disk. */ tgt_vbr_obj_set(info->mti_env, mdt_obj2dt(child)); rc = mdt_version_get_check_save(info, child, 2); if (rc) GOTO(out_put_child, rc); /* Let lower layer know current lock mode. */ info->mti_spec.sp_cr_mode = mdt_dlm_mode2mdl_mode(lh->mlh_pdo_mode); /* * Do not perform lookup sanity check. We know that name does * not exist. */ info->mti_spec.sp_cr_lookup = 0; info->mti_spec.sp_feat = &dt_directory_features; rc = mdo_create(info->mti_env, next, lname, mdt_object_child(child), &info->mti_spec, ma); if (rc == 0) rc = mdt_attr_get_complex(info, child, ma); if (rc == 0) { /* Return fid & attr to client. */ if (ma->ma_valid & MA_INODE) mdt_pack_attr2body(info, repbody, &ma->ma_attr, mdt_object_fid(child)); } out_put_child: mdt_object_put(info->mti_env, child); } else { rc = PTR_ERR(child); } mdt_create_pack_capa(info, rc, child, repbody); out_put_parent: mdt_object_unlock_put(info, parent, lh, rc); RETURN(rc); }