1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/drivers/char/ttyprintk.c 4 * 5 * Copyright (C) 2010 Samo Pogacnik 6 */ 7 8 /* 9 * This pseudo device allows user to make printk messages. It is possible 10 * to store "console" messages inline with kernel messages for better analyses 11 * of the boot process, for example. 12 */ 13 14 #include <linux/device.h> 15 #include <linux/serial.h> 16 #include <linux/tty.h> 17 #include <linux/module.h> 18 19 struct ttyprintk_port { 20 struct tty_port port; 21 struct mutex port_write_mutex; 22 }; 23 24 static struct ttyprintk_port tpk_port; 25 26 /* 27 * Our simple preformatting supports transparent output of (time-stamped) 28 * printk messages (also suitable for logging service): 29 * - any cr is replaced by nl 30 * - adds a ttyprintk source tag in front of each line 31 * - too long message is fragmented, with '\'nl between fragments 32 * - TPK_STR_SIZE isn't really the write_room limiting factor, because 33 * it is emptied on the fly during preformatting. 34 */ 35 #define TPK_STR_SIZE 508 /* should be bigger then max expected line length */ 36 #define TPK_MAX_ROOM 4096 /* we could assume 4K for instance */ 37 #define TPK_PREFIX KERN_SOH __stringify(CONFIG_TTY_PRINTK_LEVEL) 38 39 static int tpk_curr; 40 41 static char tpk_buffer[TPK_STR_SIZE + 4]; 42 43 static void tpk_flush(void) 44 { 45 if (tpk_curr > 0) { 46 tpk_buffer[tpk_curr] = '\0'; 47 printk(TPK_PREFIX "[U] %s\n", tpk_buffer); 48 tpk_curr = 0; 49 } 50 } 51 52 static int tpk_printk(const unsigned char *buf, int count) 53 { 54 int i = tpk_curr; 55 56 if (buf == NULL) { 57 tpk_flush(); 58 return i; 59 } 60 61 for (i = 0; i < count; i++) { 62 if (tpk_curr >= TPK_STR_SIZE) { 63 /* end of tmp buffer reached: cut the message in two */ 64 tpk_buffer[tpk_curr++] = '\\'; 65 tpk_flush(); 66 } 67 68 switch (buf[i]) { 69 case '\r': 70 tpk_flush(); 71 if ((i + 1) < count && buf[i + 1] == '\n') 72 i++; 73 break; 74 case '\n': 75 tpk_flush(); 76 break; 77 default: 78 tpk_buffer[tpk_curr++] = buf[i]; 79 break; 80 } 81 } 82 83 return count; 84 } 85 86 /* 87 * TTY operations open function. 88 */ 89 static int tpk_open(struct tty_struct *tty, struct file *filp) 90 { 91 tty->driver_data = &tpk_port; 92 93 return tty_port_open(&tpk_port.port, tty, filp); 94 } 95 96 /* 97 * TTY operations close function. 98 */ 99 static void tpk_close(struct tty_struct *tty, struct file *filp) 100 { 101 struct ttyprintk_port *tpkp = tty->driver_data; 102 103 mutex_lock(&tpkp->port_write_mutex); 104 /* flush tpk_printk buffer */ 105 tpk_printk(NULL, 0); 106 mutex_unlock(&tpkp->port_write_mutex); 107 108 tty_port_close(&tpkp->port, tty, filp); 109 } 110 111 /* 112 * TTY operations write function. 113 */ 114 static int tpk_write(struct tty_struct *tty, 115 const unsigned char *buf, int count) 116 { 117 struct ttyprintk_port *tpkp = tty->driver_data; 118 int ret; 119 120 121 /* exclusive use of tpk_printk within this tty */ 122 mutex_lock(&tpkp->port_write_mutex); 123 ret = tpk_printk(buf, count); 124 mutex_unlock(&tpkp->port_write_mutex); 125 126 return ret; 127 } 128 129 /* 130 * TTY operations write_room function. 131 */ 132 static int tpk_write_room(struct tty_struct *tty) 133 { 134 return TPK_MAX_ROOM; 135 } 136 137 /* 138 * TTY operations ioctl function. 139 */ 140 static int tpk_ioctl(struct tty_struct *tty, 141 unsigned int cmd, unsigned long arg) 142 { 143 struct ttyprintk_port *tpkp = tty->driver_data; 144 145 if (!tpkp) 146 return -EINVAL; 147 148 switch (cmd) { 149 /* Stop TIOCCONS */ 150 case TIOCCONS: 151 return -EOPNOTSUPP; 152 default: 153 return -ENOIOCTLCMD; 154 } 155 return 0; 156 } 157 158 static const struct tty_operations ttyprintk_ops = { 159 .open = tpk_open, 160 .close = tpk_close, 161 .write = tpk_write, 162 .write_room = tpk_write_room, 163 .ioctl = tpk_ioctl, 164 }; 165 166 static const struct tty_port_operations null_ops = { }; 167 168 static struct tty_driver *ttyprintk_driver; 169 170 static int __init ttyprintk_init(void) 171 { 172 int ret = -ENOMEM; 173 174 mutex_init(&tpk_port.port_write_mutex); 175 176 ttyprintk_driver = tty_alloc_driver(1, 177 TTY_DRIVER_RESET_TERMIOS | 178 TTY_DRIVER_REAL_RAW | 179 TTY_DRIVER_UNNUMBERED_NODE); 180 if (IS_ERR(ttyprintk_driver)) 181 return PTR_ERR(ttyprintk_driver); 182 183 tty_port_init(&tpk_port.port); 184 tpk_port.port.ops = &null_ops; 185 186 ttyprintk_driver->driver_name = "ttyprintk"; 187 ttyprintk_driver->name = "ttyprintk"; 188 ttyprintk_driver->major = TTYAUX_MAJOR; 189 ttyprintk_driver->minor_start = 3; 190 ttyprintk_driver->type = TTY_DRIVER_TYPE_CONSOLE; 191 ttyprintk_driver->init_termios = tty_std_termios; 192 ttyprintk_driver->init_termios.c_oflag = OPOST | OCRNL | ONOCR | ONLRET; 193 tty_set_operations(ttyprintk_driver, &ttyprintk_ops); 194 tty_port_link_device(&tpk_port.port, ttyprintk_driver, 0); 195 196 ret = tty_register_driver(ttyprintk_driver); 197 if (ret < 0) { 198 printk(KERN_ERR "Couldn't register ttyprintk driver\n"); 199 goto error; 200 } 201 202 return 0; 203 204 error: 205 put_tty_driver(ttyprintk_driver); 206 tty_port_destroy(&tpk_port.port); 207 return ret; 208 } 209 210 static void __exit ttyprintk_exit(void) 211 { 212 tty_unregister_driver(ttyprintk_driver); 213 put_tty_driver(ttyprintk_driver); 214 tty_port_destroy(&tpk_port.port); 215 } 216 217 device_initcall(ttyprintk_init); 218 module_exit(ttyprintk_exit); 219 220 MODULE_LICENSE("GPL"); 221