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 24 struct file_priv { 25 struct tpm_chip *chip; 26 27 /* Data passed to and from the tpm via the read/write calls */ 28 atomic_t data_pending; 29 struct mutex buffer_mutex; 30 31 struct timer_list user_read_timer; /* user needs to claim result */ 32 struct work_struct work; 33 34 u8 data_buffer[TPM_BUFSIZE]; 35 }; 36 37 static void user_reader_timeout(unsigned long ptr) 38 { 39 struct file_priv *priv = (struct file_priv *)ptr; 40 41 pr_warn("TPM user space timeout is deprecated (pid=%d)\n", 42 task_tgid_nr(current)); 43 44 schedule_work(&priv->work); 45 } 46 47 static void timeout_work(struct work_struct *work) 48 { 49 struct file_priv *priv = container_of(work, struct file_priv, work); 50 51 mutex_lock(&priv->buffer_mutex); 52 atomic_set(&priv->data_pending, 0); 53 memset(priv->data_buffer, 0, sizeof(priv->data_buffer)); 54 mutex_unlock(&priv->buffer_mutex); 55 } 56 57 static int tpm_open(struct inode *inode, struct file *file) 58 { 59 struct tpm_chip *chip = 60 container_of(inode->i_cdev, struct tpm_chip, cdev); 61 struct file_priv *priv; 62 63 /* It's assured that the chip will be opened just once, 64 * by the check of is_open variable, which is protected 65 * by driver_lock. */ 66 if (test_and_set_bit(0, &chip->is_open)) { 67 dev_dbg(&chip->dev, "Another process owns this TPM\n"); 68 return -EBUSY; 69 } 70 71 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 72 if (priv == NULL) { 73 clear_bit(0, &chip->is_open); 74 return -ENOMEM; 75 } 76 77 priv->chip = chip; 78 atomic_set(&priv->data_pending, 0); 79 mutex_init(&priv->buffer_mutex); 80 setup_timer(&priv->user_read_timer, user_reader_timeout, 81 (unsigned long)priv); 82 INIT_WORK(&priv->work, timeout_work); 83 84 file->private_data = priv; 85 return 0; 86 } 87 88 static ssize_t tpm_read(struct file *file, char __user *buf, 89 size_t size, loff_t *off) 90 { 91 struct file_priv *priv = file->private_data; 92 ssize_t ret_size; 93 int rc; 94 95 del_singleshot_timer_sync(&priv->user_read_timer); 96 flush_work(&priv->work); 97 ret_size = atomic_read(&priv->data_pending); 98 if (ret_size > 0) { /* relay data */ 99 ssize_t orig_ret_size = ret_size; 100 if (size < ret_size) 101 ret_size = size; 102 103 mutex_lock(&priv->buffer_mutex); 104 rc = copy_to_user(buf, priv->data_buffer, ret_size); 105 memset(priv->data_buffer, 0, orig_ret_size); 106 if (rc) 107 ret_size = -EFAULT; 108 109 mutex_unlock(&priv->buffer_mutex); 110 } 111 112 atomic_set(&priv->data_pending, 0); 113 114 return ret_size; 115 } 116 117 static ssize_t tpm_write(struct file *file, const char __user *buf, 118 size_t size, loff_t *off) 119 { 120 struct file_priv *priv = file->private_data; 121 size_t in_size = size; 122 ssize_t out_size; 123 124 /* cannot perform a write until the read has cleared 125 either via tpm_read or a user_read_timer timeout. 126 This also prevents splitted buffered writes from blocking here. 127 */ 128 if (atomic_read(&priv->data_pending) != 0) 129 return -EBUSY; 130 131 if (in_size > TPM_BUFSIZE) 132 return -E2BIG; 133 134 mutex_lock(&priv->buffer_mutex); 135 136 if (copy_from_user 137 (priv->data_buffer, (void __user *) buf, in_size)) { 138 mutex_unlock(&priv->buffer_mutex); 139 return -EFAULT; 140 } 141 142 /* atomic tpm command send and result receive. We only hold the ops 143 * lock during this period so that the tpm can be unregistered even if 144 * the char dev is held open. 145 */ 146 if (tpm_try_get_ops(priv->chip)) { 147 mutex_unlock(&priv->buffer_mutex); 148 return -EPIPE; 149 } 150 out_size = tpm_transmit(priv->chip, priv->data_buffer, 151 sizeof(priv->data_buffer), 0); 152 153 tpm_put_ops(priv->chip); 154 if (out_size < 0) { 155 mutex_unlock(&priv->buffer_mutex); 156 return out_size; 157 } 158 159 atomic_set(&priv->data_pending, out_size); 160 mutex_unlock(&priv->buffer_mutex); 161 162 /* Set a timeout by which the reader must come claim the result */ 163 mod_timer(&priv->user_read_timer, jiffies + (120 * HZ)); 164 165 return in_size; 166 } 167 168 /* 169 * Called on file close 170 */ 171 static int tpm_release(struct inode *inode, struct file *file) 172 { 173 struct file_priv *priv = file->private_data; 174 175 del_singleshot_timer_sync(&priv->user_read_timer); 176 flush_work(&priv->work); 177 file->private_data = NULL; 178 atomic_set(&priv->data_pending, 0); 179 clear_bit(0, &priv->chip->is_open); 180 kfree(priv); 181 return 0; 182 } 183 184 const struct file_operations tpm_fops = { 185 .owner = THIS_MODULE, 186 .llseek = no_llseek, 187 .open = tpm_open, 188 .read = tpm_read, 189 .write = tpm_write, 190 .release = tpm_release, 191 }; 192 193 194