[linux-2.6-block.git] / drivers / char / tpm / tpm-buf.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Handling of TPM command and other buffers.
 */

#include <linux/tpm_command.h>
#include <linux/module.h>
#include <linux/tpm.h>

/**
 * tpm_buf_init() - Allocate and initialize a TPM command
 * @buf:	A &tpm_buf
 * @tag:	TPM_TAG_RQU_COMMAND, TPM2_ST_NO_SESSIONS or TPM2_ST_SESSIONS
 * @ordinal:	A command ordinal
 *
 * Return: 0 or -ENOMEM
 */
int tpm_buf_init(struct tpm_buf *buf, u16 tag, u32 ordinal)
{
	buf->data = (u8 *)__get_free_page(GFP_KERNEL);
	if (!buf->data)
		return -ENOMEM;

	tpm_buf_reset(buf, tag, ordinal);
	return 0;
}
EXPORT_SYMBOL_GPL(tpm_buf_init);

/**
 * tpm_buf_reset() - Initialize a TPM command
 * @buf:	A &tpm_buf
 * @tag:	TPM_TAG_RQU_COMMAND, TPM2_ST_NO_SESSIONS or TPM2_ST_SESSIONS
 * @ordinal:	A command ordinal
 */
void tpm_buf_reset(struct tpm_buf *buf, u16 tag, u32 ordinal)
{
	struct tpm_header *head = (struct tpm_header *)buf->data;

	WARN_ON(tag != TPM_TAG_RQU_COMMAND && tag != TPM2_ST_NO_SESSIONS &&
		tag != TPM2_ST_SESSIONS && tag != 0);

	buf->flags = 0;
	buf->length = sizeof(*head);
	head->tag = cpu_to_be16(tag);
	head->length = cpu_to_be32(sizeof(*head));
	head->ordinal = cpu_to_be32(ordinal);
	buf->handles = 0;
}
EXPORT_SYMBOL_GPL(tpm_buf_reset);

/**
 * tpm_buf_init_sized() - Allocate and initialize a sized (TPM2B) buffer
 * @buf:	A @tpm_buf
 *
 * Return: 0 or -ENOMEM
 */
int tpm_buf_init_sized(struct tpm_buf *buf)
{
	buf->data = (u8 *)__get_free_page(GFP_KERNEL);
	if (!buf->data)
		return -ENOMEM;

	tpm_buf_reset_sized(buf);
	return 0;
}
EXPORT_SYMBOL_GPL(tpm_buf_init_sized);

/**
 * tpm_buf_reset_sized() - Initialize a sized buffer
 * @buf:	A &tpm_buf
 */
void tpm_buf_reset_sized(struct tpm_buf *buf)
{
	buf->flags = TPM_BUF_TPM2B;
	buf->length = 2;
	buf->data[0] = 0;
	buf->data[1] = 0;
}
EXPORT_SYMBOL_GPL(tpm_buf_reset_sized);

void tpm_buf_destroy(struct tpm_buf *buf)
{
	free_page((unsigned long)buf->data);
}
EXPORT_SYMBOL_GPL(tpm_buf_destroy);

/**
 * tpm_buf_length() - Return the number of bytes consumed by the data
 * @buf:	A &tpm_buf
 *
 * Return: The number of bytes consumed by the buffer
 */
u32 tpm_buf_length(struct tpm_buf *buf)
{
	return buf->length;
}
EXPORT_SYMBOL_GPL(tpm_buf_length);

/**
 * tpm_buf_append() - Append data to an initialized buffer
 * @buf:	A &tpm_buf
 * @new_data:	A data blob
 * @new_length:	Size of the appended data
 */
void tpm_buf_append(struct tpm_buf *buf, const u8 *new_data, u16 new_length)
{
	/* Return silently if overflow has already happened. */
	if (buf->flags & TPM_BUF_OVERFLOW)
		return;

	if ((buf->length + new_length) > PAGE_SIZE) {
		WARN(1, "tpm_buf: write overflow\n");
		buf->flags |= TPM_BUF_OVERFLOW;
		return;
	}

	memcpy(&buf->data[buf->length], new_data, new_length);
	buf->length += new_length;

	if (buf->flags & TPM_BUF_TPM2B)
		((__be16 *)buf->data)[0] = cpu_to_be16(buf->length - 2);
	else
		((struct tpm_header *)buf->data)->length = cpu_to_be32(buf->length);
}
EXPORT_SYMBOL_GPL(tpm_buf_append);

