ia64/linux-2.6.18-xen.hg

view drivers/char/tty_ioctl.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
1 /*
2 * linux/drivers/char/tty_ioctl.c
3 *
4 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
5 *
6 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
7 * which can be dynamically activated and de-activated by the line
8 * discipline handling modules (like SLIP).
9 */
11 #include <linux/types.h>
12 #include <linux/termios.h>
13 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/kernel.h>
16 #include <linux/major.h>
17 #include <linux/tty.h>
18 #include <linux/fcntl.h>
19 #include <linux/string.h>
20 #include <linux/mm.h>
21 #include <linux/module.h>
22 #include <linux/bitops.h>
24 #include <asm/io.h>
25 #include <asm/uaccess.h>
26 #include <asm/system.h>
28 #undef TTY_DEBUG_WAIT_UNTIL_SENT
30 #undef DEBUG
32 /*
33 * Internal flag options for termios setting behavior
34 */
35 #define TERMIOS_FLUSH 1
36 #define TERMIOS_WAIT 2
37 #define TERMIOS_TERMIO 4
40 /**
41 * tty_wait_until_sent - wait for I/O to finish
42 * @tty: tty we are waiting for
43 * @timeout: how long we will wait
44 *
45 * Wait for characters pending in a tty driver to hit the wire, or
46 * for a timeout to occur (eg due to flow control)
47 *
48 * Locking: none
49 */
51 void tty_wait_until_sent(struct tty_struct * tty, long timeout)
52 {
53 DECLARE_WAITQUEUE(wait, current);
55 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
56 char buf[64];
58 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
59 #endif
60 if (!tty->driver->chars_in_buffer)
61 return;
62 add_wait_queue(&tty->write_wait, &wait);
63 if (!timeout)
64 timeout = MAX_SCHEDULE_TIMEOUT;
65 do {
66 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
67 printk(KERN_DEBUG "waiting %s...(%d)\n", tty_name(tty, buf),
68 tty->driver->chars_in_buffer(tty));
69 #endif
70 set_current_state(TASK_INTERRUPTIBLE);
71 if (signal_pending(current))
72 goto stop_waiting;
73 if (!tty->driver->chars_in_buffer(tty))
74 break;
75 timeout = schedule_timeout(timeout);
76 } while (timeout);
77 if (tty->driver->wait_until_sent)
78 tty->driver->wait_until_sent(tty, timeout);
79 stop_waiting:
80 set_current_state(TASK_RUNNING);
81 remove_wait_queue(&tty->write_wait, &wait);
82 }
84 EXPORT_SYMBOL(tty_wait_until_sent);
86 static void unset_locked_termios(struct termios *termios,
87 struct termios *old,
88 struct termios *locked)
89 {
90 int i;
92 #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
94 if (!locked) {
95 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
96 return;
97 }
99 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
100 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
101 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
102 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
103 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
104 for (i=0; i < NCCS; i++)
105 termios->c_cc[i] = locked->c_cc[i] ?
106 old->c_cc[i] : termios->c_cc[i];
107 }
109 /**
110 * change_termios - update termios values
111 * @tty: tty to update
112 * @new_termios: desired new value
113 *
114 * Perform updates to the termios values set on this terminal. There
115 * is a bit of layering violation here with n_tty in terms of the
116 * internal knowledge of this function.
117 *
118 * Locking: termios_sem
119 */
121 static void change_termios(struct tty_struct * tty, struct termios * new_termios)
122 {
123 int canon_change;
124 struct termios old_termios = *tty->termios;
125 struct tty_ldisc *ld;
127 /*
128 * Perform the actual termios internal changes under lock.
129 */
132 /* FIXME: we need to decide on some locking/ordering semantics
133 for the set_termios notification eventually */
134 down(&tty->termios_sem);
136 *tty->termios = *new_termios;
137 unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
138 canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
139 if (canon_change) {
140 memset(&tty->read_flags, 0, sizeof tty->read_flags);
141 tty->canon_head = tty->read_tail;
142 tty->canon_data = 0;
143 tty->erasing = 0;
144 }
147 if (canon_change && !L_ICANON(tty) && tty->read_cnt)
148 /* Get characters left over from canonical mode. */
149 wake_up_interruptible(&tty->read_wait);
151 /* See if packet mode change of state. */
153 if (tty->link && tty->link->packet) {
154 int old_flow = ((old_termios.c_iflag & IXON) &&
155 (old_termios.c_cc[VSTOP] == '\023') &&
156 (old_termios.c_cc[VSTART] == '\021'));
157 int new_flow = (I_IXON(tty) &&
158 STOP_CHAR(tty) == '\023' &&
159 START_CHAR(tty) == '\021');
160 if (old_flow != new_flow) {
161 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
162 if (new_flow)
163 tty->ctrl_status |= TIOCPKT_DOSTOP;
164 else
165 tty->ctrl_status |= TIOCPKT_NOSTOP;
166 wake_up_interruptible(&tty->link->read_wait);
167 }
168 }
170 if (tty->driver->set_termios)
171 (*tty->driver->set_termios)(tty, &old_termios);
173 ld = tty_ldisc_ref(tty);
174 if (ld != NULL) {
175 if (ld->set_termios)
176 (ld->set_termios)(tty, &old_termios);
177 tty_ldisc_deref(ld);
178 }
179 up(&tty->termios_sem);
180 }
182 /**
183 * set_termios - set termios values for a tty
184 * @tty: terminal device
185 * @arg: user data
186 * @opt: option information
187 *
188 * Helper function to prepare termios data and run neccessary other
189 * functions before using change_termios to do the actual changes.
190 *
191 * Locking:
192 * Called functions take ldisc and termios_sem locks
193 */
195 static int set_termios(struct tty_struct * tty, void __user *arg, int opt)
196 {
197 struct termios tmp_termios;
198 struct tty_ldisc *ld;
199 int retval = tty_check_change(tty);
201 if (retval)
202 return retval;
204 if (opt & TERMIOS_TERMIO) {
205 memcpy(&tmp_termios, tty->termios, sizeof(struct termios));
206 if (user_termio_to_kernel_termios(&tmp_termios,
207 (struct termio __user *)arg))
208 return -EFAULT;
209 } else {
210 if (user_termios_to_kernel_termios(&tmp_termios,
211 (struct termios __user *)arg))
212 return -EFAULT;
213 }
215 ld = tty_ldisc_ref(tty);
217 if (ld != NULL) {
218 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
219 ld->flush_buffer(tty);
220 tty_ldisc_deref(ld);
221 }
223 if (opt & TERMIOS_WAIT) {
224 tty_wait_until_sent(tty, 0);
225 if (signal_pending(current))
226 return -EINTR;
227 }
229 change_termios(tty, &tmp_termios);
230 return 0;
231 }
233 static int get_termio(struct tty_struct * tty, struct termio __user * termio)
234 {
235 if (kernel_termios_to_user_termio(termio, tty->termios))
236 return -EFAULT;
237 return 0;
238 }
240 static unsigned long inq_canon(struct tty_struct * tty)
241 {
242 int nr, head, tail;
244 if (!tty->canon_data || !tty->read_buf)
245 return 0;
246 head = tty->canon_head;
247 tail = tty->read_tail;
248 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
249 /* Skip EOF-chars.. */
250 while (head != tail) {
251 if (test_bit(tail, tty->read_flags) &&
252 tty->read_buf[tail] == __DISABLED_CHAR)
253 nr--;
254 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
255 }
256 return nr;
257 }
259 #ifdef TIOCGETP
260 /*
261 * These are deprecated, but there is limited support..
262 *
263 * The "sg_flags" translation is a joke..
264 */
265 static int get_sgflags(struct tty_struct * tty)
266 {
267 int flags = 0;
269 if (!(tty->termios->c_lflag & ICANON)) {
270 if (tty->termios->c_lflag & ISIG)
271 flags |= 0x02; /* cbreak */
272 else
273 flags |= 0x20; /* raw */
274 }
275 if (tty->termios->c_lflag & ECHO)
276 flags |= 0x08; /* echo */
277 if (tty->termios->c_oflag & OPOST)
278 if (tty->termios->c_oflag & ONLCR)
279 flags |= 0x10; /* crmod */
280 return flags;
281 }
283 static int get_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
284 {
285 struct sgttyb tmp;
287 down(&tty->termios_sem);
288 tmp.sg_ispeed = 0;
289 tmp.sg_ospeed = 0;
290 tmp.sg_erase = tty->termios->c_cc[VERASE];
291 tmp.sg_kill = tty->termios->c_cc[VKILL];
292 tmp.sg_flags = get_sgflags(tty);
293 up(&tty->termios_sem);
295 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
296 }
298 static void set_sgflags(struct termios * termios, int flags)
299 {
300 termios->c_iflag = ICRNL | IXON;
301 termios->c_oflag = 0;
302 termios->c_lflag = ISIG | ICANON;
303 if (flags & 0x02) { /* cbreak */
304 termios->c_iflag = 0;
305 termios->c_lflag &= ~ICANON;
306 }
307 if (flags & 0x08) { /* echo */
308 termios->c_lflag |= ECHO | ECHOE | ECHOK |
309 ECHOCTL | ECHOKE | IEXTEN;
310 }
311 if (flags & 0x10) { /* crmod */
312 termios->c_oflag |= OPOST | ONLCR;
313 }
314 if (flags & 0x20) { /* raw */
315 termios->c_iflag = 0;
316 termios->c_lflag &= ~(ISIG | ICANON);
317 }
318 if (!(termios->c_lflag & ICANON)) {
319 termios->c_cc[VMIN] = 1;
320 termios->c_cc[VTIME] = 0;
321 }
322 }
324 /**
325 * set_sgttyb - set legacy terminal values
326 * @tty: tty structure
327 * @sgttyb: pointer to old style terminal structure
328 *
329 * Updates a terminal from the legacy BSD style terminal information
330 * structure.
331 *
332 * Locking: termios_sem
333 */
335 static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
336 {
337 int retval;
338 struct sgttyb tmp;
339 struct termios termios;
341 retval = tty_check_change(tty);
342 if (retval)
343 return retval;
345 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
346 return -EFAULT;
348 down(&tty->termios_sem);
349 termios = *tty->termios;
350 termios.c_cc[VERASE] = tmp.sg_erase;
351 termios.c_cc[VKILL] = tmp.sg_kill;
352 set_sgflags(&termios, tmp.sg_flags);
353 up(&tty->termios_sem);
354 change_termios(tty, &termios);
355 return 0;
356 }
357 #endif
359 #ifdef TIOCGETC
360 static int get_tchars(struct tty_struct * tty, struct tchars __user * tchars)
361 {
362 struct tchars tmp;
364 tmp.t_intrc = tty->termios->c_cc[VINTR];
365 tmp.t_quitc = tty->termios->c_cc[VQUIT];
366 tmp.t_startc = tty->termios->c_cc[VSTART];
367 tmp.t_stopc = tty->termios->c_cc[VSTOP];
368 tmp.t_eofc = tty->termios->c_cc[VEOF];
369 tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
370 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
371 }
373 static int set_tchars(struct tty_struct * tty, struct tchars __user * tchars)
374 {
375 struct tchars tmp;
377 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
378 return -EFAULT;
379 tty->termios->c_cc[VINTR] = tmp.t_intrc;
380 tty->termios->c_cc[VQUIT] = tmp.t_quitc;
381 tty->termios->c_cc[VSTART] = tmp.t_startc;
382 tty->termios->c_cc[VSTOP] = tmp.t_stopc;
383 tty->termios->c_cc[VEOF] = tmp.t_eofc;
384 tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
385 return 0;
386 }
387 #endif
389 #ifdef TIOCGLTC
390 static int get_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
391 {
392 struct ltchars tmp;
394 tmp.t_suspc = tty->termios->c_cc[VSUSP];
395 tmp.t_dsuspc = tty->termios->c_cc[VSUSP]; /* what is dsuspc anyway? */
396 tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
397 tmp.t_flushc = tty->termios->c_cc[VEOL2]; /* what is flushc anyway? */
398 tmp.t_werasc = tty->termios->c_cc[VWERASE];
399 tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
400 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
401 }
403 static int set_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
404 {
405 struct ltchars tmp;
407 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
408 return -EFAULT;
410 tty->termios->c_cc[VSUSP] = tmp.t_suspc;
411 tty->termios->c_cc[VEOL2] = tmp.t_dsuspc; /* what is dsuspc anyway? */
412 tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
413 tty->termios->c_cc[VEOL2] = tmp.t_flushc; /* what is flushc anyway? */
414 tty->termios->c_cc[VWERASE] = tmp.t_werasc;
415 tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
416 return 0;
417 }
418 #endif
420 /**
421 * send_prio_char - send priority character
422 *
423 * Send a high priority character to the tty even if stopped
424 *
425 * Locking: none
426 *
427 * FIXME: overlapping calls with start/stop tty lose state of tty
428 */
430 static void send_prio_char(struct tty_struct *tty, char ch)
431 {
432 int was_stopped = tty->stopped;
434 if (tty->driver->send_xchar) {
435 tty->driver->send_xchar(tty, ch);
436 return;
437 }
438 if (was_stopped)
439 start_tty(tty);
440 tty->driver->write(tty, &ch, 1);
441 if (was_stopped)
442 stop_tty(tty);
443 }
445 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
446 unsigned int cmd, unsigned long arg)
447 {
448 struct tty_struct * real_tty;
449 void __user *p = (void __user *)arg;
450 int retval;
451 struct tty_ldisc *ld;
453 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
454 tty->driver->subtype == PTY_TYPE_MASTER)
455 real_tty = tty->link;
456 else
457 real_tty = tty;
459 switch (cmd) {
460 #ifdef TIOCGETP
461 case TIOCGETP:
462 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
463 case TIOCSETP:
464 case TIOCSETN:
465 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
466 #endif
467 #ifdef TIOCGETC
468 case TIOCGETC:
469 return get_tchars(real_tty, p);
470 case TIOCSETC:
471 return set_tchars(real_tty, p);
472 #endif
473 #ifdef TIOCGLTC
474 case TIOCGLTC:
475 return get_ltchars(real_tty, p);
476 case TIOCSLTC:
477 return set_ltchars(real_tty, p);
478 #endif
479 case TCGETS:
480 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
481 return -EFAULT;
482 return 0;
483 case TCSETSF:
484 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
485 case TCSETSW:
486 return set_termios(real_tty, p, TERMIOS_WAIT);
487 case TCSETS:
488 return set_termios(real_tty, p, 0);
489 case TCGETA:
490 return get_termio(real_tty, p);
491 case TCSETAF:
492 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
493 case TCSETAW:
494 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
495 case TCSETA:
496 return set_termios(real_tty, p, TERMIOS_TERMIO);
497 case TCXONC:
498 retval = tty_check_change(tty);
499 if (retval)
500 return retval;
501 switch (arg) {
502 case TCOOFF:
503 if (!tty->flow_stopped) {
504 tty->flow_stopped = 1;
505 stop_tty(tty);
506 }
507 break;
508 case TCOON:
509 if (tty->flow_stopped) {
510 tty->flow_stopped = 0;
511 start_tty(tty);
512 }
513 break;
514 case TCIOFF:
515 if (STOP_CHAR(tty) != __DISABLED_CHAR)
516 send_prio_char(tty, STOP_CHAR(tty));
517 break;
518 case TCION:
519 if (START_CHAR(tty) != __DISABLED_CHAR)
520 send_prio_char(tty, START_CHAR(tty));
521 break;
522 default:
523 return -EINVAL;
524 }
525 return 0;
526 case TCFLSH:
527 retval = tty_check_change(tty);
528 if (retval)
529 return retval;
531 ld = tty_ldisc_ref(tty);
532 switch (arg) {
533 case TCIFLUSH:
534 if (ld && ld->flush_buffer)
535 ld->flush_buffer(tty);
536 break;
537 case TCIOFLUSH:
538 if (ld && ld->flush_buffer)
539 ld->flush_buffer(tty);
540 /* fall through */
541 case TCOFLUSH:
542 if (tty->driver->flush_buffer)
543 tty->driver->flush_buffer(tty);
544 break;
545 default:
546 tty_ldisc_deref(ld);
547 return -EINVAL;
548 }
549 tty_ldisc_deref(ld);
550 return 0;
551 case TIOCOUTQ:
552 return put_user(tty->driver->chars_in_buffer ?
553 tty->driver->chars_in_buffer(tty) : 0,
554 (int __user *) arg);
555 case TIOCINQ:
556 retval = tty->read_cnt;
557 if (L_ICANON(tty))
558 retval = inq_canon(tty);
559 return put_user(retval, (unsigned int __user *) arg);
560 case TIOCGLCKTRMIOS:
561 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
562 return -EFAULT;
563 return 0;
565 case TIOCSLCKTRMIOS:
566 if (!capable(CAP_SYS_ADMIN))
567 return -EPERM;
568 if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios __user *) arg))
569 return -EFAULT;
570 return 0;
572 case TIOCPKT:
573 {
574 int pktmode;
576 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
577 tty->driver->subtype != PTY_TYPE_MASTER)
578 return -ENOTTY;
579 if (get_user(pktmode, (int __user *) arg))
580 return -EFAULT;
581 if (pktmode) {
582 if (!tty->packet) {
583 tty->packet = 1;
584 tty->link->ctrl_status = 0;
585 }
586 } else
587 tty->packet = 0;
588 return 0;
589 }
590 case TIOCGSOFTCAR:
591 return put_user(C_CLOCAL(tty) ? 1 : 0, (int __user *)arg);
592 case TIOCSSOFTCAR:
593 if (get_user(arg, (unsigned int __user *) arg))
594 return -EFAULT;
595 down(&tty->termios_sem);
596 tty->termios->c_cflag =
597 ((tty->termios->c_cflag & ~CLOCAL) |
598 (arg ? CLOCAL : 0));
599 up(&tty->termios_sem);
600 return 0;
601 default:
602 return -ENOIOCTLCMD;
603 }
604 }
606 EXPORT_SYMBOL(n_tty_ioctl);