1 /* 2 * Provide access to virtual console memory. 3 * /dev/vcs0: the screen as it is being viewed right now (possibly scrolled) 4 * /dev/vcsN: the screen of /dev/ttyN (1 <= N <= 63) 5 * [minor: N] 6 * 7 * /dev/vcsaN: idem, but including attributes, and prefixed with 8 * the 4 bytes lines,columns,x,y (as screendump used to give). 9 * Attribute/character pair is in native endianity. 10 * [minor: N+128] 11 * 12 * This replaces screendump and part of selection, so that the system 13 * administrator can control access using file system permissions. 14 * 15 * aeb@cwi.nl - efter Friedas begravelse - 950211 16 * 17 * machek@k332.feld.cvut.cz - modified not to send characters to wrong console 18 * - fixed some fatal off-by-one bugs (0-- no longer == -1 -> looping and looping and looping...) 19 * - making it shorter - scr_readw are macros which expand in PRETTY long code 20 */ 21 22 #include <linux/kernel.h> 23 #include <linux/major.h> 24 #include <linux/errno.h> 25 #include <linux/export.h> 26 #include <linux/tty.h> 27 #include <linux/interrupt.h> 28 #include <linux/mm.h> 29 #include <linux/init.h> 30 #include <linux/vt_kern.h> 31 #include <linux/selection.h> 32 #include <linux/kbd_kern.h> 33 #include <linux/console.h> 34 #include <linux/device.h> 35 #include <linux/sched.h> 36 #include <linux/fs.h> 37 #include <linux/poll.h> 38 #include <linux/signal.h> 39 #include <linux/slab.h> 40 #include <linux/notifier.h> 41 42 #include <asm/uaccess.h> 43 #include <asm/byteorder.h> 44 #include <asm/unaligned.h> 45 46 #undef attr 47 #undef org 48 #undef addr 49 #define HEADER_SIZE 4 50 51 #define CON_BUF_SIZE (CONFIG_BASE_SMALL ? 256 : PAGE_SIZE) 52 53 struct vcs_poll_data { 54 struct notifier_block notifier; 55 unsigned int cons_num; 56 bool seen_last_update; 57 wait_queue_head_t waitq; 58 struct fasync_struct *fasync; 59 }; 60 61 static int 62 vcs_notifier(struct notifier_block *nb, unsigned long code, void *_param) 63 { 64 struct vt_notifier_param *param = _param; 65 struct vc_data *vc = param->vc; 66 struct vcs_poll_data *poll = 67 container_of(nb, struct vcs_poll_data, notifier); 68 int currcons = poll->cons_num; 69 70 if (code != VT_UPDATE) 71 return NOTIFY_DONE; 72 73 if (currcons == 0) 74 currcons = fg_console; 75 else 76 currcons--; 77 if (currcons != vc->vc_num) 78 return NOTIFY_DONE; 79 80 poll->seen_last_update = false; 81 wake_up_interruptible(&poll->waitq); 82 kill_fasync(&poll->fasync, SIGIO, POLL_IN); 83 return NOTIFY_OK; 84 } 85 86 static void 87 vcs_poll_data_free(struct vcs_poll_data *poll) 88 { 89 unregister_vt_notifier(&poll->notifier); 90 kfree(poll); 91 } 92 93 static struct vcs_poll_data * 94 vcs_poll_data_get(struct file *file) 95 { 96 struct vcs_poll_data *poll = file->private_data, *kill = NULL; 97 98 if (poll) 99 return poll; 100 101 poll = kzalloc(sizeof(*poll), GFP_KERNEL); 102 if (!poll) 103 return NULL; 104 poll->cons_num = iminor(file_inode(file)) & 127; 105 init_waitqueue_head(&poll->waitq); 106 poll->notifier.notifier_call = vcs_notifier; 107 if (register_vt_notifier(&poll->notifier) != 0) { 108 kfree(poll); 109 return NULL; 110 } 111 112 /* 113 * This code may be called either through ->poll() or ->fasync(). 114 * If we have two threads using the same file descriptor, they could 115 * both enter this function, both notice that the structure hasn't 116 * been allocated yet and go ahead allocating it in parallel, but 117 * only one of them must survive and be shared otherwise we'd leak 118 * memory with a dangling notifier callback. 119 */ 120 spin_lock(&file->f_lock); 121 if (!file->private_data) { 122 file->private_data = poll; 123 } else { 124 /* someone else raced ahead of us */ 125 kill = poll; 126 poll = file->private_data; 127 } 128 spin_unlock(&file->f_lock); 129 if (kill) 130 vcs_poll_data_free(kill); 131 132 return poll; 133 } 134 135 /* 136 * Returns VC for inode. 137 * Must be called with console_lock. 138 */ 139 static struct vc_data* 140 vcs_vc(struct inode *inode, int *viewed) 141 { 142 unsigned int currcons = iminor(inode) & 127; 143 144 WARN_CONSOLE_UNLOCKED(); 145 146 if (currcons == 0) { 147 currcons = fg_console; 148 if (viewed) 149 *viewed = 1; 150 } else { 151 currcons--; 152 if (viewed) 153 *viewed = 0; 154 } 155 return vc_cons[currcons].d; 156 } 157 158 /* 159 * Returns size for VC carried by inode. 160 * Must be called with console_lock. 161 */ 162 static int 163 vcs_size(struct inode *inode) 164 { 165 int size; 166 int minor = iminor(inode); 167 struct vc_data *vc; 168 169 WARN_CONSOLE_UNLOCKED(); 170 171 vc = vcs_vc(inode, NULL); 172 if (!vc) 173 return -ENXIO; 174 175 size = vc->vc_rows * vc->vc_cols; 176 177 if (minor & 128) 178 size = 2*size + HEADER_SIZE; 179 return size; 180 } 181 182 static loff_t vcs_lseek(struct file *file, loff_t offset, int orig) 183 { 184 int size; 185 186 console_lock(); 187 size = vcs_size(file_inode(file)); 188 console_unlock(); 189 if (size < 0) 190 return size; 191 switch (orig) { 192 default: 193 return -EINVAL; 194 case 2: 195 offset += size; 196 break; 197 case 1: 198 offset += file->f_pos; 199 case 0: 200 break; 201 } 202 if (offset < 0 || offset > size) { 203 return -EINVAL; 204 } 205 file->f_pos = offset; 206 return file->f_pos; 207 } 208 209 210 static ssize_t 211 vcs_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 212 { 213 struct inode *inode = file_inode(file); 214 unsigned int currcons = iminor(inode); 215 struct vc_data *vc; 216 struct vcs_poll_data *poll; 217 long pos; 218 long attr, read; 219 int col, maxcol, viewed; 220 unsigned short *org = NULL; 221 ssize_t ret; 222 char *con_buf; 223 224 con_buf = (char *) __get_free_page(GFP_KERNEL); 225 if (!con_buf) 226 return -ENOMEM; 227 228 pos = *ppos; 229 230 /* Select the proper current console and verify 231 * sanity of the situation under the console lock. 232 */ 233 console_lock(); 234 235 attr = (currcons & 128); 236 ret = -ENXIO; 237 vc = vcs_vc(inode, &viewed); 238 if (!vc) 239 goto unlock_out; 240 241 ret = -EINVAL; 242 if (pos < 0) 243 goto unlock_out; 244 poll = file->private_data; 245 if (count && poll) 246 poll->seen_last_update = true; 247 read = 0; 248 ret = 0; 249 while (count) { 250 char *con_buf0, *con_buf_start; 251 long this_round, size; 252 ssize_t orig_count; 253 long p = pos; 254 255 /* Check whether we are above size each round, 256 * as copy_to_user at the end of this loop 257 * could sleep. 258 */ 259 size = vcs_size(inode); 260 if (size < 0) { 261 if (read) 262 break; 263 ret = size; 264 goto unlock_out; 265 } 266 if (pos >= size) 267 break; 268 if (count > size - pos) 269 count = size - pos; 270 271 this_round = count; 272 if (this_round > CON_BUF_SIZE) 273 this_round = CON_BUF_SIZE; 274 275 /* Perform the whole read into the local con_buf. 276 * Then we can drop the console spinlock and safely 277 * attempt to move it to userspace. 278 */ 279 280 con_buf_start = con_buf0 = con_buf; 281 orig_count = this_round; 282 maxcol = vc->vc_cols; 283 if (!attr) { 284 org = screen_pos(vc, p, viewed); 285 col = p % maxcol; 286 p += maxcol - col; 287 while (this_round-- > 0) { 288 *con_buf0++ = (vcs_scr_readw(vc, org++) & 0xff); 289 if (++col == maxcol) { 290 org = screen_pos(vc, p, viewed); 291 col = 0; 292 p += maxcol; 293 } 294 } 295 } else { 296 if (p < HEADER_SIZE) { 297 size_t tmp_count; 298 299 con_buf0[0] = (char)vc->vc_rows; 300 con_buf0[1] = (char)vc->vc_cols; 301 getconsxy(vc, con_buf0 + 2); 302 303 con_buf_start += p; 304 this_round += p; 305 if (this_round > CON_BUF_SIZE) { 306 this_round = CON_BUF_SIZE; 307 orig_count = this_round - p; 308 } 309 310 tmp_count = HEADER_SIZE; 311 if (tmp_count > this_round) 312 tmp_count = this_round; 313 314 /* Advance state pointers and move on. */ 315 this_round -= tmp_count; 316 p = HEADER_SIZE; 317 con_buf0 = con_buf + HEADER_SIZE; 318 /* If this_round >= 0, then p is even... */ 319 } else if (p & 1) { 320 /* Skip first byte for output if start address is odd 321 * Update region sizes up/down depending on free 322 * space in buffer. 323 */ 324 con_buf_start++; 325 if (this_round < CON_BUF_SIZE) 326 this_round++; 327 else 328 orig_count--; 329 } 330 if (this_round > 0) { 331 unsigned short *tmp_buf = (unsigned short *)con_buf0; 332 333 p -= HEADER_SIZE; 334 p /= 2; 335 col = p % maxcol; 336 337 org = screen_pos(vc, p, viewed); 338 p += maxcol - col; 339 340 /* Buffer has even length, so we can always copy 341 * character + attribute. We do not copy last byte 342 * to userspace if this_round is odd. 343 */ 344 this_round = (this_round + 1) >> 1; 345 346 while (this_round) { 347 *tmp_buf++ = vcs_scr_readw(vc, org++); 348 this_round --; 349 if (++col == maxcol) { 350 org = screen_pos(vc, p, viewed); 351 col = 0; 352 p += maxcol; 353 } 354 } 355 } 356 } 357 358 /* Finally, release the console semaphore while we push 359 * all the data to userspace from our temporary buffer. 360 * 361 * AKPM: Even though it's a semaphore, we should drop it because 362 * the pagefault handling code may want to call printk(). 363 */ 364 365 console_unlock(); 366 ret = copy_to_user(buf, con_buf_start, orig_count); 367 console_lock(); 368 369 if (ret) { 370 read += (orig_count - ret); 371 ret = -EFAULT; 372 break; 373 } 374 buf += orig_count; 375 pos += orig_count; 376 read += orig_count; 377 count -= orig_count; 378 } 379 *ppos += read; 380 if (read) 381 ret = read; 382 unlock_out: 383 console_unlock(); 384 free_page((unsigned long) con_buf); 385 return ret; 386 } 387 388 static ssize_t 389 vcs_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 390 { 391 struct inode *inode = file_inode(file); 392 unsigned int currcons = iminor(inode); 393 struct vc_data *vc; 394 long pos; 395 long attr, size, written; 396 char *con_buf0; 397 int col, maxcol, viewed; 398 u16 *org0 = NULL, *org = NULL; 399 size_t ret; 400 char *con_buf; 401 402 con_buf = (char *) __get_free_page(GFP_KERNEL); 403 if (!con_buf) 404 return -ENOMEM; 405 406 pos = *ppos; 407 408 /* Select the proper current console and verify 409 * sanity of the situation under the console lock. 410 */ 411 console_lock(); 412 413 attr = (currcons & 128); 414 ret = -ENXIO; 415 vc = vcs_vc(inode, &viewed); 416 if (!vc) 417 goto unlock_out; 418 419 size = vcs_size(inode); 420 ret = -EINVAL; 421 if (pos < 0 || pos > size) 422 goto unlock_out; 423 if (count > size - pos) 424 count = size - pos; 425 written = 0; 426 while (count) { 427 long this_round = count; 428 size_t orig_count; 429 long p; 430 431 if (this_round > CON_BUF_SIZE) 432 this_round = CON_BUF_SIZE; 433 434 /* Temporarily drop the console lock so that we can read 435 * in the write data from userspace safely. 436 */ 437 console_unlock(); 438 ret = copy_from_user(con_buf, buf, this_round); 439 console_lock(); 440 441 if (ret) { 442 this_round -= ret; 443 if (!this_round) { 444 /* Abort loop if no data were copied. Otherwise 445 * fail with -EFAULT. 446 */ 447 if (written) 448 break; 449 ret = -EFAULT; 450 goto unlock_out; 451 } 452 } 453 454 /* The vcs_size might have changed while we slept to grab 455 * the user buffer, so recheck. 456 * Return data written up to now on failure. 457 */ 458 size = vcs_size(inode); 459 if (size < 0) { 460 if (written) 461 break; 462 ret = size; 463 goto unlock_out; 464 } 465 if (pos >= size) 466 break; 467 if (this_round > size - pos) 468 this_round = size - pos; 469 470 /* OK, now actually push the write to the console 471 * under the lock using the local kernel buffer. 472 */ 473 474 con_buf0 = con_buf; 475 orig_count = this_round; 476 maxcol = vc->vc_cols; 477 p = pos; 478 if (!attr) { 479 org0 = org = screen_pos(vc, p, viewed); 480 col = p % maxcol; 481 p += maxcol - col; 482 483 while (this_round > 0) { 484 unsigned char c = *con_buf0++; 485 486 this_round--; 487 vcs_scr_writew(vc, 488 (vcs_scr_readw(vc, org) & 0xff00) | c, org); 489 org++; 490 if (++col == maxcol) { 491 org = screen_pos(vc, p, viewed); 492 col = 0; 493 p += maxcol; 494 } 495 } 496 } else { 497 if (p < HEADER_SIZE) { 498 char header[HEADER_SIZE]; 499 500 getconsxy(vc, header + 2); 501 while (p < HEADER_SIZE && this_round > 0) { 502 this_round--; 503 header[p++] = *con_buf0++; 504 } 505 if (!viewed) 506 putconsxy(vc, header + 2); 507 } 508 p -= HEADER_SIZE; 509 col = (p/2) % maxcol; 510 if (this_round > 0) { 511 org0 = org = screen_pos(vc, p/2, viewed); 512 if ((p & 1) && this_round > 0) { 513 char c; 514 515 this_round--; 516 c = *con_buf0++; 517 #ifdef __BIG_ENDIAN 518 vcs_scr_writew(vc, c | 519 (vcs_scr_readw(vc, org) & 0xff00), org); 520 #else 521 vcs_scr_writew(vc, (c << 8) | 522 (vcs_scr_readw(vc, org) & 0xff), org); 523 #endif 524 org++; 525 p++; 526 if (++col == maxcol) { 527 org = screen_pos(vc, p/2, viewed); 528 col = 0; 529 } 530 } 531 p /= 2; 532 p += maxcol - col; 533 } 534 while (this_round > 1) { 535 unsigned short w; 536 537 w = get_unaligned(((unsigned short *)con_buf0)); 538 vcs_scr_writew(vc, w, org++); 539 con_buf0 += 2; 540 this_round -= 2; 541 if (++col == maxcol) { 542 org = screen_pos(vc, p, viewed); 543 col = 0; 544 p += maxcol; 545 } 546 } 547 if (this_round > 0) { 548 unsigned char c; 549 550 c = *con_buf0++; 551 #ifdef __BIG_ENDIAN 552 vcs_scr_writew(vc, (vcs_scr_readw(vc, org) & 0xff) | (c << 8), org); 553 #else 554 vcs_scr_writew(vc, (vcs_scr_readw(vc, org) & 0xff00) | c, org); 555 #endif 556 } 557 } 558 count -= orig_count; 559 written += orig_count; 560 buf += orig_count; 561 pos += orig_count; 562 if (org0) 563 update_region(vc, (unsigned long)(org0), org - org0); 564 } 565 *ppos += written; 566 ret = written; 567 if (written) 568 vcs_scr_updated(vc); 569 570 unlock_out: 571 console_unlock(); 572 free_page((unsigned long) con_buf); 573 return ret; 574 } 575 576 static unsigned int 577 vcs_poll(struct file *file, poll_table *wait) 578 { 579 struct vcs_poll_data *poll = vcs_poll_data_get(file); 580 int ret = DEFAULT_POLLMASK|POLLERR|POLLPRI; 581 582 if (poll) { 583 poll_wait(file, &poll->waitq, wait); 584 if (poll->seen_last_update) 585 ret = DEFAULT_POLLMASK; 586 } 587 return ret; 588 } 589 590 static int 591 vcs_fasync(int fd, struct file *file, int on) 592 { 593 struct vcs_poll_data *poll = file->private_data; 594 595 if (!poll) { 596 /* don't allocate anything if all we want is disable fasync */ 597 if (!on) 598 return 0; 599 poll = vcs_poll_data_get(file); 600 if (!poll) 601 return -ENOMEM; 602 } 603 604 return fasync_helper(fd, file, on, &poll->fasync); 605 } 606 607 static int 608 vcs_open(struct inode *inode, struct file *filp) 609 { 610 unsigned int currcons = iminor(inode) & 127; 611 int ret = 0; 612 613 console_lock(); 614 if(currcons && !vc_cons_allocated(currcons-1)) 615 ret = -ENXIO; 616 console_unlock(); 617 return ret; 618 } 619 620 static int vcs_release(struct inode *inode, struct file *file) 621 { 622 struct vcs_poll_data *poll = file->private_data; 623 624 if (poll) 625 vcs_poll_data_free(poll); 626 return 0; 627 } 628 629 static const struct file_operations vcs_fops = { 630 .llseek = vcs_lseek, 631 .read = vcs_read, 632 .write = vcs_write, 633 .poll = vcs_poll, 634 .fasync = vcs_fasync, 635 .open = vcs_open, 636 .release = vcs_release, 637 }; 638 639 static struct class *vc_class; 640 641 void vcs_make_sysfs(int index) 642 { 643 device_create(vc_class, NULL, MKDEV(VCS_MAJOR, index + 1), NULL, 644 "vcs%u", index + 1); 645 device_create(vc_class, NULL, MKDEV(VCS_MAJOR, index + 129), NULL, 646 "vcsa%u", index + 1); 647 } 648 649 void vcs_remove_sysfs(int index) 650 { 651 device_destroy(vc_class, MKDEV(VCS_MAJOR, index + 1)); 652 device_destroy(vc_class, MKDEV(VCS_MAJOR, index + 129)); 653 } 654 655 int __init vcs_init(void) 656 { 657 unsigned int i; 658 659 if (register_chrdev(VCS_MAJOR, "vcs", &vcs_fops)) 660 panic("unable to get major %d for vcs device", VCS_MAJOR); 661 vc_class = class_create(THIS_MODULE, "vc"); 662 663 device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 0), NULL, "vcs"); 664 device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 128), NULL, "vcsa"); 665 for (i = 0; i < MIN_NR_CONSOLES; i++) 666 vcs_make_sysfs(i); 667 return 0; 668 } 669