int mdt_capa_keys_init(const struct lu_env *env, struct mdt_device *mdt) { struct lustre_capa_key *keys = mdt->mdt_capa_keys; struct mdt_thread_info *mti; struct dt_object *obj; struct lu_attr *la; mdsno_t mdsnum; unsigned long size; int rc; ENTRY; mdsnum = mdt_seq_site(mdt)->ss_node_id; mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key); LASSERT(mti != NULL); la = &mti->mti_attr.ma_attr; obj = mdt->mdt_ck_obj; rc = obj->do_ops->do_attr_get(env, mdt->mdt_ck_obj, la, BYPASS_CAPA); if (rc) RETURN(rc); size = (unsigned long)la->la_size; if (size == 0) { int i; for (i = 0; i < 2; i++) { make_capa_key(&keys[i], mdsnum, i); DEBUG_CAPA_KEY(D_SEC, &keys[i], "initializing"); } rc = write_capa_keys(env, mdt, keys); if (rc) { CERROR("error writing MDS %s: rc %d\n", CAPA_KEYS, rc); RETURN(rc); } } else { rc = read_capa_keys(env, mdt, keys); if (rc) { CERROR("error reading MDS %s: rc %d\n", CAPA_KEYS, rc); RETURN(rc); } } set_capa_key_expiry(mdt); cfs_timer_arm(&mdt->mdt_ck_timer, mdt->mdt_ck_expiry); CDEBUG(D_SEC, "mds_ck_timer %lu\n", mdt->mdt_ck_expiry); RETURN(0); }
static int mdt_ck_thread_main(void *args) { struct mdt_device *mdt = args; struct ptlrpc_thread *thread = &mdt->mdt_ck_thread; struct lustre_capa_key *bkey = &mdt->mdt_capa_keys[0], *rkey = &mdt->mdt_capa_keys[1]; struct lustre_capa_key *tmp; struct lu_env env; struct mdt_thread_info *info; struct md_device *next; struct l_wait_info lwi = { 0 }; mdsno_t mdsnum; int rc; ENTRY; unshare_fs_struct(); cfs_block_allsigs(); thread_set_flags(thread, SVC_RUNNING); wake_up(&thread->t_ctl_waitq); rc = lu_env_init(&env, LCT_MD_THREAD|LCT_REMEMBER|LCT_NOREF); if (rc) RETURN(rc); thread->t_env = &env; env.le_ctx.lc_thread = thread; env.le_ctx.lc_cookie = 0x1; info = lu_context_key_get(&env.le_ctx, &mdt_thread_key); LASSERT(info != NULL); tmp = &info->mti_capa_key; mdsnum = mdt_seq_site(mdt)->ss_node_id; while (1) { l_wait_event(thread->t_ctl_waitq, thread_is_stopping(thread) || thread_is_event(thread), &lwi); if (thread_is_stopping(thread)) break; thread_clear_flags(thread, SVC_EVENT); if (cfs_time_before(cfs_time_current(), mdt->mdt_ck_expiry)) break; *tmp = *rkey; make_capa_key(tmp, mdsnum, rkey->lk_keyid); next = mdt->mdt_child; rc = next->md_ops->mdo_update_capa_key(&env, next, tmp); if (!rc) { spin_lock(&capa_lock); *bkey = *rkey; *rkey = *tmp; spin_unlock(&capa_lock); rc = write_capa_keys(&env, mdt, mdt->mdt_capa_keys); if (rc) { spin_lock(&capa_lock); *rkey = *bkey; memset(bkey, 0, sizeof(*bkey)); spin_unlock(&capa_lock); } else { set_capa_key_expiry(mdt); DEBUG_CAPA_KEY(D_SEC, rkey, "new"); } } if (rc) { DEBUG_CAPA_KEY(D_ERROR, rkey, "update failed for"); /* next retry is in 300 sec */ mdt->mdt_ck_expiry = jiffies + 300 * HZ; } cfs_timer_arm(&mdt->mdt_ck_timer, mdt->mdt_ck_expiry); CDEBUG(D_SEC, "mdt_ck_timer %lu\n", mdt->mdt_ck_expiry); } lu_env_fini(&env); thread_set_flags(thread, SVC_STOPPED); wake_up(&thread->t_ctl_waitq); RETURN(0); }
/* * 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)); 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)); if (mdt_object_obf(parent)) GOTO(out_put_parent, rc = -EPERM); 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)) { CERROR("%s: Creating remote dir is only " "permitted for administrator: rc = %d\n", mdt2obd_dev(mdt)->obd_name, -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", mdt2obd_dev(mdt)->obd_name); GOTO(out_put_child, rc = -EPERM); } } 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. */ info->mti_mos = 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); }