1 /* 2 * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com) 3 * Licensed under the GPL 4 */ 5 6 #include "linux/sched.h" 7 #include "linux/slab.h" 8 #include "linux/list.h" 9 #include "linux/kd.h" 10 #include "linux/interrupt.h" 11 #include "asm/uaccess.h" 12 #include "chan_kern.h" 13 #include "irq_user.h" 14 #include "line.h" 15 #include "kern.h" 16 #include "user_util.h" 17 #include "kern_util.h" 18 #include "os.h" 19 #include "irq_kern.h" 20 21 #define LINE_BUFSIZE 4096 22 23 static irqreturn_t line_interrupt(int irq, void *data) 24 { 25 struct chan *chan = data; 26 struct line *line = chan->line; 27 struct tty_struct *tty = line->tty; 28 29 if (line) 30 chan_interrupt(&line->chan_list, &line->task, tty, irq); 31 return IRQ_HANDLED; 32 } 33 34 static void line_timer_cb(struct work_struct *work) 35 { 36 struct line *line = container_of(work, struct line, task.work); 37 38 if(!line->throttled) 39 chan_interrupt(&line->chan_list, &line->task, line->tty, 40 line->driver->read_irq); 41 } 42 43 /* Returns the free space inside the ring buffer of this line. 44 * 45 * Should be called while holding line->lock (this does not modify datas). 46 */ 47 static int write_room(struct line *line) 48 { 49 int n; 50 51 if (line->buffer == NULL) 52 return LINE_BUFSIZE - 1; 53 54 /* This is for the case where the buffer is wrapped! */ 55 n = line->head - line->tail; 56 57 if (n <= 0) 58 n = LINE_BUFSIZE + n; /* The other case */ 59 return n - 1; 60 } 61 62 int line_write_room(struct tty_struct *tty) 63 { 64 struct line *line = tty->driver_data; 65 unsigned long flags; 66 int room; 67 68 if (tty->stopped) 69 return 0; 70 71 spin_lock_irqsave(&line->lock, flags); 72 room = write_room(line); 73 spin_unlock_irqrestore(&line->lock, flags); 74 75 /*XXX: Warning to remove */ 76 if (0 == room) 77 printk(KERN_DEBUG "%s: %s: no room left in buffer\n", 78 __FUNCTION__,tty->name); 79 return room; 80 } 81 82 int line_chars_in_buffer(struct tty_struct *tty) 83 { 84 struct line *line = tty->driver_data; 85 unsigned long flags; 86 int ret; 87 88 spin_lock_irqsave(&line->lock, flags); 89 90 /*write_room subtracts 1 for the needed NULL, so we readd it.*/ 91 ret = LINE_BUFSIZE - (write_room(line) + 1); 92 spin_unlock_irqrestore(&line->lock, flags); 93 94 return ret; 95 } 96 97 /* 98 * This copies the content of buf into the circular buffer associated with 99 * this line. 100 * The return value is the number of characters actually copied, i.e. the ones 101 * for which there was space: this function is not supposed to ever flush out 102 * the circular buffer. 103 * 104 * Must be called while holding line->lock! 105 */ 106 static int buffer_data(struct line *line, const char *buf, int len) 107 { 108 int end, room; 109 110 if(line->buffer == NULL){ 111 line->buffer = kmalloc(LINE_BUFSIZE, GFP_ATOMIC); 112 if (line->buffer == NULL) { 113 printk("buffer_data - atomic allocation failed\n"); 114 return(0); 115 } 116 line->head = line->buffer; 117 line->tail = line->buffer; 118 } 119 120 room = write_room(line); 121 len = (len > room) ? room : len; 122 123 end = line->buffer + LINE_BUFSIZE - line->tail; 124 125 if (len < end){ 126 memcpy(line->tail, buf, len); 127 line->tail += len; 128 } 129 else { 130 /* The circular buffer is wrapping */ 131 memcpy(line->tail, buf, end); 132 buf += end; 133 memcpy(line->buffer, buf, len - end); 134 line->tail = line->buffer + len - end; 135 } 136 137 return len; 138 } 139 140 /* 141 * Flushes the ring buffer to the output channels. That is, write_chan is 142 * called, passing it line->head as buffer, and an appropriate count. 143 * 144 * On exit, returns 1 when the buffer is empty, 145 * 0 when the buffer is not empty on exit, 146 * and -errno when an error occurred. 147 * 148 * Must be called while holding line->lock!*/ 149 static int flush_buffer(struct line *line) 150 { 151 int n, count; 152 153 if ((line->buffer == NULL) || (line->head == line->tail)) 154 return 1; 155 156 if (line->tail < line->head) { 157 /* line->buffer + LINE_BUFSIZE is the end of the buffer! */ 158 count = line->buffer + LINE_BUFSIZE - line->head; 159 160 n = write_chan(&line->chan_list, line->head, count, 161 line->driver->write_irq); 162 if (n < 0) 163 return n; 164 if (n == count) { 165 /* We have flushed from ->head to buffer end, now we 166 * must flush only from the beginning to ->tail.*/ 167 line->head = line->buffer; 168 } else { 169 line->head += n; 170 return 0; 171 } 172 } 173 174 count = line->tail - line->head; 175 n = write_chan(&line->chan_list, line->head, count, 176 line->driver->write_irq); 177 178 if(n < 0) 179 return n; 180 181 line->head += n; 182 return line->head == line->tail; 183 } 184 185 void line_flush_buffer(struct tty_struct *tty) 186 { 187 struct line *line = tty->driver_data; 188 unsigned long flags; 189 int err; 190 191 /*XXX: copied from line_write, verify if it is correct!*/ 192 if(tty->stopped) 193 return; 194 //return 0; 195 196 spin_lock_irqsave(&line->lock, flags); 197 err = flush_buffer(line); 198 /*if (err == 1) 199 err = 0;*/ 200 spin_unlock_irqrestore(&line->lock, flags); 201 //return err; 202 } 203 204 /* We map both ->flush_chars and ->put_char (which go in pair) onto ->flush_buffer 205 * and ->write. Hope it's not that bad.*/ 206 void line_flush_chars(struct tty_struct *tty) 207 { 208 line_flush_buffer(tty); 209 } 210 211 void line_put_char(struct tty_struct *tty, unsigned char ch) 212 { 213 line_write(tty, &ch, sizeof(ch)); 214 } 215 216 int line_write(struct tty_struct *tty, const unsigned char *buf, int len) 217 { 218 struct line *line = tty->driver_data; 219 unsigned long flags; 220 int n, err, ret = 0; 221 222 if(tty->stopped) 223 return 0; 224 225 spin_lock_irqsave(&line->lock, flags); 226 if (line->head != line->tail) { 227 ret = buffer_data(line, buf, len); 228 err = flush_buffer(line); 229 if (err <= 0 && (err != -EAGAIN || !ret)) 230 ret = err; 231 } else { 232 n = write_chan(&line->chan_list, buf, len, 233 line->driver->write_irq); 234 if (n < 0) { 235 ret = n; 236 goto out_up; 237 } 238 239 len -= n; 240 ret += n; 241 if (len > 0) 242 ret += buffer_data(line, buf + n, len); 243 } 244 out_up: 245 spin_unlock_irqrestore(&line->lock, flags); 246 return ret; 247 } 248 249 void line_set_termios(struct tty_struct *tty, struct ktermios * old) 250 { 251 /* nothing */ 252 } 253 254 static const struct { 255 int cmd; 256 char *level; 257 char *name; 258 } tty_ioctls[] = { 259 /* don't print these, they flood the log ... */ 260 { TCGETS, NULL, "TCGETS" }, 261 { TCSETS, NULL, "TCSETS" }, 262 { TCSETSW, NULL, "TCSETSW" }, 263 { TCFLSH, NULL, "TCFLSH" }, 264 { TCSBRK, NULL, "TCSBRK" }, 265 266 /* general tty stuff */ 267 { TCSETSF, KERN_DEBUG, "TCSETSF" }, 268 { TCGETA, KERN_DEBUG, "TCGETA" }, 269 { TIOCMGET, KERN_DEBUG, "TIOCMGET" }, 270 { TCSBRKP, KERN_DEBUG, "TCSBRKP" }, 271 { TIOCMSET, KERN_DEBUG, "TIOCMSET" }, 272 273 /* linux-specific ones */ 274 { TIOCLINUX, KERN_INFO, "TIOCLINUX" }, 275 { KDGKBMODE, KERN_INFO, "KDGKBMODE" }, 276 { KDGKBTYPE, KERN_INFO, "KDGKBTYPE" }, 277 { KDSIGACCEPT, KERN_INFO, "KDSIGACCEPT" }, 278 }; 279 280 int line_ioctl(struct tty_struct *tty, struct file * file, 281 unsigned int cmd, unsigned long arg) 282 { 283 int ret; 284 int i; 285 286 ret = 0; 287 switch(cmd) { 288 #ifdef TIOCGETP 289 case TIOCGETP: 290 case TIOCSETP: 291 case TIOCSETN: 292 #endif 293 #ifdef TIOCGETC 294 case TIOCGETC: 295 case TIOCSETC: 296 #endif 297 #ifdef TIOCGLTC 298 case TIOCGLTC: 299 case TIOCSLTC: 300 #endif 301 case TCGETS: 302 case TCSETSF: 303 case TCSETSW: 304 case TCSETS: 305 case TCGETA: 306 case TCSETAF: 307 case TCSETAW: 308 case TCSETA: 309 case TCXONC: 310 case TCFLSH: 311 case TIOCOUTQ: 312 case TIOCINQ: 313 case TIOCGLCKTRMIOS: 314 case TIOCSLCKTRMIOS: 315 case TIOCPKT: 316 case TIOCGSOFTCAR: 317 case TIOCSSOFTCAR: 318 return -ENOIOCTLCMD; 319 #if 0 320 case TCwhatever: 321 /* do something */ 322 break; 323 #endif 324 default: 325 for (i = 0; i < ARRAY_SIZE(tty_ioctls); i++) 326 if (cmd == tty_ioctls[i].cmd) 327 break; 328 if (i < ARRAY_SIZE(tty_ioctls)) { 329 if (NULL != tty_ioctls[i].level) 330 printk("%s%s: %s: ioctl %s called\n", 331 tty_ioctls[i].level, __FUNCTION__, 332 tty->name, tty_ioctls[i].name); 333 } else { 334 printk(KERN_ERR "%s: %s: unknown ioctl: 0x%x\n", 335 __FUNCTION__, tty->name, cmd); 336 } 337 ret = -ENOIOCTLCMD; 338 break; 339 } 340 return ret; 341 } 342 343 void line_throttle(struct tty_struct *tty) 344 { 345 struct line *line = tty->driver_data; 346 347 deactivate_chan(&line->chan_list, line->driver->read_irq); 348 line->throttled = 1; 349 } 350 351 void line_unthrottle(struct tty_struct *tty) 352 { 353 struct line *line = tty->driver_data; 354 355 line->throttled = 0; 356 chan_interrupt(&line->chan_list, &line->task, tty, 357 line->driver->read_irq); 358 359 /* Maybe there is enough stuff pending that calling the interrupt 360 * throttles us again. In this case, line->throttled will be 1 361 * again and we shouldn't turn the interrupt back on. 362 */ 363 if(!line->throttled) 364 reactivate_chan(&line->chan_list, line->driver->read_irq); 365 } 366 367 static irqreturn_t line_write_interrupt(int irq, void *data) 368 { 369 struct chan *chan = data; 370 struct line *line = chan->line; 371 struct tty_struct *tty = line->tty; 372 int err; 373 374 /* Interrupts are enabled here because we registered the interrupt with 375 * IRQF_DISABLED (see line_setup_irq).*/ 376 377 spin_lock_irq(&line->lock); 378 err = flush_buffer(line); 379 if (err == 0) { 380 return IRQ_NONE; 381 } else if(err < 0) { 382 line->head = line->buffer; 383 line->tail = line->buffer; 384 } 385 spin_unlock_irq(&line->lock); 386 387 if(tty == NULL) 388 return IRQ_NONE; 389 390 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) && 391 (tty->ldisc.write_wakeup != NULL)) 392 (tty->ldisc.write_wakeup)(tty); 393 394 /* BLOCKING mode 395 * In blocking mode, everything sleeps on tty->write_wait. 396 * Sleeping in the console driver would break non-blocking 397 * writes. 398 */ 399 400 if (waitqueue_active(&tty->write_wait)) 401 wake_up_interruptible(&tty->write_wait); 402 return IRQ_HANDLED; 403 } 404 405 int line_setup_irq(int fd, int input, int output, struct line *line, void *data) 406 { 407 const struct line_driver *driver = line->driver; 408 int err = 0, flags = IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM; 409 410 if (input) 411 err = um_request_irq(driver->read_irq, fd, IRQ_READ, 412 line_interrupt, flags, 413 driver->read_irq_name, data); 414 if (err) 415 return err; 416 if (output) 417 err = um_request_irq(driver->write_irq, fd, IRQ_WRITE, 418 line_write_interrupt, flags, 419 driver->write_irq_name, data); 420 line->have_irq = 1; 421 return err; 422 } 423 424 int line_open(struct line *lines, struct tty_struct *tty) 425 { 426 struct line *line; 427 int err = -ENODEV; 428 429 line = &lines[tty->index]; 430 tty->driver_data = line; 431 432 /* The IRQ which takes this lock is not yet enabled and won't be run 433 * before the end, so we don't need to use spin_lock_irq.*/ 434 spin_lock(&line->lock); 435 436 tty->driver_data = line; 437 line->tty = tty; 438 if(!line->valid) 439 goto out; 440 441 if(tty->count == 1){ 442 /* Here the device is opened, if necessary, and interrupt 443 * is registered. 444 */ 445 enable_chan(line); 446 INIT_DELAYED_WORK(&line->task, line_timer_cb); 447 448 if(!line->sigio){ 449 chan_enable_winch(&line->chan_list, tty); 450 line->sigio = 1; 451 } 452 453 chan_window_size(&line->chan_list, &tty->winsize.ws_row, 454 &tty->winsize.ws_col); 455 } 456 457 err = 0; 458 out: 459 spin_unlock(&line->lock); 460 return err; 461 } 462 463 static void unregister_winch(struct tty_struct *tty); 464 465 void line_close(struct tty_struct *tty, struct file * filp) 466 { 467 struct line *line = tty->driver_data; 468 469 /* XXX: I assume this should be called in process context, not with 470 * interrupts disabled! 471 */ 472 spin_lock_irq(&line->lock); 473 474 /* We ignore the error anyway! */ 475 flush_buffer(line); 476 477 if(tty->count == 1){ 478 line->tty = NULL; 479 tty->driver_data = NULL; 480 481 if(line->sigio){ 482 unregister_winch(tty); 483 line->sigio = 0; 484 } 485 } 486 487 spin_unlock_irq(&line->lock); 488 } 489 490 void close_lines(struct line *lines, int nlines) 491 { 492 int i; 493 494 for(i = 0; i < nlines; i++) 495 close_chan(&lines[i].chan_list, 0); 496 } 497 498 /* Common setup code for both startup command line and mconsole initialization. 499 * @lines contains the array (of size @num) to modify; 500 * @init is the setup string; 501 */ 502 503 int line_setup(struct line *lines, unsigned int num, char *init) 504 { 505 int i, n; 506 char *end; 507 508 if(*init == '=') { 509 /* We said con=/ssl= instead of con#=, so we are configuring all 510 * consoles at once.*/ 511 n = -1; 512 } 513 else { 514 n = simple_strtoul(init, &end, 0); 515 if(*end != '='){ 516 printk(KERN_ERR "line_setup failed to parse \"%s\"\n", 517 init); 518 return 0; 519 } 520 init = end; 521 } 522 init++; 523 524 if (n >= (signed int) num) { 525 printk("line_setup - %d out of range ((0 ... %d) allowed)\n", 526 n, num - 1); 527 return 0; 528 } 529 else if (n >= 0){ 530 if (lines[n].tty != NULL) { 531 printk("line_setup - device %d is open\n", n); 532 return 0; 533 } 534 if (lines[n].init_pri <= INIT_ONE){ 535 lines[n].init_pri = INIT_ONE; 536 if (!strcmp(init, "none")) 537 lines[n].valid = 0; 538 else { 539 lines[n].init_str = init; 540 lines[n].valid = 1; 541 } 542 } 543 } 544 else { 545 for(i = 0; i < num; i++){ 546 if(lines[i].init_pri <= INIT_ALL){ 547 lines[i].init_pri = INIT_ALL; 548 if(!strcmp(init, "none")) lines[i].valid = 0; 549 else { 550 lines[i].init_str = init; 551 lines[i].valid = 1; 552 } 553 } 554 } 555 } 556 return n == -1 ? num : n; 557 } 558 559 int line_config(struct line *lines, unsigned int num, char *str, 560 const struct chan_opts *opts) 561 { 562 struct line *line; 563 char *new; 564 int n; 565 566 if(*str == '='){ 567 printk("line_config - can't configure all devices from " 568 "mconsole\n"); 569 return 1; 570 } 571 572 new = kstrdup(str, GFP_KERNEL); 573 if(new == NULL){ 574 printk("line_config - kstrdup failed\n"); 575 return 1; 576 } 577 n = line_setup(lines, num, new); 578 if(n < 0) 579 return 1; 580 581 line = &lines[n]; 582 return parse_chan_pair(line->init_str, line, n, opts); 583 } 584 585 int line_get_config(char *name, struct line *lines, unsigned int num, char *str, 586 int size, char **error_out) 587 { 588 struct line *line; 589 char *end; 590 int dev, n = 0; 591 592 dev = simple_strtoul(name, &end, 0); 593 if((*end != '\0') || (end == name)){ 594 *error_out = "line_get_config failed to parse device number"; 595 return 0; 596 } 597 598 if((dev < 0) || (dev >= num)){ 599 *error_out = "device number out of range"; 600 return 0; 601 } 602 603 line = &lines[dev]; 604 605 spin_lock(&line->lock); 606 if(!line->valid) 607 CONFIG_CHUNK(str, size, n, "none", 1); 608 else if(line->tty == NULL) 609 CONFIG_CHUNK(str, size, n, line->init_str, 1); 610 else n = chan_config_string(&line->chan_list, str, size, error_out); 611 spin_unlock(&line->lock); 612 613 return n; 614 } 615 616 int line_id(char **str, int *start_out, int *end_out) 617 { 618 char *end; 619 int n; 620 621 n = simple_strtoul(*str, &end, 0); 622 if((*end != '\0') || (end == *str)) 623 return -1; 624 625 *str = end; 626 *start_out = n; 627 *end_out = n; 628 return n; 629 } 630 631 int line_remove(struct line *lines, unsigned int num, int n) 632 { 633 int err; 634 char config[sizeof("conxxxx=none\0")]; 635 636 sprintf(config, "%d=none", n); 637 err = line_setup(lines, num, config); 638 if(err >= 0) 639 err = 0; 640 return err; 641 } 642 643 struct tty_driver *line_register_devfs(struct lines *set, 644 struct line_driver *line_driver, 645 const struct tty_operations *ops, 646 struct line *lines, int nlines) 647 { 648 int i; 649 struct tty_driver *driver = alloc_tty_driver(nlines); 650 651 if (!driver) 652 return NULL; 653 654 driver->driver_name = line_driver->name; 655 driver->name = line_driver->device_name; 656 driver->major = line_driver->major; 657 driver->minor_start = line_driver->minor_start; 658 driver->type = line_driver->type; 659 driver->subtype = line_driver->subtype; 660 driver->flags = TTY_DRIVER_REAL_RAW; 661 driver->init_termios = tty_std_termios; 662 tty_set_operations(driver, ops); 663 664 if (tty_register_driver(driver)) { 665 printk("%s: can't register %s driver\n", 666 __FUNCTION__,line_driver->name); 667 put_tty_driver(driver); 668 return NULL; 669 } 670 671 for(i = 0; i < nlines; i++){ 672 if(!lines[i].valid) 673 tty_unregister_device(driver, i); 674 } 675 676 mconsole_register_dev(&line_driver->mc); 677 return driver; 678 } 679 680 static DEFINE_SPINLOCK(winch_handler_lock); 681 static LIST_HEAD(winch_handlers); 682 683 void lines_init(struct line *lines, int nlines, struct chan_opts *opts) 684 { 685 struct line *line; 686 int i; 687 688 for(i = 0; i < nlines; i++){ 689 line = &lines[i]; 690 INIT_LIST_HEAD(&line->chan_list); 691 692 if(line->init_str == NULL) 693 continue; 694 695 line->init_str = kstrdup(line->init_str, GFP_KERNEL); 696 if(line->init_str == NULL) 697 printk("lines_init - kstrdup returned NULL\n"); 698 699 if(parse_chan_pair(line->init_str, line, i, opts)){ 700 printk("parse_chan_pair failed for device %d\n", i); 701 line->valid = 0; 702 } 703 } 704 } 705 706 struct winch { 707 struct list_head list; 708 int fd; 709 int tty_fd; 710 int pid; 711 struct tty_struct *tty; 712 }; 713 714 static irqreturn_t winch_interrupt(int irq, void *data) 715 { 716 struct winch *winch = data; 717 struct tty_struct *tty; 718 struct line *line; 719 int err; 720 char c; 721 722 if(winch->fd != -1){ 723 err = generic_read(winch->fd, &c, NULL); 724 if(err < 0){ 725 if(err != -EAGAIN){ 726 printk("winch_interrupt : read failed, " 727 "errno = %d\n", -err); 728 printk("fd %d is losing SIGWINCH support\n", 729 winch->tty_fd); 730 return IRQ_HANDLED; 731 } 732 goto out; 733 } 734 } 735 tty = winch->tty; 736 if (tty != NULL) { 737 line = tty->driver_data; 738 chan_window_size(&line->chan_list, &tty->winsize.ws_row, 739 &tty->winsize.ws_col); 740 kill_pg(tty->pgrp, SIGWINCH, 1); 741 } 742 out: 743 if(winch->fd != -1) 744 reactivate_fd(winch->fd, WINCH_IRQ); 745 return IRQ_HANDLED; 746 } 747 748 void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty) 749 { 750 struct winch *winch; 751 752 winch = kmalloc(sizeof(*winch), GFP_KERNEL); 753 if (winch == NULL) { 754 printk("register_winch_irq - kmalloc failed\n"); 755 return; 756 } 757 758 *winch = ((struct winch) { .list = LIST_HEAD_INIT(winch->list), 759 .fd = fd, 760 .tty_fd = tty_fd, 761 .pid = pid, 762 .tty = tty }); 763 764 spin_lock(&winch_handler_lock); 765 list_add(&winch->list, &winch_handlers); 766 spin_unlock(&winch_handler_lock); 767 768 if(um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt, 769 IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM, 770 "winch", winch) < 0) 771 printk("register_winch_irq - failed to register IRQ\n"); 772 } 773 774 static void free_winch(struct winch *winch) 775 { 776 list_del(&winch->list); 777 778 if(winch->pid != -1) 779 os_kill_process(winch->pid, 1); 780 if(winch->fd != -1) 781 os_close_file(winch->fd); 782 783 free_irq(WINCH_IRQ, winch); 784 kfree(winch); 785 } 786 787 static void unregister_winch(struct tty_struct *tty) 788 { 789 struct list_head *ele; 790 struct winch *winch; 791 792 spin_lock(&winch_handler_lock); 793 794 list_for_each(ele, &winch_handlers){ 795 winch = list_entry(ele, struct winch, list); 796 if(winch->tty == tty){ 797 free_winch(winch); 798 break; 799 } 800 } 801 spin_unlock(&winch_handler_lock); 802 } 803 804 static void winch_cleanup(void) 805 { 806 struct list_head *ele, *next; 807 struct winch *winch; 808 809 spin_lock(&winch_handler_lock); 810 811 list_for_each_safe(ele, next, &winch_handlers){ 812 winch = list_entry(ele, struct winch, list); 813 free_winch(winch); 814 } 815 816 spin_unlock(&winch_handler_lock); 817 } 818 __uml_exitcall(winch_cleanup); 819 820 char *add_xterm_umid(char *base) 821 { 822 char *umid, *title; 823 int len; 824 825 umid = get_umid(); 826 if(*umid == '\0') 827 return base; 828 829 len = strlen(base) + strlen(" ()") + strlen(umid) + 1; 830 title = kmalloc(len, GFP_KERNEL); 831 if(title == NULL){ 832 printk("Failed to allocate buffer for xterm title\n"); 833 return base; 834 } 835 836 snprintf(title, len, "%s (%s)", base, umid); 837 return title; 838 } 839