]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/tty/tty_jobctrl.c
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 1991, 1992 Linus Torvalds
6 #include <linux/types.h>
7 #include <linux/errno.h>
8 #include <linux/signal.h>
9 #include <linux/sched/signal.h>
10 #include <linux/sched/task.h>
11 #include <linux/tty.h>
12 #include <linux/fcntl.h>
13 #include <linux/uaccess.h>
16 static int is_ignored(int sig
)
18 return (sigismember(¤t
->blocked
, sig
) ||
19 current
->sighand
->action
[sig
-1].sa
.sa_handler
== SIG_IGN
);
23 * tty_check_change - check for POSIX terminal changes
25 * @sig: signal to send
27 * If we try to write to, or set the state of, a terminal and we're
28 * not in the foreground, send a SIGTTOU. If the signal is blocked or
29 * ignored, go ahead and perform the operation. (POSIX 7.2)
33 int __tty_check_change(struct tty_struct
*tty
, int sig
)
36 struct pid
*pgrp
, *tty_pgrp
;
39 if (current
->signal
->tty
!= tty
)
43 pgrp
= task_pgrp(current
);
45 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
47 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
49 if (tty_pgrp
&& pgrp
!= tty_pgrp
) {
50 if (is_ignored(sig
)) {
53 } else if (is_current_pgrp_orphaned())
56 kill_pgrp(pgrp
, sig
, 1);
57 set_thread_flag(TIF_SIGPENDING
);
64 tty_warn(tty
, "sig=%d, tty->pgrp == NULL!\n", sig
);
69 int tty_check_change(struct tty_struct
*tty
)
71 return __tty_check_change(tty
, SIGTTOU
);
73 EXPORT_SYMBOL(tty_check_change
);
75 void proc_clear_tty(struct task_struct
*p
)
78 struct tty_struct
*tty
;
80 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
82 p
->signal
->tty
= NULL
;
83 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
88 * proc_set_tty - set the controlling terminal
91 * Only callable by the session leader and only if it does not already have
92 * a controlling terminal.
94 * Caller must hold: tty_lock()
95 * a readlock on tasklist_lock
98 static void __proc_set_tty(struct tty_struct
*tty
)
102 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
104 * The session and fg pgrp references will be non-NULL if
105 * tiocsctty() is stealing the controlling tty
107 put_pid(tty
->session
);
109 tty
->pgrp
= get_pid(task_pgrp(current
));
110 tty
->session
= get_pid(task_session(current
));
111 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
112 if (current
->signal
->tty
) {
113 tty_debug(tty
, "current tty %s not NULL!!\n",
114 current
->signal
->tty
->name
);
115 tty_kref_put(current
->signal
->tty
);
117 put_pid(current
->signal
->tty_old_pgrp
);
118 current
->signal
->tty
= tty_kref_get(tty
);
119 current
->signal
->tty_old_pgrp
= NULL
;
122 static void proc_set_tty(struct tty_struct
*tty
)
124 spin_lock_irq(¤t
->sighand
->siglock
);
126 spin_unlock_irq(¤t
->sighand
->siglock
);
130 * Called by tty_open() to set the controlling tty if applicable.
132 void tty_open_proc_set_tty(struct file
*filp
, struct tty_struct
*tty
)
134 read_lock(&tasklist_lock
);
135 spin_lock_irq(¤t
->sighand
->siglock
);
136 if (current
->signal
->leader
&&
137 !current
->signal
->tty
&&
138 tty
->session
== NULL
) {
140 * Don't let a process that only has write access to the tty
141 * obtain the privileges associated with having a tty as
142 * controlling terminal (being able to reopen it with full
143 * access through /dev/tty, being able to perform pushback).
144 * Many distributions set the group of all ttys to "tty" and
145 * grant write-only access to all terminals for setgid tty
146 * binaries, which should not imply full privileges on all ttys.
148 * This could theoretically break old code that performs open()
149 * on a write-only file descriptor. In that case, it might be
150 * necessary to also permit this if
151 * inode_permission(inode, MAY_READ) == 0.
153 if (filp
->f_mode
& FMODE_READ
)
156 spin_unlock_irq(¤t
->sighand
->siglock
);
157 read_unlock(&tasklist_lock
);
160 struct tty_struct
*get_current_tty(void)
162 struct tty_struct
*tty
;
165 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
166 tty
= tty_kref_get(current
->signal
->tty
);
167 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
170 EXPORT_SYMBOL_GPL(get_current_tty
);
173 * Called from tty_release().
175 void session_clear_tty(struct pid
*session
)
177 struct task_struct
*p
;
179 do_each_pid_task(session
, PIDTYPE_SID
, p
) {
181 } while_each_pid_task(session
, PIDTYPE_SID
, p
);
185 * tty_signal_session_leader - sends SIGHUP to session leader
186 * @tty: controlling tty
187 * @exit_session: if non-zero, signal all foreground group processes
189 * Send SIGHUP and SIGCONT to the session leader and its process group.
190 * Optionally, signal all processes in the foreground process group.
192 * Returns the number of processes in the session with this tty
193 * as their controlling terminal. This value is used to drop
194 * tty references for those processes.
196 int tty_signal_session_leader(struct tty_struct
*tty
, int exit_session
)
198 struct task_struct
*p
;
200 struct pid
*tty_pgrp
= NULL
;
202 read_lock(&tasklist_lock
);
204 do_each_pid_task(tty
->session
, PIDTYPE_SID
, p
) {
205 spin_lock_irq(&p
->sighand
->siglock
);
206 if (p
->signal
->tty
== tty
) {
207 p
->signal
->tty
= NULL
;
209 * We defer the dereferences outside of
214 if (!p
->signal
->leader
) {
215 spin_unlock_irq(&p
->sighand
->siglock
);
218 __group_send_sig_info(SIGHUP
, SEND_SIG_PRIV
, p
);
219 __group_send_sig_info(SIGCONT
, SEND_SIG_PRIV
, p
);
220 put_pid(p
->signal
->tty_old_pgrp
); /* A noop */
221 spin_lock(&tty
->ctrl_lock
);
222 tty_pgrp
= get_pid(tty
->pgrp
);
224 p
->signal
->tty_old_pgrp
= get_pid(tty
->pgrp
);
225 spin_unlock(&tty
->ctrl_lock
);
226 spin_unlock_irq(&p
->sighand
->siglock
);
227 } while_each_pid_task(tty
->session
, PIDTYPE_SID
, p
);
229 read_unlock(&tasklist_lock
);
233 kill_pgrp(tty_pgrp
, SIGHUP
, exit_session
);
241 * disassociate_ctty - disconnect controlling tty
242 * @on_exit: true if exiting so need to "hang up" the session
244 * This function is typically called only by the session leader, when
245 * it wants to disassociate itself from its controlling tty.
247 * It performs the following functions:
248 * (1) Sends a SIGHUP and SIGCONT to the foreground process group
249 * (2) Clears the tty from being controlling the session
250 * (3) Clears the controlling tty for all processes in the
253 * The argument on_exit is set to 1 if called when a process is
254 * exiting; it is 0 if called by the ioctl TIOCNOTTY.
257 * BTM is taken for hysterical raisons, and held when
258 * called from no_tty().
259 * tty_mutex is taken to protect tty
260 * ->siglock is taken to protect ->signal/->sighand
261 * tasklist_lock is taken to walk process list for sessions
262 * ->siglock is taken to protect ->signal/->sighand
264 void disassociate_ctty(int on_exit
)
266 struct tty_struct
*tty
;
268 if (!current
->signal
->leader
)
271 tty
= get_current_tty();
273 if (on_exit
&& tty
->driver
->type
!= TTY_DRIVER_TYPE_PTY
) {
274 tty_vhangup_session(tty
);
276 struct pid
*tty_pgrp
= tty_get_pgrp(tty
);
279 kill_pgrp(tty_pgrp
, SIGHUP
, on_exit
);
281 kill_pgrp(tty_pgrp
, SIGCONT
, on_exit
);
287 } else if (on_exit
) {
288 struct pid
*old_pgrp
;
290 spin_lock_irq(¤t
->sighand
->siglock
);
291 old_pgrp
= current
->signal
->tty_old_pgrp
;
292 current
->signal
->tty_old_pgrp
= NULL
;
293 spin_unlock_irq(¤t
->sighand
->siglock
);
295 kill_pgrp(old_pgrp
, SIGHUP
, on_exit
);
296 kill_pgrp(old_pgrp
, SIGCONT
, on_exit
);
302 spin_lock_irq(¤t
->sighand
->siglock
);
303 put_pid(current
->signal
->tty_old_pgrp
);
304 current
->signal
->tty_old_pgrp
= NULL
;
305 tty
= tty_kref_get(current
->signal
->tty
);
306 spin_unlock_irq(¤t
->sighand
->siglock
);
312 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
313 put_pid(tty
->session
);
317 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
322 /* Now clear signal->tty under the lock */
323 read_lock(&tasklist_lock
);
324 session_clear_tty(task_session(current
));
325 read_unlock(&tasklist_lock
);
330 * no_tty - Ensure the current process does not have a controlling tty
335 * FIXME: Review locking here. The tty_lock never covered any race
336 * between a new association and proc_clear_tty but possibly we need
337 * to protect against this anyway.
339 struct task_struct
*tsk
= current
;
341 disassociate_ctty(0);
346 * tiocsctty - set controlling tty
347 * @tty: tty structure
348 * @file: file structure used to check permissions
349 * @arg: user argument
351 * This ioctl is used to manage job control. It permits a session
352 * leader to set this tty as the controlling tty for the session.
355 * Takes tty_lock() to serialize proc_set_tty() for this tty
356 * Takes tasklist_lock internally to walk sessions
357 * Takes ->siglock() when updating signal->tty
359 static int tiocsctty(struct tty_struct
*tty
, struct file
*file
, int arg
)
364 read_lock(&tasklist_lock
);
366 if (current
->signal
->leader
&& (task_session(current
) == tty
->session
))
370 * The process must be a session leader and
371 * not have a controlling tty already.
373 if (!current
->signal
->leader
|| current
->signal
->tty
) {
380 * This tty is already the controlling
381 * tty for another session group!
383 if (arg
== 1 && capable(CAP_SYS_ADMIN
)) {
387 session_clear_tty(tty
->session
);
394 /* See the comment in tty_open_proc_set_tty(). */
395 if ((file
->f_mode
& FMODE_READ
) == 0 && !capable(CAP_SYS_ADMIN
)) {
402 read_unlock(&tasklist_lock
);
408 * tty_get_pgrp - return a ref counted pgrp pid
411 * Returns a refcounted instance of the pid struct for the process
412 * group controlling the tty.
414 struct pid
*tty_get_pgrp(struct tty_struct
*tty
)
419 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
420 pgrp
= get_pid(tty
->pgrp
);
421 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
425 EXPORT_SYMBOL_GPL(tty_get_pgrp
);
428 * This checks not only the pgrp, but falls back on the pid if no
429 * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
432 * The caller must hold rcu lock or the tasklist lock.
434 static struct pid
*session_of_pgrp(struct pid
*pgrp
)
436 struct task_struct
*p
;
437 struct pid
*sid
= NULL
;
439 p
= pid_task(pgrp
, PIDTYPE_PGID
);
441 p
= pid_task(pgrp
, PIDTYPE_PID
);
443 sid
= task_session(p
);
449 * tiocgpgrp - get process group
450 * @tty: tty passed by user
451 * @real_tty: tty side of the tty passed by the user if a pty else the tty
454 * Obtain the process group of the tty. If there is no process group
457 * Locking: none. Reference to current->signal->tty is safe.
459 static int tiocgpgrp(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
464 * (tty == real_tty) is a cheap way of
465 * testing if the tty is NOT a master pty.
467 if (tty
== real_tty
&& current
->signal
->tty
!= real_tty
)
469 pid
= tty_get_pgrp(real_tty
);
470 ret
= put_user(pid_vnr(pid
), p
);
476 * tiocspgrp - attempt to set process group
477 * @tty: tty passed by user
478 * @real_tty: tty side device matching tty passed by user
481 * Set the process group of the tty to the session passed. Only
482 * permitted where the tty session is our session.
484 * Locking: RCU, ctrl lock
486 static int tiocspgrp(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
490 int retval
= tty_check_change(real_tty
);
497 if (get_user(pgrp_nr
, p
))
502 spin_lock_irq(&real_tty
->ctrl_lock
);
503 if (!current
->signal
->tty
||
504 (current
->signal
->tty
!= real_tty
) ||
505 (real_tty
->session
!= task_session(current
))) {
507 goto out_unlock_ctrl
;
510 pgrp
= find_vpid(pgrp_nr
);
515 if (session_of_pgrp(pgrp
) != task_session(current
))
518 put_pid(real_tty
->pgrp
);
519 real_tty
->pgrp
= get_pid(pgrp
);
523 spin_unlock_irq(&real_tty
->ctrl_lock
);
528 * tiocgsid - get session id
529 * @tty: tty passed by user
530 * @real_tty: tty side of the tty passed by the user if a pty else the tty
531 * @p: pointer to returned session id
533 * Obtain the session id of the tty. If there is no session
536 static int tiocgsid(struct tty_struct
*tty
, struct tty_struct
*real_tty
, pid_t __user
*p
)
542 * (tty == real_tty) is a cheap way of
543 * testing if the tty is NOT a master pty.
545 if (tty
== real_tty
&& current
->signal
->tty
!= real_tty
)
548 spin_lock_irqsave(&real_tty
->ctrl_lock
, flags
);
549 if (!real_tty
->session
)
551 sid
= pid_vnr(real_tty
->session
);
552 spin_unlock_irqrestore(&real_tty
->ctrl_lock
, flags
);
554 return put_user(sid
, p
);
557 spin_unlock_irqrestore(&real_tty
->ctrl_lock
, flags
);
562 * Called from tty_ioctl(). If tty is a pty then real_tty is the slave side,
563 * if not then tty == real_tty.
565 long tty_jobctrl_ioctl(struct tty_struct
*tty
, struct tty_struct
*real_tty
,
566 struct file
*file
, unsigned int cmd
, unsigned long arg
)
568 void __user
*p
= (void __user
*)arg
;
572 if (current
->signal
->tty
!= tty
)
577 return tiocsctty(real_tty
, file
, arg
);
579 return tiocgpgrp(tty
, real_tty
, p
);
581 return tiocspgrp(tty
, real_tty
, p
);
583 return tiocgsid(tty
, real_tty
, p
);