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 return fixed_size_llseek(file, offset, orig, size); 192 } 193 194 195 static ssize_t 196 vcs_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) 197 { 198 struct inode *inode = file_inode(file); 199 unsigned int currcons = iminor(inode); 200 struct vc_data *vc; 201 struct vcs_poll_data *poll; 202 long pos; 203 long attr, read; 204 int col, maxcol, viewed; 205 unsigned short *org = NULL; 206 ssize_t ret; 207 char *con_buf; 208 209 con_buf = (char *) __get_free_page(GFP_KERNEL); 210 if (!con_buf) 211 return -ENOMEM; 212 213 pos = *ppos; 214 215 /* Select the proper current console and verify 216 * sanity of the situation under the console lock. 217 */ 218 console_lock(); 219 220 attr = (currcons & 128); 221 ret = -ENXIO; 222 vc = vcs_vc(inode, &viewed); 223 if (!vc) 224 goto unlock_out; 225 226 ret = -EINVAL; 227 if (pos < 0) 228 goto unlock_out; 229 poll = file->private_data; 230 if (count && poll) 231 poll->seen_last_update = true; 232 read = 0; 233 ret = 0; 234 while (count) { 235 char *con_buf0, *con_buf_start; 236 long this_round, size; 237 ssize_t orig_count; 238 long p = pos; 239 240 /* Check whether we are above size each round, 241 * as copy_to_user at the end of this loop 242 * could sleep. 243 */ 244 size = vcs_size(inode); 245 if (size < 0) { 246 if (read) 247 break; 248 ret = size; 249 goto unlock_out; 250 } 251 if (pos >= size) 252 break; 253 if (count > size - pos) 254 count = size - pos; 255 256 this_round = count; 257 if (this_round > CON_BUF_SIZE) 258 this_round = CON_BUF_SIZE; 259 260 /* Perform the whole read into the local con_buf. 261 * Then we can drop the console spinlock and safely 262 * attempt to move it to userspace. 263 */ 264 265 con_buf_start = con_buf0 = con_buf; 266 orig_count = this_round; 267 maxcol = vc->vc_cols; 268 if (!attr) { 269 org = screen_pos(vc, p, viewed); 270 col = p % maxcol; 271 p += maxcol - col; 272 while (this_round-- > 0) { 273 *con_buf0++ = (vcs_scr_readw(vc, org++) & 0xff); 274 if (++col == maxcol) { 275 org = screen_pos(vc, p, viewed); 276 col = 0; 277 p += maxcol; 278 } 279 } 280 } else { 281 if (p < HEADER_SIZE) { 282 size_t tmp_count; 283 284 con_buf0[0] = (char)vc->vc_rows; 285 con_buf0[1] = (char)vc->vc_cols; 286 getconsxy(vc, con_buf0 + 2); 287 288 con_buf_start += p; 289 this_round += p; 290 if (this_round > CON_BUF_SIZE) { 291 this_round = CON_BUF_SIZE; 292 orig_count = this_round - p; 293 } 294 295 tmp_count = HEADER_SIZE; 296 if (tmp_count > this_round) 297 tmp_count = this_round; 298 299 /* Advance state pointers and move on. */ 300 this_round -= tmp_count; 301 p = HEADER_SIZE; 302 con_buf0 = con_buf + HEADER_SIZE; 303 /* If this_round >= 0, then p is even... */ 304 } else if (p & 1) { 305 /* Skip first byte for output if start address is odd 306 * Update region sizes up/down depending on free 307 * space in buffer. 308 */ 309 con_buf_start++; 310 if (this_round < CON_BUF_SIZE) 311 this_round++; 312 else 313 orig_count--; 314 } 315 if (this_round > 0) { 316 unsigned short *tmp_buf = (unsigned short *)con_buf0; 317 318 p -= HEADER_SIZE; 319 p /= 2; 320 col = p % maxcol; 321 322 org = screen_pos(vc, p, viewed); 323 p += maxcol - col; 324 325 /* Buffer has even length, so we can always copy 326 * character + attribute. We do not copy last byte 327 * to userspace if this_round is odd. 328 */ 329 this_round = (this_round + 1) >> 1; 330 331 while (this_round) { 332 *tmp_buf++ = vcs_scr_readw(vc, org++); 333 this_round --; 334 if (++col == maxcol) { 335 org = screen_pos(vc, p, viewed); 336 col = 0; 337 p += maxcol; 338 } 339 } 340 } 341 } 342 343 /* Finally, release the console semaphore while we push 344 * all the data to userspace from our temporary buffer. 345 * 346 * AKPM: Even though it's a semaphore, we should drop it because 347 * the pagefault handling code may want to call printk(). 348 */ 349 350 console_unlock(); 351 ret = copy_to_user(buf, con_buf_start, orig_count); 352 console_lock(); 353 354 if (ret) { 355 read += (orig_count - ret); 356 ret = -EFAULT; 357 break; 358 } 359 buf += orig_count; 360 pos += orig_count; 361 read += orig_count; 362 count -= orig_count; 363 } 364 *ppos += read; 365 if (read) 366 ret = read; 367 unlock_out: 368 console_unlock(); 369 free_page((unsigned long) con_buf); 370 return ret; 371 } 372 373 static ssize_t 374 vcs_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 375 { 376 struct inode *inode = file_inode(file); 377 unsigned int currcons = iminor(inode); 378 struct vc_data *vc; 379 long pos; 380 long attr, size, written; 381 char *con_buf0; 382 int col, maxcol, viewed; 383 u16 *org0 = NULL, *org = NULL; 384 size_t ret; 385 char *con_buf; 386 387 con_buf = (char *) __get_free_page(GFP_KERNEL); 388 if (!con_buf) 389 return -ENOMEM; 390 391 pos = *ppos; 392 393 /* Select the proper current console and verify 394 * sanity of the situation under the console lock. 395 */ 396 console_lock(); 397 398 attr = (currcons & 128); 399 ret = -ENXIO; 400 vc = vcs_vc(inode, &viewed); 401 if (!vc) 402 goto unlock_out; 403 404 size = vcs_size(inode); 405 ret = -EINVAL; 406 if (pos < 0 || pos > size) 407 goto unlock_out; 408 if (count > size - pos) 409 count = size - pos; 410 written = 0; 411 while (count) { 412 long this_round = count; 413 size_t orig_count; 414 long p; 415 416 if (this_round > CON_BUF_SIZE) 417 this_round = CON_BUF_SIZE; 418 419 /* Temporarily drop the console lock so that we can read 420 * in the write data from userspace safely. 421 */ 422 console_unlock(); 423 ret = copy_from_user(con_buf, buf, this_round); 424 console_lock(); 425 426 if (ret) { 427 this_round -= ret; 428 if (!this_round) { 429 /* Abort loop if no data were copied. Otherwise 430 * fail with -EFAULT. 431 */ 432 if (written) 433 break; 434 ret = -EFAULT; 435 goto unlock_out; 436 } 437 } 438 439 /* The vcs_size might have changed while we slept to grab 440 * the user buffer, so recheck. 441 * Return data written up to now on failure. 442 */ 443 size = vcs_size(inode); 444 if (size < 0) { 445 if (written) 446 break; 447 ret = size; 448 goto unlock_out; 449 } 450 if (pos >= size) 451 break; 452 if (this_round > size - pos) 453 this_round = size - pos; 454 455 /* OK, now actually push the write to the console 456 * under the lock using the local kernel buffer. 457 */ 458 459 con_buf0 = con_buf; 460 orig_count = this_round; 461 maxcol = vc->vc_cols; 462 p = pos; 463 if (!attr) { 464 org0 = org = screen_pos(vc, p, viewed); 465 col = p % maxcol; 466 p += maxcol - col; 467 468 while (this_round > 0) { 469 unsigned char c = *con_buf0++; 470 471 this_round--; 472 vcs_scr_writew(vc, 473 (vcs_scr_readw(vc, org) & 0xff00) | c, org); 474 org++; 475 if (++col == maxcol) { 476 org = screen_pos(vc, p, viewed); 477 col = 0; 478 p += maxcol; 479 } 480 } 481 } else { 482 if (p < HEADER_SIZE) { 483 char header[HEADER_SIZE]; 484 485 getconsxy(vc, header + 2); 486 while (p < HEADER_SIZE && this_round > 0) { 487 this_round--; 488 header[p++] = *con_buf0++; 489 } 490 if (!viewed) 491 putconsxy(vc, header + 2); 492 } 493 p -= HEADER_SIZE; 494 col = (p/2) % maxcol; 495 if (this_round > 0) { 496 org0 = org = screen_pos(vc, p/2, viewed); 497 if ((p & 1) && this_round > 0) { 498 char c; 499 500 this_round--; 501 c = *con_buf0++; 502 #ifdef __BIG_ENDIAN 503 vcs_scr_writew(vc, c | 504 (vcs_scr_readw(vc, org) & 0xff00), org); 505 #else 506 vcs_scr_writew(vc, (c << 8) | 507 (vcs_scr_readw(vc, org) & 0xff), org); 508 #endif 509 org++; 510 p++; 511 if (++col == maxcol) { 512 org = screen_pos(vc, p/2, viewed); 513 col = 0; 514 } 515 } 516 p /= 2; 517 p += maxcol - col; 518 } 519 while (this_round > 1) { 520 unsigned short w; 521 522 w = get_unaligned(((unsigned short *)con_buf0)); 523 vcs_scr_writew(vc, w, org++); 524 con_buf0 += 2; 525 this_round -= 2; 526 if (++col == maxcol) { 527 org = screen_pos(vc, p, viewed); 528 col = 0; 529 p += maxcol; 530 } 531 } 532 if (this_round > 0) { 533 unsigned char c; 534 535 c = *con_buf0++; 536 #ifdef __BIG_ENDIAN 537 vcs_scr_writew(vc, (vcs_scr_readw(vc, org) & 0xff) | (c << 8), org); 538 #else 539 vcs_scr_writew(vc, (vcs_scr_readw(vc, org) & 0xff00) | c, org); 540 #endif 541 } 542 } 543 count -= orig_count; 544 written += orig_count; 545 buf += orig_count; 546 pos += orig_count; 547 if (org0) 548 update_region(vc, (unsigned long)(org0), org - org0); 549 } 550 *ppos += written; 551 ret = written; 552 if (written) 553 vcs_scr_updated(vc); 554 555 unlock_out: 556 console_unlock(); 557 free_page((unsigned long) con_buf); 558 return ret; 559 } 560 561 static unsigned int 562 vcs_poll(struct file *file, poll_table *wait) 563 { 564 struct vcs_poll_data *poll = vcs_poll_data_get(file); 565 int ret = DEFAULT_POLLMASK|POLLERR|POLLPRI; 566 567 if (poll) { 568 poll_wait(file, &poll->waitq, wait); 569 if (poll->seen_last_update) 570 ret = DEFAULT_POLLMASK; 571 } 572 return ret; 573 } 574 575 static int 576 vcs_fasync(int fd, struct file *file, int on) 577 { 578 struct vcs_poll_data *poll = file->private_data; 579 580 if (!poll) { 581 /* don't allocate anything if all we want is disable fasync */ 582 if (!on) 583 return 0; 584 poll = vcs_poll_data_get(file); 585 if (!poll) 586 return -ENOMEM; 587 } 588 589 return fasync_helper(fd, file, on, &poll->fasync); 590 } 591 592 static int 593 vcs_open(struct inode *inode, struct file *filp) 594 { 595 unsigned int currcons = iminor(inode) & 127; 596 int ret = 0; 597 598 console_lock(); 599 if(currcons && !vc_cons_allocated(currcons-1)) 600 ret = -ENXIO; 601 console_unlock(); 602 return ret; 603 } 604 605 static int vcs_release(struct inode *inode, struct file *file) 606 { 607 struct vcs_poll_data *poll = file->private_data; 608 609 if (poll) 610 vcs_poll_data_free(poll); 611 return 0; 612 } 613 614 static const struct file_operations vcs_fops = { 615 .llseek = vcs_lseek, 616 .read = vcs_read, 617 .write = vcs_write, 618 .poll = vcs_poll, 619 .fasync = vcs_fasync, 620 .open = vcs_open, 621 .release = vcs_release, 622 }; 623 624 static struct class *vc_class; 625 626 void vcs_make_sysfs(int index) 627 { 628 device_create(vc_class, NULL, MKDEV(VCS_MAJOR, index + 1), NULL, 629 "vcs%u", index + 1); 630 device_create(vc_class, NULL, MKDEV(VCS_MAJOR, index + 129), NULL, 631 "vcsa%u", index + 1); 632 } 633 634 void vcs_remove_sysfs(int index) 635 { 636 device_destroy(vc_class, MKDEV(VCS_MAJOR, index + 1)); 637 device_destroy(vc_class, MKDEV(VCS_MAJOR, index + 129)); 638 } 639 640 int __init vcs_init(void) 641 { 642 unsigned int i; 643 644 if (register_chrdev(VCS_MAJOR, "vcs", &vcs_fops)) 645 panic("unable to get major %d for vcs device", VCS_MAJOR); 646 vc_class = class_create(THIS_MODULE, "vc"); 647 648 device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 0), NULL, "vcs"); 649 device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 128), NULL, "vcsa"); 650 for (i = 0; i < MIN_NR_CONSOLES; i++) 651 vcs_make_sysfs(i); 652 return 0; 653 } 654