Commit 74673fc5 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'next-tpm' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security 

Pull TPM updates from James Morris:

 - Support for partial reads of /dev/tpm0.

 - Clean up for TPM 1.x code: move the commands to tpm1-cmd.c and make
   everything to use the same data structure for building TPM commands
   i.e. struct tpm_buf.

* 'next-tpm' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security: (25 commits)
  tpm: add support for partial reads
  tpm: tpm_ibmvtpm: fix kdoc warnings
  tpm: fix kdoc for tpm2_flush_context_cmd()
  tpm: tpm_try_transmit() refactor error flow.
  tpm: use u32 instead of int for PCR index
  tpm1: reimplement tpm1_continue_selftest() using tpm_buf
  tpm1: reimplement SAVESTATE using tpm_buf
  tpm1: rename tpm1_pcr_read_dev to tpm1_pcr_read()
  tpm1: implement tpm1_pcr_read_dev() using tpm_buf structure
  tpm: tpm1: rewrite tpm1_get_random() using tpm_buf structure
  tpm: tpm-space.c remove unneeded semicolon
  tpm: tpm-interface.c drop unused macros
  tpm: add tpm_auto_startup() into tpm-interface.c
  tpm: factor out tpm_startup function
  tpm: factor out tpm 1.x pm suspend flow into tpm1-cmd.c
  tpm: move tpm 1.x selftest code from tpm-interface.c tpm1-cmd.c
  tpm: factor out tpm1_get_random into tpm1-cmd.c
  tpm: move tpm_getcap to tpm1-cmd.c
  tpm: move tpm1_pcr_extend to tpm1-cmd.c
  tpm: factor out tpm_get_timeouts()
  ...
parents 19f2e267 0db51ef2

drivers/char/tpm/Makefile

+13 −3
Original line number Diff line number Diff line
@@ -3,9 +3,19 @@ 
# Makefile for the kernel tpm device drivers.

#

obj-$(CONFIG_TCG_TPM) += tpm.o

tpm-y := tpm-interface.o tpm-dev.o tpm-sysfs.o tpm-chip.o tpm2-cmd.o \

	 tpm-dev-common.o tpmrm-dev.o eventlog/common.o eventlog/tpm1.o \

	 eventlog/tpm2.o tpm2-space.o

tpm-y := tpm-chip.o

tpm-y += tpm-dev-common.o

tpm-y += tpm-dev.o

tpm-y += tpm-interface.o

tpm-y += tpm1-cmd.o

tpm-y += tpm2-cmd.o

tpm-y += tpmrm-dev.o

tpm-y += tpm2-space.o

tpm-y += tpm-sysfs.o

tpm-y += eventlog/common.o

tpm-y += eventlog/tpm1.o

tpm-y += eventlog/tpm2.o



tpm-$(CONFIG_ACPI) += tpm_ppi.o eventlog/acpi.o

tpm-$(CONFIG_EFI) += eventlog/efi.o

tpm-$(CONFIG_OF) += eventlog/of.o

drivers/char/tpm/st33zp24/st33zp24.c

+1 −1
Original line number Diff line number Diff line
@@ -649,7 +649,7 @@ int st33zp24_pm_resume(struct device *dev) 
	} else {

		ret = tpm_pm_resume(dev);

		if (!ret)

			tpm_do_selftest(chip);

			tpm1_do_selftest(chip);

	}

	return ret;

} /* st33zp24_pm_resume() */

drivers/char/tpm/tpm-chip.c

+3 −8
Original line number Diff line number Diff line
@@ -451,14 +451,9 @@ int tpm_chip_register(struct tpm_chip *chip) 
{

	int rc;



	if (chip->ops->flags & TPM_OPS_AUTO_STARTUP) {

		if (chip->flags & TPM_CHIP_FLAG_TPM2)

			rc = tpm2_auto_startup(chip);

		else

			rc = tpm1_auto_startup(chip);

	rc = tpm_auto_startup(chip);

	if (rc)

		return rc;

	}



	tpm_sysfs_add_device(chip);

drivers/char/tpm/tpm-dev-common.c

+36 −16
Original line number Diff line number Diff line
@@ -40,7 +40,7 @@ static void tpm_async_work(struct work_struct *work) 


	tpm_put_ops(priv->chip);

	if (ret > 0) {

		priv->data_pending = ret;

		priv->response_length = ret;

		mod_timer(&priv->user_read_timer, jiffies + (120 * HZ));

	}

	mutex_unlock(&priv->buffer_mutex);
@@ -63,7 +63,8 @@ static void tpm_timeout_work(struct work_struct *work) 
					      timeout_work);



	mutex_lock(&priv->buffer_mutex);

	priv->data_pending = 0;

	priv->response_read = true;

	priv->response_length = 0;

	memset(priv->data_buffer, 0, sizeof(priv->data_buffer));

	mutex_unlock(&priv->buffer_mutex);

	wake_up_interruptible(&priv->async_wait);
