tpm: have event log use the tpm_chip (748935ee) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/char/tpm/tpm-chip.c

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -127,6 +127,7 @@ static void tpm_dev_release(struct device *dev)
	idr_remove(&dev_nums_idr, chip->dev_num);		idr_remove(&dev_nums_idr, chip->dev_num);
	mutex_unlock(&idr_lock);		mutex_unlock(&idr_lock);

			kfree(chip->log.bios_event_log);
	kfree(chip);		kfree(chip);
	}		}

	@@ -345,7 +346,7 @@ int tpm_chip_register(struct tpm_chip *chip)
	tpm_sysfs_add_device(chip);		tpm_sysfs_add_device(chip);

	rc = tpm_bios_log_setup(chip);		rc = tpm_bios_log_setup(chip);
	if (rc)		if (rc == -ENODEV)
	return rc;		return rc;

	tpm_add_ppi(chip);		tpm_add_ppi(chip);

drivers/char/tpm/tpm.h

+11 −0

Original line number	Original line	Diff line number	Diff line
	@@ -35,6 +35,8 @@
	#include <linux/cdev.h>		#include <linux/cdev.h>
	#include <linux/highmem.h>		#include <linux/highmem.h>

			#include "tpm_eventlog.h"

	enum tpm_const {		enum tpm_const {
	TPM_MINOR = 224, /* officially assigned */		TPM_MINOR = 224, /* officially assigned */
	TPM_BUFSIZE = 4096,		TPM_BUFSIZE = 4096,
	@@ -146,6 +148,11 @@ enum tpm_chip_flags {
	TPM_CHIP_FLAG_HAVE_TIMEOUTS = BIT(4),		TPM_CHIP_FLAG_HAVE_TIMEOUTS = BIT(4),
	};		};

			struct tpm_chip_seqops {
			struct tpm_chip *chip;
			const struct seq_operations *seqops;
			};

	struct tpm_chip {		struct tpm_chip {
	struct device dev;		struct device dev;
	struct cdev cdev;		struct cdev cdev;
	@@ -157,6 +164,10 @@ struct tpm_chip {
	struct rw_semaphore ops_sem;		struct rw_semaphore ops_sem;
	const struct tpm_class_ops *ops;		const struct tpm_class_ops *ops;

			struct tpm_bios_log log;
			struct tpm_chip_seqops bin_log_seqops;
			struct tpm_chip_seqops ascii_log_seqops;

	unsigned int flags;		unsigned int flags;

	int dev_num; /* /dev/tpm# */		int dev_num; /* /dev/tpm# */

drivers/char/tpm/tpm_acpi.c

+11 −4

Original line number	Original line	Diff line number	Diff line
	@@ -45,13 +45,15 @@ struct acpi_tcpa {
	};		};

	/* read binary bios log */		/* read binary bios log */
	int read_log(struct tpm_bios_log *log)		int read_log(struct tpm_chip *chip)
	{		{
	struct acpi_tcpa *buff;		struct acpi_tcpa *buff;
	acpi_status status;		acpi_status status;
	void __iomem *virt;		void __iomem *virt;
	u64 len, start;		u64 len, start;
			struct tpm_bios_log *log;

			log = &chip->log;
	if (log->bios_event_log != NULL) {		if (log->bios_event_log != NULL) {
	printk(KERN_ERR		printk(KERN_ERR
	"%s: ERROR - Eventlog already initialized\n",		"%s: ERROR - Eventlog already initialized\n",
	@@ -97,13 +99,18 @@ int read_log(struct tpm_bios_log *log)

	virt = acpi_os_map_iomem(start, len);		virt = acpi_os_map_iomem(start, len);
	if (!virt) {		if (!virt) {
	kfree(log->bios_event_log);
	printk("%s: ERROR - Unable to map memory\n", __func__);		printk("%s: ERROR - Unable to map memory\n", __func__);
	return -EIO;		goto err;
	}		}

	memcpy_fromio(log->bios_event_log, virt, len);		memcpy_fromio(log->bios_event_log, virt, len);

	acpi_os_unmap_iomem(virt, len);		acpi_os_unmap_iomem(virt, len);
	return 0;		return 0;

			err:
			kfree(log->bios_event_log);
			log->bios_event_log = NULL;
			return -EIO;

	}		}

drivers/char/tpm/tpm_eventlog.c

+56 −30

Original line number	Original line	Diff line number	Diff line
	@@ -73,7 +73,8 @@ static const char* tcpa_pc_event_id_strings[] = {
	static void tpm_bios_measurements_start(struct seq_file m, loff_t *pos)		static void tpm_bios_measurements_start(struct seq_file m, loff_t *pos)
	{		{
	loff_t i;		loff_t i;
	struct tpm_bios_log *log = m->private;		struct tpm_chip *chip = m->private;
			struct tpm_bios_log *log = &chip->log;
	void *addr = log->bios_event_log;		void *addr = log->bios_event_log;
	void *limit = log->bios_event_log_end;		void *limit = log->bios_event_log_end;
	struct tcpa_event *event;		struct tcpa_event *event;
	@@ -120,7 +121,8 @@ static void tpm_bios_measurements_next(struct seq_file m, void *v,
	loff_t *pos)		loff_t *pos)
	{		{
	struct tcpa_event *event = v;		struct tcpa_event *event = v;
	struct tpm_bios_log *log = m->private;		struct tpm_chip *chip = m->private;
			struct tpm_bios_log *log = &chip->log;
	void *limit = log->bios_event_log_end;		void *limit = log->bios_event_log_end;
	u32 converted_event_size;		u32 converted_event_size;
	u32 converted_event_type;		u32 converted_event_type;
	@@ -261,13 +263,10 @@ static int tpm_binary_bios_measurements_show(struct seq_file m, void v)
	static int tpm_bios_measurements_release(struct inode *inode,		static int tpm_bios_measurements_release(struct inode *inode,
	struct file *file)		struct file *file)
	{		{
	struct seq_file *seq = file->private_data;		struct seq_file seq = (struct seq_file )file->private_data;
	struct tpm_bios_log *log = seq->private;		struct tpm_chip chip = (struct tpm_chip )seq->private;

	if (log) {		put_device(&chip->dev);
	kfree(log->bios_event_log);
	kfree(log);
	}

	return seq_release(inode, file);		return seq_release(inode, file);
	}		}
	@@ -323,33 +322,30 @@ static int tpm_bios_measurements_open(struct inode *inode,
	struct file *file)		struct file *file)
	{		{
	int err;		int err;
	struct tpm_bios_log *log;
	struct seq_file *seq;		struct seq_file *seq;
	const struct seq_operations *seqops =		struct tpm_chip_seqops *chip_seqops;
	(const struct seq_operations *)inode->i_private;		const struct seq_operations *seqops;
			struct tpm_chip *chip;
	log = kzalloc(sizeof(struct tpm_bios_log), GFP_KERNEL);
	if (!log)		inode_lock(inode);
	return -ENOMEM;		if (!inode->i_private) {
			inode_unlock(inode);
	if ((err = read_log(log)))		return -ENODEV;
	goto out_free;		}
			chip_seqops = (struct tpm_chip_seqops *)inode->i_private;
			seqops = chip_seqops->seqops;
			chip = chip_seqops->chip;
			get_device(&chip->dev);
			inode_unlock(inode);

	/* now register seq file */		/* now register seq file */
	err = seq_open(file, seqops);		err = seq_open(file, seqops);
	if (!err) {		if (!err) {
	seq = file->private_data;		seq = file->private_data;
	seq->private = log;		seq->private = chip;
	} else {
	goto out_free;
	}		}

	out:
	return err;		return err;
	out_free:
	kfree(log->bios_event_log);
	kfree(log);
	goto out;
	}		}

	static const struct file_operations tpm_bios_measurements_ops = {		static const struct file_operations tpm_bios_measurements_ops = {
	@@ -363,10 +359,22 @@ int tpm_bios_log_setup(struct tpm_chip *chip)
	{		{
	const char *name = dev_name(&chip->dev);		const char *name = dev_name(&chip->dev);
	unsigned int cnt;		unsigned int cnt;
			int rc = 0;

	if (chip->flags & TPM_CHIP_FLAG_TPM2)		if (chip->flags & TPM_CHIP_FLAG_TPM2)
	return 0;		return 0;

			rc = read_log(chip);
			/*
			* read_log failure means event log is not supported except for ENOMEM.
			*/
			if (rc < 0) {
			if (rc == -ENOMEM)
			return -ENODEV;
			else
			return rc;
			}

	cnt = 0;		cnt = 0;
	chip->bios_dir[cnt] = securityfs_create_dir(name, NULL);		chip->bios_dir[cnt] = securityfs_create_dir(name, NULL);
	/* NOTE: securityfs_create_dir can return ENODEV if securityfs is		/* NOTE: securityfs_create_dir can return ENODEV if securityfs is
	@@ -376,19 +384,25 @@ int tpm_bios_log_setup(struct tpm_chip *chip)
	goto err;		goto err;
	cnt++;		cnt++;

			chip->bin_log_seqops.chip = chip;
			chip->bin_log_seqops.seqops = &tpm_binary_b_measurements_seqops;

	chip->bios_dir[cnt] =		chip->bios_dir[cnt] =
	securityfs_create_file("binary_bios_measurements",		securityfs_create_file("binary_bios_measurements",
	0440, chip->bios_dir[0],		0440, chip->bios_dir[0],
	(void *)&tpm_binary_b_measurements_seqops,		(void *)&chip->bin_log_seqops,
	&tpm_bios_measurements_ops);		&tpm_bios_measurements_ops);
	if (IS_ERR(chip->bios_dir[cnt]))		if (IS_ERR(chip->bios_dir[cnt]))
	goto err;		goto err;
	cnt++;		cnt++;

			chip->ascii_log_seqops.chip = chip;
			chip->ascii_log_seqops.seqops = &tpm_ascii_b_measurements_seqops;

	chip->bios_dir[cnt] =		chip->bios_dir[cnt] =
	securityfs_create_file("ascii_bios_measurements",		securityfs_create_file("ascii_bios_measurements",
	0440, chip->bios_dir[0],		0440, chip->bios_dir[0],
	(void *)&tpm_ascii_b_measurements_seqops,		(void *)&chip->ascii_log_seqops,
	&tpm_bios_measurements_ops);		&tpm_bios_measurements_ops);
	if (IS_ERR(chip->bios_dir[cnt]))		if (IS_ERR(chip->bios_dir[cnt]))
	goto err;		goto err;
	@@ -405,7 +419,19 @@ int tpm_bios_log_setup(struct tpm_chip *chip)
	void tpm_bios_log_teardown(struct tpm_chip *chip)		void tpm_bios_log_teardown(struct tpm_chip *chip)
	{		{
	int i;		int i;
			struct inode *inode;

	for (i = (TPM_NUM_EVENT_LOG_FILES - 1); i >= 0; i--)		/* securityfs_remove currently doesn't take care of handling sync
			* between removal and opening of pseudo files. To handle this, a
			* workaround is added by making i_private = NULL here during removal
			* and to check it during open(), both within inode_lock()/unlock().
			* This design ensures that open() either safely gets kref or fails.
			*/
			for (i = (TPM_NUM_EVENT_LOG_FILES - 1); i >= 0; i--) {
			inode = d_inode(chip->bios_dir[i]);
			inode_lock(inode);
			inode->i_private = NULL;
			inode_unlock(inode);
	securityfs_remove(chip->bios_dir[i]);		securityfs_remove(chip->bios_dir[i]);
	}		}
			}

drivers/char/tpm/tpm_eventlog.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -73,7 +73,7 @@ enum tcpa_pc_event_ids {
	HOST_TABLE_OF_DEVICES,		HOST_TABLE_OF_DEVICES,
	};		};

	int read_log(struct tpm_bios_log *log);		int read_log(struct tpm_chip *chip);

	#if defined(CONFIG_TCG_IBMVTPM) \|\| defined(CONFIG_TCG_IBMVTPM_MODULE) \|\| \		#if defined(CONFIG_TCG_IBMVTPM) \|\| defined(CONFIG_TCG_IBMVTPM_MODULE) \|\| \
	defined(CONFIG_ACPI)		defined(CONFIG_ACPI)