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

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

Version: ~ [ linux-5.4 ] ~ [ linux-5.3.13 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.86 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.156 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.203 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.202 ] ~ [ 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) 2000 - 2007 Jeff Dike (jdike@{linux.intel,addtoit}.com)
  3  * Licensed under the GPL
  4  */
  5 
  6 #include <linux/slab.h>
  7 #include <linux/tty.h>
  8 #include <linux/tty_flip.h>
  9 #include "chan.h"
 10 #include <os.h>
 11 #include <irq_kern.h>
 12 
 13 #ifdef CONFIG_NOCONFIG_CHAN
 14 static void *not_configged_init(char *str, int device,
 15                                 const struct chan_opts *opts)
 16 {
 17         printk(KERN_ERR "Using a channel type which is configured out of "
 18                "UML\n");
 19         return NULL;
 20 }
 21 
 22 static int not_configged_open(int input, int output, int primary, void *data,
 23                               char **dev_out)
 24 {
 25         printk(KERN_ERR "Using a channel type which is configured out of "
 26                "UML\n");
 27         return -ENODEV;
 28 }
 29 
 30 static void not_configged_close(int fd, void *data)
 31 {
 32         printk(KERN_ERR "Using a channel type which is configured out of "
 33                "UML\n");
 34 }
 35 
 36 static int not_configged_read(int fd, char *c_out, void *data)
 37 {
 38         printk(KERN_ERR "Using a channel type which is configured out of "
 39                "UML\n");
 40         return -EIO;
 41 }
 42 
 43 static int not_configged_write(int fd, const char *buf, int len, void *data)
 44 {
 45         printk(KERN_ERR "Using a channel type which is configured out of "
 46                "UML\n");
 47         return -EIO;
 48 }
 49 
 50 static int not_configged_console_write(int fd, const char *buf, int len)
 51 {
 52         printk(KERN_ERR "Using a channel type which is configured out of "
 53                "UML\n");
 54         return -EIO;
 55 }
 56 
 57 static int not_configged_window_size(int fd, void *data, unsigned short *rows,
 58                                      unsigned short *cols)
 59 {
 60         printk(KERN_ERR "Using a channel type which is configured out of "
 61                "UML\n");
 62         return -ENODEV;
 63 }
 64 
 65 static void not_configged_free(void *data)
 66 {
 67         printk(KERN_ERR "Using a channel type which is configured out of "
 68                "UML\n");
 69 }
 70 
 71 static const struct chan_ops not_configged_ops = {
 72         .init           = not_configged_init,
 73         .open           = not_configged_open,
 74         .close          = not_configged_close,
 75         .read           = not_configged_read,
 76         .write          = not_configged_write,
 77         .console_write  = not_configged_console_write,
 78         .window_size    = not_configged_window_size,
 79         .free           = not_configged_free,
 80         .winch          = 0,
 81 };
 82 #endif /* CONFIG_NOCONFIG_CHAN */
 83 
 84 static int open_one_chan(struct chan *chan)
 85 {
 86         int fd, err;
 87 
 88         if (chan->opened)
 89                 return 0;
 90 
 91         if (chan->ops->open == NULL)
 92                 fd = 0;
 93         else fd = (*chan->ops->open)(chan->input, chan->output, chan->primary,
 94                                      chan->data, &chan->dev);
 95         if (fd < 0)
 96                 return fd;
 97 
 98         err = os_set_fd_block(fd, 0);
 99         if (err) {
100                 (*chan->ops->close)(fd, chan->data);
101                 return err;
102         }
103 
104         chan->fd = fd;
105 
106         chan->opened = 1;
107         return 0;
108 }
109 
110 static int open_chan(struct list_head *chans)
111 {
112         struct list_head *ele;
113         struct chan *chan;
114         int ret, err = 0;
115 
116         list_for_each(ele, chans) {
117                 chan = list_entry(ele, struct chan, list);
118                 ret = open_one_chan(chan);
119                 if (chan->primary)
120                         err = ret;
121         }
122         return err;
123 }
124 
125 void chan_enable_winch(struct chan *chan, struct tty_port *port)
126 {
127         if (chan && chan->primary && chan->ops->winch)
128                 register_winch(chan->fd, port);
129 }
130 
131 static void line_timer_cb(struct work_struct *work)
132 {
133         struct line *line = container_of(work, struct line, task.work);
134 
135         if (!line->throttled)
136                 chan_interrupt(line, line->driver->read_irq);
137 }
138 
139 int enable_chan(struct line *line)
140 {
141         struct list_head *ele;
142         struct chan *chan;
143         int err;
144 
145         INIT_DELAYED_WORK(&line->task, line_timer_cb);
146 
147         list_for_each(ele, &line->chan_list) {
148                 chan = list_entry(ele, struct chan, list);
149                 err = open_one_chan(chan);
150                 if (err) {
151                         if (chan->primary)
152                                 goto out_close;
153 
154                         continue;
155                 }
156 
157                 if (chan->enabled)
158                         continue;
159                 err = line_setup_irq(chan->fd, chan->input, chan->output, line,
160                                      chan);
161                 if (err)
162                         goto out_close;
163 
164                 chan->enabled = 1;
165         }
166 
167         return 0;
168 
169  out_close:
170         close_chan(line);
171         return err;
172 }
173 
174 /* Items are added in IRQ context, when free_irq can't be called, and
175  * removed in process context, when it can.
176  * This handles interrupt sources which disappear, and which need to
177  * be permanently disabled.  This is discovered in IRQ context, but
178  * the freeing of the IRQ must be done later.
179  */
180 static DEFINE_SPINLOCK(irqs_to_free_lock);
181 static LIST_HEAD(irqs_to_free);
182 
183 void free_irqs(void)
184 {
185         struct chan *chan;
186         LIST_HEAD(list);
187         struct list_head *ele;
188         unsigned long flags;
189 
190         spin_lock_irqsave(&irqs_to_free_lock, flags);
191         list_splice_init(&irqs_to_free, &list);
192         spin_unlock_irqrestore(&irqs_to_free_lock, flags);
193 
194         list_for_each(ele, &list) {
195                 chan = list_entry(ele, struct chan, free_list);
196 
197                 if (chan->input && chan->enabled)
198                         um_free_irq(chan->line->driver->read_irq, chan);
199                 if (chan->output && chan->enabled)
200                         um_free_irq(chan->line->driver->write_irq, chan);
201                 chan->enabled = 0;
202         }
203 }
204 
205 static void close_one_chan(struct chan *chan, int delay_free_irq)
206 {
207         unsigned long flags;
208 
209         if (!chan->opened)
210                 return;
211 
212         if (delay_free_irq) {
213                 spin_lock_irqsave(&irqs_to_free_lock, flags);
214                 list_add(&chan->free_list, &irqs_to_free);
215                 spin_unlock_irqrestore(&irqs_to_free_lock, flags);
216         }
217         else {
218                 if (chan->input && chan->enabled)
219                         um_free_irq(chan->line->driver->read_irq, chan);
220                 if (chan->output && chan->enabled)
221                         um_free_irq(chan->line->driver->write_irq, chan);
222                 chan->enabled = 0;
223         }
224         if (chan->ops->close != NULL)
225                 (*chan->ops->close)(chan->fd, chan->data);
226 
227         chan->opened = 0;
228         chan->fd = -1;
229 }
230 
231 void close_chan(struct line *line)
232 {
233         struct chan *chan;
234 
235         /* Close in reverse order as open in case more than one of them
236          * refers to the same device and they save and restore that device's
237          * state.  Then, the first one opened will have the original state,
238          * so it must be the last closed.
239          */
240         list_for_each_entry_reverse(chan, &line->chan_list, list) {
241                 close_one_chan(chan, 0);
242         }
243 }
244 
245 void deactivate_chan(struct chan *chan, int irq)
246 {
247         if (chan && chan->enabled)
248                 deactivate_fd(chan->fd, irq);
249 }
250 
251 void reactivate_chan(struct chan *chan, int irq)
252 {
253         if (chan && chan->enabled)
254                 reactivate_fd(chan->fd, irq);
255 }
256 
257 int write_chan(struct chan *chan, const char *buf, int len,
258                int write_irq)
259 {
260         int n, ret = 0;
261 
262         if (len == 0 || !chan || !chan->ops->write)
263                 return 0;
264 
265         n = chan->ops->write(chan->fd, buf, len, chan->data);
266         if (chan->primary) {
267                 ret = n;
268                 if ((ret == -EAGAIN) || ((ret >= 0) && (ret < len)))
269                         reactivate_fd(chan->fd, write_irq);
270         }
271         return ret;
272 }
273 
274 int console_write_chan(struct chan *chan, const char *buf, int len)
275 {
276         int n, ret = 0;
277 
278         if (!chan || !chan->ops->console_write)
279                 return 0;
280 
281         n = chan->ops->console_write(chan->fd, buf, len);
282         if (chan->primary)
283                 ret = n;
284         return ret;
285 }
286 
287 int console_open_chan(struct line *line, struct console *co)
288 {
289         int err;
290 
291         err = open_chan(&line->chan_list);
292         if (err)
293                 return err;
294 
295         printk(KERN_INFO "Console initialized on /dev/%s%d\n", co->name,
296                co->index);
297         return 0;
298 }
299 
300 int chan_window_size(struct line *line, unsigned short *rows_out,
301                       unsigned short *cols_out)
302 {
303         struct chan *chan;
304 
305         chan = line->chan_in;
306         if (chan && chan->primary) {
307                 if (chan->ops->window_size == NULL)
308                         return 0;
309                 return chan->ops->window_size(chan->fd, chan->data,
310                                               rows_out, cols_out);
311         }
312         chan = line->chan_out;
313         if (chan && chan->primary) {
314                 if (chan->ops->window_size == NULL)
315                         return 0;
316                 return chan->ops->window_size(chan->fd, chan->data,
317                                               rows_out, cols_out);
318         }
319         return 0;
320 }
321 
322 static void free_one_chan(struct chan *chan)
323 {
324         list_del(&chan->list);
325 
326         close_one_chan(chan, 0);
327 
328         if (chan->ops->free != NULL)
329                 (*chan->ops->free)(chan->data);
330 
331         if (chan->primary && chan->output)
332                 ignore_sigio_fd(chan->fd);
333         kfree(chan);
334 }
335 
336 static void free_chan(struct list_head *chans)
337 {
338         struct list_head *ele, *next;
339         struct chan *chan;
340 
341         list_for_each_safe(ele, next, chans) {
342                 chan = list_entry(ele, struct chan, list);
343                 free_one_chan(chan);
344         }
345 }
346 
347 static int one_chan_config_string(struct chan *chan, char *str, int size,
348                                   char **error_out)
349 {
350         int n = 0;
351 
352         if (chan == NULL) {
353                 CONFIG_CHUNK(str, size, n, "none", 1);
354                 return n;
355         }
356 
357         CONFIG_CHUNK(str, size, n, chan->ops->type, 0);
358 
359         if (chan->dev == NULL) {
360                 CONFIG_CHUNK(str, size, n, "", 1);
361                 return n;
362         }
363 
364         CONFIG_CHUNK(str, size, n, ":", 0);
365         CONFIG_CHUNK(str, size, n, chan->dev, 0);
366 
367         return n;
368 }
369 
370 static int chan_pair_config_string(struct chan *in, struct chan *out,
371                                    char *str, int size, char **error_out)
372 {
373         int n;
374 
375         n = one_chan_config_string(in, str, size, error_out);
376         str += n;
377         size -= n;
378 
379         if (in == out) {
380                 CONFIG_CHUNK(str, size, n, "", 1);
381                 return n;
382         }
383 
384         CONFIG_CHUNK(str, size, n, ",", 1);
385         n = one_chan_config_string(out, str, size, error_out);
386         str += n;
387         size -= n;
388         CONFIG_CHUNK(str, size, n, "", 1);
389 
390         return n;
391 }
392 
393 int chan_config_string(struct line *line, char *str, int size,
394                        char **error_out)
395 {
396         struct chan *in = line->chan_in, *out = line->chan_out;
397 
398         if (in && !in->primary)
399                 in = NULL;
400         if (out && !out->primary)
401                 out = NULL;
402 
403         return chan_pair_config_string(in, out, str, size, error_out);
404 }
405 
406 struct chan_type {
407         char *key;
408         const struct chan_ops *ops;
409 };
410 
411 static const struct chan_type chan_table[] = {
412         { "fd", &fd_ops },
413 
414 #ifdef CONFIG_NULL_CHAN
415         { "null", &null_ops },
416 #else
417         { "null", &not_configged_ops },
418 #endif
419 
420 #ifdef CONFIG_PORT_CHAN
421         { "port", &port_ops },
422 #else
423         { "port", &not_configged_ops },
424 #endif
425 
426 #ifdef CONFIG_PTY_CHAN
427         { "pty", &pty_ops },
428         { "pts", &pts_ops },
429 #else
430         { "pty", &not_configged_ops },
431         { "pts", &not_configged_ops },
432 #endif
433 
434 #ifdef CONFIG_TTY_CHAN
435         { "tty", &tty_ops },
436 #else
437         { "tty", &not_configged_ops },
438 #endif
439 
440 #ifdef CONFIG_XTERM_CHAN
441         { "xterm", &xterm_ops },
442 #else
443         { "xterm", &not_configged_ops },
444 #endif
445 };
446 
447 static struct chan *parse_chan(struct line *line, char *str, int device,
448                                const struct chan_opts *opts, char **error_out)
449 {
450         const struct chan_type *entry;
451         const struct chan_ops *ops;
452         struct chan *chan;
453         void *data;
454         int i;
455 
456         ops = NULL;
457         data = NULL;
458         for(i = 0; i < ARRAY_SIZE(chan_table); i++) {
459                 entry = &chan_table[i];
460                 if (!strncmp(str, entry->key, strlen(entry->key))) {
461                         ops = entry->ops;
462                         str += strlen(entry->key);
463                         break;
464                 }
465         }
466         if (ops == NULL) {
467                 *error_out = "No match for configured backends";
468                 return NULL;
469         }
470 
471         data = (*ops->init)(str, device, opts);
472         if (data == NULL) {
473                 *error_out = "Configuration failed";
474                 return NULL;
475         }
476 
477         chan = kmalloc(sizeof(*chan), GFP_ATOMIC);
478         if (chan == NULL) {
479                 *error_out = "Memory allocation failed";
480                 return NULL;
481         }
482         *chan = ((struct chan) { .list          = LIST_HEAD_INIT(chan->list),
483                                  .free_list     =
484                                         LIST_HEAD_INIT(chan->free_list),
485                                  .line          = line,
486                                  .primary       = 1,
487                                  .input         = 0,
488                                  .output        = 0,
489                                  .opened        = 0,
490                                  .enabled       = 0,
491                                  .fd            = -1,
492                                  .ops           = ops,
493                                  .data          = data });
494         return chan;
495 }
496 
497 int parse_chan_pair(char *str, struct line *line, int device,
498                     const struct chan_opts *opts, char **error_out)
499 {
500         struct list_head *chans = &line->chan_list;
501         struct chan *new;
502         char *in, *out;
503 
504         if (!list_empty(chans)) {
505                 line->chan_in = line->chan_out = NULL;
506                 free_chan(chans);
507                 INIT_LIST_HEAD(chans);
508         }
509 
510         if (!str)
511                 return 0;
512 
513         out = strchr(str, ',');
514         if (out != NULL) {
515                 in = str;
516                 *out = '\0';
517                 out++;
518                 new = parse_chan(line, in, device, opts, error_out);
519                 if (new == NULL)
520                         return -1;
521 
522                 new->input = 1;
523                 list_add(&new->list, chans);
524                 line->chan_in = new;
525 
526                 new = parse_chan(line, out, device, opts, error_out);
527                 if (new == NULL)
528                         return -1;
529 
530                 list_add(&new->list, chans);
531                 new->output = 1;
532                 line->chan_out = new;
533         }
534         else {
535                 new = parse_chan(line, str, device, opts, error_out);
536                 if (new == NULL)
537                         return -1;
538 
539                 list_add(&new->list, chans);
540                 new->input = 1;
541                 new->output = 1;
542                 line->chan_in = line->chan_out = new;
543         }
544         return 0;
545 }
546 
547 void chan_interrupt(struct line *line, int irq)
548 {
549         struct tty_port *port = &line->port;
550         struct chan *chan = line->chan_in;
551         int err;
552         char c;
553 
554         if (!chan || !chan->ops->read)
555                 goto out;
556 
557         do {
558                 if (!tty_buffer_request_room(port, 1)) {
559                         schedule_delayed_work(&line->task, 1);
560                         goto out;
561                 }
562                 err = chan->ops->read(chan->fd, &c, chan->data);
563                 if (err > 0)
564                         tty_insert_flip_char(port, c, TTY_NORMAL);
565         } while (err > 0);
566 
567         if (err == 0)
568                 reactivate_fd(chan->fd, irq);
569         if (err == -EIO) {
570                 if (chan->primary) {
571                         struct tty_struct *tty = tty_port_tty_get(&line->port);
572                         if (tty != NULL) {
573                                 tty_hangup(tty);
574                                 tty_kref_put(tty);
575                         }
576                         if (line->chan_out != chan)
577                                 close_one_chan(line->chan_out, 1);
578                 }
579                 close_one_chan(chan, 1);
580                 if (chan->primary)
581                         return;
582         }
583  out:
584         tty_flip_buffer_push(port);
585 }
586 

~ [ 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