~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/um/drivers/line.c

Version: ~ [ linux-5.5-rc1 ] ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp