cxl/test/mem.c

166 	struct cxl_mockmem_data *mdata = dev_get_drvdata(dev);
170 	return &mdata->mes.mock_logs[log_type];
325 	struct cxl_mockmem_data *mdata = dev_get_drvdata(dev);
326 	struct mock_event_store *mes = &mdata->mes;
337 	cxl_mem_get_event_records(mdata->mds, mes->ev_status);
449 	struct cxl_mockmem_data *mdata = dev_get_drvdata(cxlds->dev);
458 	mdata->timestamp = le64_to_cpu(ts->timestamp);
614 static int mock_sanitize(struct cxl_mockmem_data *mdata,
617 	struct cxl_memdev_state *mds = mdata->mds;
626 	if (mdata->security_state & CXL_PMEM_SEC_STATE_USER_PASS_SET) {
630 	if (mdata->security_state & CXL_PMEM_SEC_STATE_LOCKED) {
637 				  msecs_to_jiffies(mdata->sanitize_timeout))) {
647 static int mock_secure_erase(struct cxl_mockmem_data *mdata,
656 	if (mdata->security_state & CXL_PMEM_SEC_STATE_USER_PASS_SET) {
661 	if (mdata->security_state & CXL_PMEM_SEC_STATE_LOCKED) {
669 static int mock_get_security_state(struct cxl_mockmem_data *mdata,
678 	memcpy(cmd->payload_out, &mdata->security_state, sizeof(u32));
683 static void master_plimit_check(struct cxl_mockmem_data *mdata)
685 	if (mdata->master_limit == PASS_TRY_LIMIT)
687 	mdata->master_limit++;
688 	if (mdata->master_limit == PASS_TRY_LIMIT)
689 		mdata->security_state |= CXL_PMEM_SEC_STATE_MASTER_PLIMIT;
692 static void user_plimit_check(struct cxl_mockmem_data *mdata)
694 	if (mdata->user_limit == PASS_TRY_LIMIT)
696 	mdata->user_limit++;
697 	if (mdata->user_limit == PASS_TRY_LIMIT)
698 		mdata->security_state |= CXL_PMEM_SEC_STATE_USER_PLIMIT;
701 static int mock_set_passphrase(struct cxl_mockmem_data *mdata,
712 	if (mdata->security_state & CXL_PMEM_SEC_STATE_FROZEN) {
720 		if (mdata->security_state & CXL_PMEM_SEC_STATE_MASTER_PLIMIT) {
728 		if (mdata->security_state & CXL_PMEM_SEC_STATE_USER_PASS_SET) {
732 		if (memcmp(mdata->master_pass, set_pass->old_pass, NVDIMM_PASSPHRASE_LEN)) {
733 			master_plimit_check(mdata);
737 		memcpy(mdata->master_pass, set_pass->new_pass, NVDIMM_PASSPHRASE_LEN);
738 		mdata->security_state |= CXL_PMEM_SEC_STATE_MASTER_PASS_SET;
742 		if (mdata->security_state & CXL_PMEM_SEC_STATE_USER_PLIMIT) {
746 		if (memcmp(mdata->user_pass, set_pass->old_pass, NVDIMM_PASSPHRASE_LEN)) {
747 			user_plimit_check(mdata);
751 		memcpy(mdata->user_pass, set_pass->new_pass, NVDIMM_PASSPHRASE_LEN);
752 		mdata->security_state |= CXL_PMEM_SEC_STATE_USER_PASS_SET;
761 static int mock_disable_passphrase(struct cxl_mockmem_data *mdata,
772 	if (mdata->security_state & CXL_PMEM_SEC_STATE_FROZEN) {
780 		if (mdata->security_state & CXL_PMEM_SEC_STATE_MASTER_PLIMIT) {
785 		if (!(mdata->security_state & CXL_PMEM_SEC_STATE_MASTER_PASS_SET)) {
790 		if (memcmp(dis_pass->pass, mdata->master_pass, NVDIMM_PASSPHRASE_LEN)) {
791 			master_plimit_check(mdata);
796 		mdata->master_limit = 0;
797 		memset(mdata->master_pass, 0, NVDIMM_PASSPHRASE_LEN);
798 		mdata->security_state &= ~CXL_PMEM_SEC_STATE_MASTER_PASS_SET;
802 		if (mdata->security_state & CXL_PMEM_SEC_STATE_USER_PLIMIT) {
807 		if (!(mdata->security_state & CXL_PMEM_SEC_STATE_USER_PASS_SET)) {
812 		if (memcmp(dis_pass->pass, mdata->user_pass, NVDIMM_PASSPHRASE_LEN)) {
813 			user_plimit_check(mdata);
818 		mdata->user_limit = 0;
819 		memset(mdata->user_pass, 0, NVDIMM_PASSPHRASE_LEN);
820 		mdata->security_state &= ~(CXL_PMEM_SEC_STATE_USER_PASS_SET |
832 static int mock_freeze_security(struct cxl_mockmem_data *mdata,
841 	if (mdata->security_state & CXL_PMEM_SEC_STATE_FROZEN)
844 	mdata->security_state |= CXL_PMEM_SEC_STATE_FROZEN;
848 static int mock_unlock_security(struct cxl_mockmem_data *mdata,
857 	if (mdata->security_state & CXL_PMEM_SEC_STATE_FROZEN) {
862 	if (!(mdata->security_state & CXL_PMEM_SEC_STATE_USER_PASS_SET)) {
867 	if (mdata->security_state & CXL_PMEM_SEC_STATE_USER_PLIMIT) {
872 	if (!(mdata->security_state & CXL_PMEM_SEC_STATE_LOCKED)) {
877 	if (memcmp(cmd->payload_in, mdata->user_pass, NVDIMM_PASSPHRASE_LEN)) {
878 		if (++mdata->user_limit == PASS_TRY_LIMIT)
879 			mdata->security_state |= CXL_PMEM_SEC_STATE_USER_PLIMIT;
884 	mdata->user_limit = 0;
885 	mdata->security_state &= ~CXL_PMEM_SEC_STATE_LOCKED;
889 static int mock_passphrase_secure_erase(struct cxl_mockmem_data *mdata,
901 	if (mdata->security_state & CXL_PMEM_SEC_STATE_FROZEN) {
906 	if (mdata->security_state & CXL_PMEM_SEC_STATE_USER_PLIMIT &&
912 	if (mdata->security_state & CXL_PMEM_SEC_STATE_MASTER_PLIMIT &&
927 		if (mdata->security_state & CXL_PMEM_SEC_STATE_MASTER_PASS_SET) {
928 			if (memcmp(mdata->master_pass, erase->pass,
930 				master_plimit_check(mdata);
934 			mdata->master_limit = 0;
935 			mdata->user_limit = 0;
936 			mdata->security_state &= ~CXL_PMEM_SEC_STATE_USER_PASS_SET;
937 			memset(mdata->user_pass, 0, NVDIMM_PASSPHRASE_LEN);
938 			mdata->security_state &= ~CXL_PMEM_SEC_STATE_LOCKED;
958 		if (mdata->security_state & CXL_PMEM_SEC_STATE_USER_PASS_SET) {
959 			if (memcmp(mdata->user_pass, erase->pass,
961 				user_plimit_check(mdata);
965 			mdata->user_limit = 0;
966 			mdata->security_state &= ~CXL_PMEM_SEC_STATE_USER_PASS_SET;
967 			memset(mdata->user_pass, 0, NVDIMM_PASSPHRASE_LEN);
987 static int mock_get_lsa(struct cxl_mockmem_data *mdata,
991 	void *lsa = mdata->lsa;
1007 static int mock_set_lsa(struct cxl_mockmem_data *mdata,
1011 	void *lsa = mdata->lsa;
1242 static int mock_fw_info(struct cxl_mockmem_data *mdata,
1247 		.slot_info = (mdata->fw_slot & 0x7) |
1248 			     ((mdata->fw_staged & 0x7) << 3),
1264 static int mock_transfer_fw(struct cxl_mockmem_data *mdata,
1268 	void *fw = mdata->fw;
1284 		mdata->fw_size = offset + length;
1300 static int mock_activate_fw(struct cxl_mockmem_data *mdata,
1310 		mdata->fw_slot = activate->slot;
1311 		mdata->fw_staged = 0;
1314 		mdata->fw_staged = activate->slot;
1326 	struct cxl_mockmem_data *mdata = dev_get_drvdata(dev);
1346 		rc = mock_get_lsa(mdata, cmd);
1358 		rc = mock_set_lsa(mdata, cmd);
1364 		rc = mock_sanitize(mdata, cmd);
1367 		rc = mock_secure_erase(mdata, cmd);
1370 		rc = mock_get_security_state(mdata, cmd);
1373 		rc = mock_set_passphrase(mdata, cmd);
1376 		rc = mock_disable_passphrase(mdata, cmd);
1379 		rc = mock_freeze_security(mdata, cmd);
1382 		rc = mock_unlock_security(mdata, cmd);
1385 		rc = mock_passphrase_secure_erase(mdata, cmd);
1397 		rc = mock_fw_info(mdata, cmd);
1400 		rc = mock_transfer_fw(mdata, cmd);
1403 		rc = mock_activate_fw(mdata, cmd);
1447 	struct cxl_mockmem_data *mdata;
1450 	mdata = devm_kzalloc(dev, sizeof(*mdata), GFP_KERNEL);
1451 	if (!mdata)
1453 	dev_set_drvdata(dev, mdata);
1455 	mdata->lsa = vmalloc(LSA_SIZE);
1456 	if (!mdata->lsa)
1458 	mdata->fw = vmalloc(FW_SIZE);
1459 	if (!mdata->fw)
1461 	mdata->fw_slot = 2;
1463 	rc = devm_add_action_or_reset(dev, label_area_release, mdata->lsa);
1467 	rc = devm_add_action_or_reset(dev, fw_buf_release, mdata->fw);
1475 	mdata->mds = mds;
1478 	mds->event.buf = (struct cxl_get_event_payload *) mdata->event_buf;
1507 	cxl_mock_add_event_logs(&mdata->mes);
1529 	struct cxl_mockmem_data *mdata = dev_get_drvdata(dev);
1532 			  !!(mdata->security_state & CXL_PMEM_SEC_STATE_LOCKED));
1538 	struct cxl_mockmem_data *mdata = dev_get_drvdata(dev);
1547 		if (!(mdata->security_state & CXL_PMEM_SEC_STATE_USER_PASS_SET))
1549 		mdata->security_state |= CXL_PMEM_SEC_STATE_LOCKED;
1550 		mdata->security_state &= ~mask;
1562 	struct cxl_mockmem_data *mdata = dev_get_drvdata(dev);
1570 	sha256_update(&sctx, mdata->fw, mdata->fw_size);
1592 	struct cxl_mockmem_data *mdata = dev_get_drvdata(dev);
1594 	return sysfs_emit(buf, "%lu\n", mdata->sanitize_timeout);
1601 	struct cxl_mockmem_data *mdata = dev_get_drvdata(dev);
1609 	mdata->sanitize_timeout = val;