void tpm_buf_append_u8(struct tpm_buf *buf, const u8 value)
{
	tpm_buf_append(buf, &value, 1);
}
EXPORT_SYMBOL_GPL(tpm_buf_append_u8);

void tpm_buf_append_u16(struct tpm_buf *buf, const u16 value)
{
	__be16 value2 = cpu_to_be16(value);

	tpm_buf_append(buf, (u8 *)&value2, 2);
}
EXPORT_SYMBOL_GPL(tpm_buf_append_u16);

void tpm_buf_append_u32(struct tpm_buf *buf, const u32 value)
{
	__be32 value2 = cpu_to_be32(value);

	tpm_buf_append(buf, (u8 *)&value2, 4);
}
EXPORT_SYMBOL_GPL(tpm_buf_append_u32);

/**
 * tpm_buf_append_handle() - Add a handle
 * @chip:	&tpm_chip instance
 * @buf:	&tpm_buf instance
 * @handle:	a TPM object handle
 *
 * Add a handle to the buffer, and increase the count tracking the number of
 * handles in the command buffer. Works only for command buffers.
 */
void tpm_buf_append_handle(struct tpm_chip *chip, struct tpm_buf *buf, u32 handle)
{
	if (buf->flags & TPM_BUF_TPM2B) {
		dev_err(&chip->dev, "Invalid buffer type (TPM2B)\n");
		return;
	}

	tpm_buf_append_u32(buf, handle);
	buf->handles++;
}

/**
 * tpm_buf_read() - Read from a TPM buffer
 * @buf:	&tpm_buf instance
 * @offset:	offset within the buffer
 * @count:	the number of bytes to read
 * @output:	the output buffer
 */
static void tpm_buf_read(struct tpm_buf *buf, off_t *offset, size_t count, void *output)
{
	off_t next_offset;

	/* Return silently if overflow has already happened. */
	if (buf->flags & TPM_BUF_BOUNDARY_ERROR)
		return;

	next_offset = *offset + count;
	if (next_offset > buf->length) {
		WARN(1, "tpm_buf: read out of boundary\n");
		buf->flags |= TPM_BUF_BOUNDARY_ERROR;
		return;
	}

	memcpy(output, &buf->data[*offset], count);
	*offset = next_offset;
}

/**
 * tpm_buf_read_u8() - Read 8-bit word from a TPM buffer
 * @buf:	&tpm_buf instance
 * @offset:	offset within the buffer
 *
 * Return: next 8-bit word
 */
u8 tpm_buf_read_u8(struct tpm_buf *buf, off_t *offset)
{
	u8 value = 0;

	tpm_buf_read(buf, offset, sizeof(value), &value);

	return value;
}
EXPORT_SYMBOL_GPL(tpm_buf_read_u8);

/**
 * tpm_buf_read_u16() - Read 16-bit word from a TPM buffer
 * @buf:	&tpm_buf instance
 * @offset:	offset within the buffer
 *
 * Return: next 16-bit word
 */
u16 tpm_buf_read_u16(struct tpm_buf *buf, off_t *offset)
{
	u16 value = 0;

	tpm_buf_read(buf, offset, sizeof(value), &value);

	return be16_to_cpu(value);
}
EXPORT_SYMBOL_GPL(tpm_buf_read_u16);

/**
 * tpm_buf_read_u32() - Read 32-bit word from a TPM buffer
 * @buf:	&tpm_buf instance
 * @offset:	offset within the buffer
 *
 * Return: next 32-bit word
 */