@@ -74,6 +75,7 @@ void tpm_common_open(struct file *file, struct tpm_chip *chip, 
{

	priv->chip = chip;

	priv->space = space;

	priv->response_read = true;



	mutex_init(&priv->buffer_mutex);

	timer_setup(&priv->user_read_timer, user_reader_timeout, 0);
@@ -90,22 +92,35 @@ ssize_t tpm_common_read(struct file *file, char __user *buf, 
	ssize_t ret_size = 0;

	int rc;



	del_singleshot_timer_sync(&priv->user_read_timer);

	flush_work(&priv->timeout_work);

	mutex_lock(&priv->buffer_mutex);



	if (priv->data_pending) {

		ret_size = min_t(ssize_t, size, priv->data_pending);

		if (ret_size > 0) {

			rc = copy_to_user(buf, priv->data_buffer, ret_size);

			memset(priv->data_buffer, 0, priv->data_pending);

			if (rc)

				ret_size = -EFAULT;

	if (priv->response_length) {

		priv->response_read = true;



		ret_size = min_t(ssize_t, size, priv->response_length);

		if (!ret_size) {

			priv->response_length = 0;

			goto out;

		}



		priv->data_pending = 0;

		rc = copy_to_user(buf, priv->data_buffer + *off, ret_size);

		if (rc) {

			memset(priv->data_buffer, 0, TPM_BUFSIZE);

			priv->response_length = 0;

			ret_size = -EFAULT;

		} else {

			memset(priv->data_buffer + *off, 0, ret_size);

			priv->response_length -= ret_size;

			*off += ret_size;

		}

	}



out:

	if (!priv->response_length) {

		*off = 0;

		del_singleshot_timer_sync(&priv->user_read_timer);

		flush_work(&priv->timeout_work);

	}

	mutex_unlock(&priv->buffer_mutex);

	return ret_size;

}
@@ -125,7 +140,8 @@ ssize_t tpm_common_write(struct file *file, const char __user *buf, 
	 * tpm_read or a user_read_timer timeout. This also prevents split

	 * buffered writes from blocking here.

	 */

	if (priv->data_pending != 0 || priv->command_enqueued) {

	if ((!priv->response_read && priv->response_length) ||

	    priv->command_enqueued) {

		ret = -EBUSY;

		goto out;

	}
@@ -150,6 +166,10 @@ ssize_t tpm_common_write(struct file *file, const char __user *buf, 
		goto out;

	}



	priv->response_length = 0;

	priv->response_read = false;

	*off = 0;



	/*

	 * If in nonblocking mode schedule an async job to send

	 * the command return the size.
@@ -168,7 +188,7 @@ ssize_t tpm_common_write(struct file *file, const char __user *buf, 
	tpm_put_ops(priv->chip);



	if (ret > 0) {

		priv->data_pending = ret;

		priv->response_length = ret;

		mod_timer(&priv->user_read_timer, jiffies + (120 * HZ));

		ret = size;

	}
@@ -184,7 +204,7 @@ __poll_t tpm_common_poll(struct file *file, poll_table *wait) 


	poll_wait(file, &priv->async_wait, wait);



	if (priv->data_pending)

	if (!priv->response_read || priv->response_length)

		mask = EPOLLIN | EPOLLRDNORM;

	else

		mask = EPOLLOUT | EPOLLWRNORM;
@@ -201,7 +221,7 @@ void tpm_common_release(struct file *file, struct file_priv *priv) 
	del_singleshot_timer_sync(&priv->user_read_timer);

	flush_work(&priv->timeout_work);

	file->private_data = NULL;

	priv->data_pending = 0;

	priv->response_length = 0;

}



int __init tpm_dev_common_init(void)

drivers/char/tpm/tpm-dev.h

+2 −3
Original line number Diff line number Diff line
@@ -9,14 +9,13 @@ struct file_priv { 
	struct tpm_chip *chip;

	struct tpm_space *space;



	/* Holds the amount of data passed or an error code from async op */

	ssize_t data_pending;

	struct mutex buffer_mutex;



	struct timer_list user_read_timer;      /* user needs to claim result */

	struct work_struct timeout_work;

	struct work_struct async_work;

	wait_queue_head_t async_wait;

	size_t response_length;

	bool response_read;

	bool command_enqueued;



	u8 data_buffer[TPM_BUFSIZE];

CRA Git | Maintained and supported by SUSTech CRA and CCSE