drivers/char/ttyprintk.c

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