u32 tpm_buf_read_u32(struct tpm_buf *buf, off_t *offset)
{
	u32 value = 0;

	tpm_buf_read(buf, offset, sizeof(value), &value);

	return be32_to_cpu(value);
}
EXPORT_SYMBOL_GPL(tpm_buf_read_u32);
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Handling of TPM command and other buffers.
	4	*/
	5
	6	#include <linux/tpm_command.h>
	7	#include <linux/module.h>
	8	#include <linux/tpm.h>
	9
	10	/**
	11	* tpm_buf_init() - Allocate and initialize a TPM command
	12	* @buf: A &tpm_buf
	13	* @tag: TPM_TAG_RQU_COMMAND, TPM2_ST_NO_SESSIONS or TPM2_ST_SESSIONS
	14	* @ordinal: A command ordinal
	15	*
	16	* Return: 0 or -ENOMEM
	17	*/
	18	int tpm_buf_init(struct tpm_buf *buf, u16 tag, u32 ordinal)
	19	{
	20	buf->data = (u8 *)__get_free_page(GFP_KERNEL);
	21	if (!buf->data)
	22	return -ENOMEM;
	23
	24	tpm_buf_reset(buf, tag, ordinal);
	25	return 0;
	26	}
	27	EXPORT_SYMBOL_GPL(tpm_buf_init);
	28
	29	/**
	30	* tpm_buf_reset() - Initialize a TPM command
	31	* @buf: A &tpm_buf
	32	* @tag: TPM_TAG_RQU_COMMAND, TPM2_ST_NO_SESSIONS or TPM2_ST_SESSIONS
	33	* @ordinal: A command ordinal
	34	*/
	35	void tpm_buf_reset(struct tpm_buf *buf, u16 tag, u32 ordinal)
	36	{
	37	struct tpm_header head = (struct tpm_header )buf->data;
	38
	39	WARN_ON(tag != TPM_TAG_RQU_COMMAND && tag != TPM2_ST_NO_SESSIONS &&
	40	tag != TPM2_ST_SESSIONS && tag != 0);
	41
	42	buf->flags = 0;
	43	buf->length = sizeof(*head);
	44	head->tag = cpu_to_be16(tag);
	45	head->length = cpu_to_be32(sizeof(*head));
	46	head->ordinal = cpu_to_be32(ordinal);
	47	buf->handles = 0;
	48	}
	49	EXPORT_SYMBOL_GPL(tpm_buf_reset);
	50
	51	/**
	52	* tpm_buf_init_sized() - Allocate and initialize a sized (TPM2B) buffer
	53	* @buf: A @tpm_buf
	54	*
	55	* Return: 0 or -ENOMEM
	56	*/
	57	int tpm_buf_init_sized(struct tpm_buf *buf)
	58	{
	59	buf->data = (u8 *)__get_free_page(GFP_KERNEL);
	60	if (!buf->data)
	61	return -ENOMEM;
	62
	63	tpm_buf_reset_sized(buf);
	64	return 0;
	65	}
	66	EXPORT_SYMBOL_GPL(tpm_buf_init_sized);
	67
	68	/**
	69	* tpm_buf_reset_sized() - Initialize a sized buffer
	70	* @buf: A &tpm_buf
	71	*/
	72	void tpm_buf_reset_sized(struct tpm_buf *buf)
	73	{
	74	buf->flags = TPM_BUF_TPM2B;
	75	buf->length = 2;
	76	buf->data[0] = 0;
	77	buf->data[1] = 0;
	78	}
	79	EXPORT_SYMBOL_GPL(tpm_buf_reset_sized);
	80
	81	void tpm_buf_destroy(struct tpm_buf *buf)
	82	{
	83	free_page((unsigned long)buf->data);
	84	}
	85	EXPORT_SYMBOL_GPL(tpm_buf_destroy);
	86
	87	/**
	88	* tpm_buf_length() - Return the number of bytes consumed by the data
	89	* @buf: A &tpm_buf
	90	*
	91	* Return: The number of bytes consumed by the buffer
	92	*/
	93	u32 tpm_buf_length(struct tpm_buf *buf)
	94	{
	95	return buf->length;
	96	}
	97	EXPORT_SYMBOL_GPL(tpm_buf_length);
	98
	99	/**
	100	* tpm_buf_append() - Append data to an initialized buffer
	101	* @buf: A &tpm_buf
	102	* @new_data: A data blob
	103	* @new_length: Size of the appended data
	104	*/
	105	void tpm_buf_append(struct tpm_buf buf, const u8 new_data, u16 new_length)
	106	{
	107	/* Return silently if overflow has already happened. */
	108	if (buf->flags & TPM_BUF_OVERFLOW)
	109	return;
	110
	111	if ((buf->length + new_length) > PAGE_SIZE) {
	112	WARN(1, "tpm_buf: write overflow\n");
	113	buf->flags \|= TPM_BUF_OVERFLOW;
	114	return;
	115	}
	116
	117	memcpy(&buf->data[buf->length], new_data, new_length);
	118	buf->length += new_length;
	119
	120	if (buf->flags & TPM_BUF_TPM2B)
	121	((__be16 *)buf->data)[0] = cpu_to_be16(buf->length - 2);
	122	else
	123	((struct tpm_header *)buf->data)->length = cpu_to_be32(buf->length);
	124	}
	125	EXPORT_SYMBOL_GPL(tpm_buf_append);
	126
	127	void tpm_buf_append_u8(struct tpm_buf *buf, const u8 value)
	128	{
	129	tpm_buf_append(buf, &value, 1);
	130	}
	131	EXPORT_SYMBOL_GPL(tpm_buf_append_u8);
	132
	133	void tpm_buf_append_u16(struct tpm_buf *buf, const u16 value)
	134	{
	135	__be16 value2 = cpu_to_be16(value);
	136
	137	tpm_buf_append(buf, (u8 *)&value2, 2);
	138	}
	139	EXPORT_SYMBOL_GPL(tpm_buf_append_u16);
	140
	141	void tpm_buf_append_u32(struct tpm_buf *buf, const u32 value)
	142	{
	143	__be32 value2 = cpu_to_be32(value);
	144
	145	tpm_buf_append(buf, (u8 *)&value2, 4);
	146	}
	147	EXPORT_SYMBOL_GPL(tpm_buf_append_u32);
	148
	149	/**
	150	* tpm_buf_append_handle() - Add a handle
	151	* @chip: &tpm_chip instance
	152	* @buf: &tpm_buf instance
	153	* @handle: a TPM object handle
	154	*
	155	* Add a handle to the buffer, and increase the count tracking the number of
	156	* handles in the command buffer. Works only for command buffers.
	157	*/
	158	void tpm_buf_append_handle(struct tpm_chip chip, struct tpm_buf buf, u32 handle)
	159	{
	160	if (buf->flags & TPM_BUF_TPM2B) {
	161	dev_err(&chip->dev, "Invalid buffer type (TPM2B)\n");
	162	return;
	163	}
	164
	165	tpm_buf_append_u32(buf, handle);
	166	buf->handles++;
	167	}
	168
	169	/**
	170	* tpm_buf_read() - Read from a TPM buffer
	171	* @buf: &tpm_buf instance
	172	* @offset: offset within the buffer
	173	* @count: the number of bytes to read
	174	* @output: the output buffer
	175	*/
	176	static void tpm_buf_read(struct tpm_buf buf, off_t offset, size_t count, void *output)
	177	{
	178	off_t next_offset;
	179
	180	/* Return silently if overflow has already happened. */
	181	if (buf->flags & TPM_BUF_BOUNDARY_ERROR)
	182	return;
	183
	184	next_offset = *offset + count;
	185	if (next_offset > buf->length) {
	186	WARN(1, "tpm_buf: read out of boundary\n");
	187	buf->flags \|= TPM_BUF_BOUNDARY_ERROR;
	188	return;
	189	}
	190
	191	memcpy(output, &buf->data[*offset], count);
	192	*offset = next_offset;
	193	}
	194
	195	/**
	196	* tpm_buf_read_u8() - Read 8-bit word from a TPM buffer
	197	* @buf: &tpm_buf instance
	198	* @offset: offset within the buffer
	199	*
	200	* Return: next 8-bit word
	201	*/
	202	u8 tpm_buf_read_u8(struct tpm_buf buf, off_t offset)
	203	{
	204	u8 value = 0;
	205
	206	tpm_buf_read(buf, offset, sizeof(value), &value);
	207
	208	return value;
	209	}
	210	EXPORT_SYMBOL_GPL(tpm_buf_read_u8);
	211
	212	/**
	213	* tpm_buf_read_u16() - Read 16-bit word from a TPM buffer
	214	* @buf: &tpm_buf instance
	215	* @offset: offset within the buffer
	216	*
	217	* Return: next 16-bit word
	218	*/
	219	u16 tpm_buf_read_u16(struct tpm_buf buf, off_t offset)
	220	{
	221	u16 value = 0;
	222
	223	tpm_buf_read(buf, offset, sizeof(value), &value);
	224
	225	return be16_to_cpu(value);
	226	}
	227	EXPORT_SYMBOL_GPL(tpm_buf_read_u16);
	228
	229	/**
	230	* tpm_buf_read_u32() - Read 32-bit word from a TPM buffer
	231	* @buf: &tpm_buf instance
	232	* @offset: offset within the buffer
	233	*
	234	* Return: next 32-bit word
	235	*/
	236	u32 tpm_buf_read_u32(struct tpm_buf buf, off_t offset)
	237	{
	238	u32 value = 0;
	239
	240	tpm_buf_read(buf, offset, sizeof(value), &value);
	241
	242	return be32_to_cpu(value);
	243	}
	244	EXPORT_SYMBOL_GPL(tpm_buf_read_u32);
	245
	246