1 /* 2 * Copyright (C) 2004 IBM Corporation 3 * Authors: 4 * Leendert van Doorn <leendert@watson.ibm.com> 5 * Dave Safford <safford@watson.ibm.com> 6 * Reiner Sailer <sailer@watson.ibm.com> 7 * Kylene Hall <kjhall@us.ibm.com> 8 * 9 * Copyright (C) 2013 Obsidian Research Corp 10 * Jason Gunthorpe <jgunthorpe@obsidianresearch.com> 11 * 12 * Device file system interface to the TPM 13 * 14 * This program is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU General Public License as 16 * published by the Free Software Foundation, version 2 of the 17 * License. 18 * 19 */ 20 #include <linux/slab.h> 21 #include <linux/uaccess.h> 22 #include "tpm.h" 23 #include "tpm-dev.h" 24 25 static void user_reader_timeout(unsigned long ptr) 26 { 27 struct file_priv *priv = (struct file_priv *)ptr; 28 29 pr_warn("TPM user space timeout is deprecated (pid=%d)\n", 30 task_tgid_nr(current)); 31 32 schedule_work(&priv->work); 33 } 34 35 static void timeout_work(struct work_struct *work) 36 { 37 struct file_priv *priv = container_of(work, struct file_priv, work); 38 39 mutex_lock(&priv->buffer_mutex); 40 atomic_set(&priv->data_pending, 0); 41 memset(priv->data_buffer, 0, sizeof(priv->data_buffer)); 42 mutex_unlock(&priv->buffer_mutex); 43 } 44 45 void tpm_common_open(struct file *file, struct tpm_chip *chip, 46 struct file_priv *priv) 47 { 48 priv->chip = chip; 49 atomic_set(&priv->data_pending, 0); 50 mutex_init(&priv->buffer_mutex); 51 setup_timer(&priv->user_read_timer, user_reader_timeout, 52 (unsigned long)priv); 53 INIT_WORK(&priv->work, timeout_work); 54 55 file->private_data = priv; 56 } 57 58 ssize_t tpm_common_read(struct file *file, char __user *buf, 59 size_t size, loff_t *off) 60 { 61 struct file_priv *priv = file->private_data; 62 ssize_t ret_size; 63 ssize_t orig_ret_size; 64 int rc; 65 66 del_singleshot_timer_sync(&priv->user_read_timer); 67 flush_work(&priv->work); 68 ret_size = atomic_read(&priv->data_pending); 69 if (ret_size > 0) { /* relay data */ 70 orig_ret_size = ret_size; 71 if (size < ret_size) 72 ret_size = size; 73 74 mutex_lock(&priv->buffer_mutex); 75 rc = copy_to_user(buf, priv->data_buffer, ret_size); 76 memset(priv->data_buffer, 0, orig_ret_size); 77 if (rc) 78 ret_size = -EFAULT; 79 80 mutex_unlock(&priv->buffer_mutex); 81 } 82 83 atomic_set(&priv->data_pending, 0); 84 85 return ret_size; 86 } 87 88 ssize_t tpm_common_write(struct file *file, const char __user *buf, 89 size_t size, loff_t *off, struct tpm_space *space) 90 { 91 struct file_priv *priv = file->private_data; 92 size_t in_size = size; 93 ssize_t out_size; 94 95 /* Cannot perform a write until the read has cleared either via 96 * tpm_read or a user_read_timer timeout. This also prevents split 97 * buffered writes from blocking here. 98 */ 99 if (atomic_read(&priv->data_pending) != 0) 100 return -EBUSY; 101 102 if (in_size > TPM_BUFSIZE) 103 return -E2BIG; 104 105 mutex_lock(&priv->buffer_mutex); 106 107 if (copy_from_user 108 (priv->data_buffer, (void __user *) buf, in_size)) { 109 mutex_unlock(&priv->buffer_mutex); 110 return -EFAULT; 111 } 112 113 /* atomic tpm command send and result receive. We only hold the ops 114 * lock during this period so that the tpm can be unregistered even if 115 * the char dev is held open. 116 */ 117 if (tpm_try_get_ops(priv->chip)) { 118 mutex_unlock(&priv->buffer_mutex); 119 return -EPIPE; 120 } 121 out_size = tpm_transmit(priv->chip, space, priv->data_buffer, 122 sizeof(priv->data_buffer), 0); 123 124 tpm_put_ops(priv->chip); 125 if (out_size < 0) { 126 mutex_unlock(&priv->buffer_mutex); 127 return out_size; 128 } 129 130 atomic_set(&priv->data_pending, out_size); 131 mutex_unlock(&priv->buffer_mutex); 132 133 /* Set a timeout by which the reader must come claim the result */ 134 mod_timer(&priv->user_read_timer, jiffies + (120 * HZ)); 135 136 return in_size; 137 } 138 139 /* 140 * Called on file close 141 */ 142 void tpm_common_release(struct file *file, struct file_priv *priv) 143 { 144 del_singleshot_timer_sync(&priv->user_read_timer); 145 flush_work(&priv->work); 146 file->private_data = NULL; 147 atomic_set(&priv->data_pending, 0); 148 } 149