Linux可信计算机制模块详细分析之核心文件分析（8）tpm.c核心代码注释（中）

/*设置TPM命令格式*/

ssize_t tpm_getcap(struct device *dev, __be32 subcap_id, cap_t *cap,

const char *desc)

{

struct tpm_cmd_t tpm_cmd;

int rc;

struct tpm_chip *chip = dev_get_drvdata(dev);

tpm_cmd.header.in = tpm_getcap_header;

if (subcap_id == CAP_VERSION_1_1 || subcap_id == CAP_VERSION_1_2) {

tpm_cmd.params.getcap_in.cap = subcap_id;

/*subcap field not necessary */

tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(0);

tpm_cmd.header.in.length -= cpu_to_be32(sizeof(__be32));

} else {

if (subcap_id == TPM_CAP_FLAG_PERM ||

subcap_id == TPM_CAP_FLAG_VOL)

tpm_cmd.params.getcap_in.cap = TPM_CAP_FLAG;

else

tpm_cmd.params.getcap_in.cap = TPM_CAP_PROP;

tpm_cmd.params.getcap_in.subcap_size = cpu_to_be32(4);

tpm_cmd.params.getcap_in.subcap = subcap_id;

}

rc = transmit_cmd(chip, &tpm_cmd, TPM_INTERNAL_RESULT_SIZE, desc);

if (!rc)

*cap = tpm_cmd.params.getcap_out.cap;

return rc;

}

/*TPM设备自检，成功返回0*/

static int tpm_continue_selftest(struct tpm_chip *chip)

{

int rc;

struct tpm_cmd_t cmd;

cmd.header.in = continue_selftest_header;

rc = transmit_cmd(chip, &cmd, CONTINUE_SELFTEST_RESULT_SIZE,

"continue selftest");

return rc;

}

/*返回tpm设备的序号，对应/dev/tpm#中#的值*/

static struct tpm_chip *tpm_chip_find_get(int chip_num)

{

struct tpm_chip *pos, *chip = NULL;

rcu_read_lock();

list_for_each_entry_rcu(pos, &tpm_chip_list, list) {

if (chip_num != TPM_ANY_NUM && chip_num != pos->dev_num)

continue;

if (try_module_get(pos->dev->driver->owner)) {

chip = pos;

break;

}

}

rcu_read_unlock();

return chip;

}

/*读取TPM设备中平台配置寄存器中的数据*/

static int __tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)

{

int rc;

struct tpm_cmd_t cmd;

cmd.header.in = pcrread_header;

cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx);

rc = transmit_cmd(chip, &cmd, READ_PCR_RESULT_SIZE,

"attempting to read a pcr value");

if (rc == 0)

memcpy(res_buf, cmd.params.pcrread_out.pcr_result,

TPM_DIGEST_SIZE);

return rc;

}

/*读取TPM设备中平台配置寄存器中的数据，对__tpm_pcr_read()函数的进一步封装*/

int tpm_pcr_read(u32 chip_num, int pcr_idx, u8 *res_buf)

{

struct tpm_chip *chip;

int rc;

/*获取tpm设备序号*/

chip = tpm_chip_find_get(chip_num);

if (chip == NULL)

return -ENODEV;

/*读取pcr中的数据*/

rc = __tpm_pcr_read(chip, pcr_idx, res_buf);

tpm_chip_put(chip);

return rc;

}

/*扩充、更新平台配置寄存器pcr中的数据*/

int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash)

{

struct tpm_cmd_t cmd;

int rc;

struct tpm_chip *chip;

chip = tpm_chip_find_get(chip_num);

if (chip == NULL)

return -ENODEV;

cmd.header.in = pcrextend_header;

cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx);

memcpy(cmd.params.pcrextend_in.hash, hash, TPM_DIGEST_SIZE);

rc = transmit_cmd(chip, &cmd, EXTEND_PCR_RESULT_SIZE,

"attempting extend a PCR value");

tpm_chip_put(chip);

return rc;

}

/*12.www.qixoo.qixoo.com/在接受下次命令前，TPM设备状态自检。当检测状态成功可以接受命令时，返回0*/

int tpm_do_selftest(struct tpm_chip *chip)

{

int rc;

unsigned int loops;

unsigned int delay_msec = 1000;

unsigned long duration;

struct tpm_cmd_t cmd;

duration = tpm_calc_ordinal_duration(chip, TPM_ORD_CONTINUE_SELFTEST);

loops = jiffies_to_msecs(duration) / delay_msec;

rc = tpm_continue_selftest(chip);

/*在挂起或恢复期间，没有TPM设备驱动，可能失败返回10 (BAD_ORDINAL)或者28 (FAILEDSELFTEST)*/

if (rc)

return rc;

do {

/* 尝试读取pcr中的数据 */

cmd.header.in = pcrread_header;

cmd.params.pcrread_in.pcr_idx = cpu_to_be32(0);

rc = tpm_transmit(chip, (u8 *) &cmd, READ_PCR_RESULT_SIZE);

if (rc < TPM_HEADER_SIZE)

return -EFAULT;

rc = be32_to_cpu(cmd.header.out.return_code);

if (rc == TPM_ERR_DISABLED || rc == TPM_ERR_DEACTIVATED) {

dev_info(chip->dev, "TPM is disabled/deactivated (0x%X)\n", rc);

/*TPM状态是disabled 或 deactivated，TPM设备驱动可以继续运行，TPM设备可以接受处理命令*/

return 0;

}

if (rc != TPM_WARN_DOING_SELFTEST)

return rc;

msleep(delay_msec);

} while (--loops > 0);

return rc;

}

/*显示设定的TPM设备执行命令的时间*/

ssize_t tpm_show_durations(struct device *dev, struct device_attribute *attr,

char *buf)

{

struct tpm_chip *chip = dev_get_drvdata(dev);

if (chip->vendor.duration[TPM_LONG] == 0)

return 0;

return sprintf(buf, "%d %d %d [%s]\n",

jiffies_to_usecs(chip->vendor.duration[TPM_SHORT]),

jiffies_to_usecs(chip->vendor.duration[TPM_MEDIUM]),

jiffies_to_usecs(chip->vendor.duration[TPM_LONG]),

chip->vendor.duration_adjusted

? "adjusted" : "original");

}

/*显示设定的超时时间值*/

ssize_t tpm_show_timeouts(struct device *dev, struct device_attribute *attr,

char *buf)

{

struct tpm_chip *chip = dev_get_drvdata(dev);

return sprintf(buf, "%d %d %d %d [%s]\n",

jiffies_to_usecs(chip->vendor.timeout_a),

jiffies_to_usecs(chip->vendor.timeout_b),

jiffies_to_usecs(chip->vendor.timeout_c),

jiffies_to_usecs(chip->vendor.timeout_d),

chip->vendor.timeout_adjusted

? "adjusted" : "original");

}

/*取消TPM设备操作*/

ssize_t tpm_store_cancel(struct device *dev, struct device_attribute *attr,

const char *buf, size_t count)

{

struct tpm_chip *chip = dev_get_drvdata(dev);

if (chip == NULL)

return 0;

/*调用tpm_chip结构体中vendor字段指向的tpm_vendor_specific 结构体中的cancel函数成员*/

chip->vendor.cancel(chip);

return count;

}