Skip to content

Instantly share code, notes, and snippets.

@dvyukov

dvyukov/gist:64c0b2dfe64047d90edd

Created November 26, 2015 13:39
Show Gist options
  • Save dvyukov/64c0b2dfe64047d90edd to your computer and use it in GitHub Desktop.
Save dvyukov/64c0b2dfe64047d90edd to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gistfile1.txt
vmlinux: file format elf64-x86-64
Disassembly of section .text:
ffffffff829d99d0 <tty_ioctl>:
/*
* Split this up, as gcc can choke on it otherwise..
*/
long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
ffffffff829d99d0: 55 push %rbp
ffffffff829d99d1: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d99d8: fc ff df
ffffffff829d99db: 48 89 e5 mov %rsp,%rbp
ffffffff829d99de: 41 57 push %r15
ffffffff829d99e0: 41 56 push %r14
ffffffff829d99e2: 41 55 push %r13
ffffffff829d99e4: 41 54 push %r12
ffffffff829d99e6: 49 89 fd mov %rdi,%r13
ffffffff829d99e9: 53 push %rbx
ffffffff829d99ea: 48 81 c7 88 01 00 00 add $0x188,%rdi
ffffffff829d99f1: 41 89 f6 mov %esi,%r14d
ffffffff829d99f4: 48 81 ec c0 01 00 00 sub $0x1c0,%rsp
ffffffff829d99fb: 48 89 95 30 fe ff ff mov %rdx,-0x1d0(%rbp)
ffffffff829d9a02: 48 8d 95 38 fe ff ff lea -0x1c8(%rbp),%rdx
ffffffff829d9a09: 48 c7 85 38 fe ff ff movq $0x41b58ab3,-0x1c8(%rbp)
ffffffff829d9a10: b3 8a b5 41
ffffffff829d9a14: 48 c7 85 40 fe ff ff movq $0xffffffff85f5e300,-0x1c0(%rbp)
ffffffff829d9a1b: 00 e3 f5 85
ffffffff829d9a1f: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9a23: 48 c7 85 48 fe ff ff movq $0xffffffff829d99d0,-0x1b8(%rbp)
ffffffff829d9a2a: d0 99 9d 82
ffffffff829d9a2e: 49 89 d4 mov %rdx,%r12
ffffffff829d9a31: 48 01 c2 add %rax,%rdx
ffffffff829d9a34: c7 02 f1 f1 f1 f1 movl $0xf1f1f1f1,(%rdx)
ffffffff829d9a3a: c7 42 04 01 f4 f4 f4 movl $0xf4f4f401,0x4(%rdx)
ffffffff829d9a41: c7 42 08 f2 f2 f2 f2 movl $0xf2f2f2f2,0x8(%rdx)
ffffffff829d9a48: c7 42 0c 01 f4 f4 f4 movl $0xf4f4f401,0xc(%rdx)
ffffffff829d9a4f: c7 42 10 f2 f2 f2 f2 movl $0xf2f2f2f2,0x10(%rdx)
ffffffff829d9a56: c7 42 14 00 f4 f4 f4 movl $0xf4f4f400,0x14(%rdx)
ffffffff829d9a5d: c7 42 18 f2 f2 f2 f2 movl $0xf2f2f2f2,0x18(%rdx)
ffffffff829d9a64: c7 42 1c 00 00 f4 f4 movl $0xf4f40000,0x1c(%rdx)
ffffffff829d9a6b: c7 42 20 f2 f2 f2 f2 movl $0xf2f2f2f2,0x20(%rdx)
ffffffff829d9a72: c7 42 2c 00 00 f4 f4 movl $0xf4f40000,0x2c(%rdx)
ffffffff829d9a79: c7 42 30 f3 f3 f3 f3 movl $0xf3f3f3f3,0x30(%rdx)
ffffffff829d9a80: 48 89 fa mov %rdi,%rdx
ffffffff829d9a83: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9a87: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9a8b: 0f 85 88 1d 00 00 jne ffffffff829db819 <tty_ioctl+0x1e49>
ffffffff829d9a91: 49 8b 9d 88 01 00 00 mov 0x188(%r13),%rbx
kfree(tty);
}
static inline struct tty_struct *file_tty(struct file *file)
{
return ((struct tty_file_private *)file->private_data)->tty;
ffffffff829d9a98: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9a9f: fc ff df
ffffffff829d9aa2: 48 89 da mov %rbx,%rdx
ffffffff829d9aa5: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9aa9: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9aad: 0f 85 52 1c 00 00 jne ffffffff829db705 <tty_ioctl+0x1d35>
ffffffff829d9ab3: 49 8d 7d 20 lea 0x20(%r13),%rdi
ffffffff829d9ab7: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9abe: fc ff df
ffffffff829d9ac1: 48 8b 1b mov (%rbx),%rbx
ffffffff829d9ac4: 48 89 fa mov %rdi,%rdx
ffffffff829d9ac7: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9acb: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9acf: 0f 85 4e 1d 00 00 jne ffffffff829db823 <tty_ioctl+0x1e53>
struct tty_struct *real_tty;
void __user *p = (void __user *)arg;
int retval;
struct tty_ldisc *ld;
if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
ffffffff829d9ad5: 49 8b 75 20 mov 0x20(%r13),%rsi
ffffffff829d9ad9: 48 c7 c2 60 23 61 85 mov $0xffffffff85612360,%rdx
ffffffff829d9ae0: 48 89 df mov %rbx,%rdi
ffffffff829d9ae3: e8 18 d7 ff ff callq ffffffff829d7200 <tty_paranoia_check>
ffffffff829d9ae8: 85 c0 test %eax,%eax
ffffffff829d9aea: 0f 85 6d 06 00 00 jne ffffffff829da15d <tty_ioctl+0x78d>
* if pty, return the slave side (real_tty)
* otherwise, return self
*/
static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
{
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
ffffffff829d9af0: 48 8d 7b 10 lea 0x10(%rbx),%rdi
ffffffff829d9af4: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9afb: fc ff df
ffffffff829d9afe: 48 89 fa mov %rdi,%rdx
ffffffff829d9b01: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9b05: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9b09: 0f 85 f6 1c 00 00 jne ffffffff829db805 <tty_ioctl+0x1e35>
ffffffff829d9b0f: 4c 8b 7b 10 mov 0x10(%rbx),%r15
ffffffff829d9b13: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9b1a: fc ff df
ffffffff829d9b1d: 49 8d 7f 38 lea 0x38(%r15),%rdi
ffffffff829d9b21: 48 89 fa mov %rdi,%rdx
ffffffff829d9b24: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9b28: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffffffff829d9b2c: 84 c0 test %al,%al
ffffffff829d9b2e: 74 08 je ffffffff829d9b38 <tty_ioctl+0x168>
ffffffff829d9b30: 3c 03 cmp $0x3,%al
ffffffff829d9b32: 0f 8e c7 09 00 00 jle ffffffff829da4ff <tty_ioctl+0xb2f>
ffffffff829d9b38: 41 81 7f 38 04 00 01 cmpl $0x10004,0x38(%r15)
ffffffff829d9b3f: 00
kfree(tty);
}
static inline struct tty_struct *file_tty(struct file *file)
{
return ((struct tty_file_private *)file->private_data)->tty;
ffffffff829d9b40: 49 89 da mov %rbx,%r10
* if pty, return the slave side (real_tty)
* otherwise, return self
*/
static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
{
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
ffffffff829d9b43: 0f 84 10 02 00 00 je ffffffff829d9d59 <tty_ioctl+0x389>
ffffffff829d9b49: 41 8d 8e f7 ab ff ff lea -0x5409(%r14),%ecx
ffffffff829d9b50: 83 f9 1f cmp $0x1f,%ecx
ffffffff829d9b53: 0f 87 f3 00 00 00 ja ffffffff829d9c4c <tty_ioctl+0x27c>
ffffffff829d9b59: b8 01 00 00 00 mov $0x1,%eax
ffffffff829d9b5e: 48 d3 e0 shl %cl,%rax
ffffffff829d9b61: a9 01 00 00 d4 test $0xd4000001,%eax
ffffffff829d9b66: 0f 84 e0 00 00 00 je ffffffff829d9c4c <tty_ioctl+0x27c>
DECLARE_PER_CPU(struct task_struct *, current_task);
static __always_inline struct task_struct *get_current(void)
{
return this_cpu_read_stable(current_task);
ffffffff829d9b6c: 65 4c 8b 3c 25 c0 3f mov %gs:0x13fc0,%r15
ffffffff829d9b73: 01 00
{
unsigned long flags;
struct pid *pgrp, *tty_pgrp;
int ret = 0;
if (current->signal->tty != tty)
ffffffff829d9b75: 49 8d bf 48 06 00 00 lea 0x648(%r15),%rdi
ffffffff829d9b7c: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9b83: fc ff df
ffffffff829d9b86: 48 89 fa mov %rdi,%rdx
ffffffff829d9b89: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9b8d: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9b91: 0f 85 1e 1d 00 00 jne ffffffff829db8b5 <tty_ioctl+0x1ee5>
ffffffff829d9b97: 4d 8b bf 48 06 00 00 mov 0x648(%r15),%r15
ffffffff829d9b9e: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9ba5: fc ff df
ffffffff829d9ba8: 49 8d bf d0 01 00 00 lea 0x1d0(%r15),%rdi
ffffffff829d9baf: 48 89 fa mov %rdi,%rdx
ffffffff829d9bb2: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9bb6: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9bba: 0f 85 0d 1d 00 00 jne ffffffff829db8cd <tty_ioctl+0x1efd>
ffffffff829d9bc0: 49 3b 9f d0 01 00 00 cmp 0x1d0(%r15),%rbx
ffffffff829d9bc7: 0f 84 e3 14 00 00 je ffffffff829db0b0 <tty_ioctl+0x16e0>
case TCSBRK:
case TCSBRKP:
retval = tty_check_change(tty);
if (retval)
return retval;
if (cmd != TIOCCBRK) {
ffffffff829d9bcd: 41 81 fe 28 54 00 00 cmp $0x5428,%r14d
ffffffff829d9bd4: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829d9bdb: 0f 84 88 05 00 00 je ffffffff829da169 <tty_ioctl+0x799>
tty_wait_until_sent(tty, 0);
ffffffff829d9be1: 31 f6 xor %esi,%esi
ffffffff829d9be3: 48 89 df mov %rbx,%rdi
ffffffff829d9be6: e8 45 4f 01 00 callq ffffffff829eeb30 <tty_wait_until_sent>
ffffffff829d9beb: 65 4c 8b 3c 25 c0 3f mov %gs:0x13fc0,%r15
ffffffff829d9bf2: 01 00
return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
}
static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
{
return test_ti_thread_flag(task_thread_info(tsk), flag);
ffffffff829d9bf4: 49 8d 7f 08 lea 0x8(%r15),%rdi
ffffffff829d9bf8: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9bff: fc ff df
ffffffff829d9c02: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829d9c09: 48 89 fa mov %rdi,%rdx
ffffffff829d9c0c: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9c10: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9c14: 0f 85 10 1b 00 00 jne ffffffff829db72a <tty_ioctl+0x1d5a>
ffffffff829d9c1a: 4d 8b 7f 08 mov 0x8(%r15),%r15
}
static __always_inline int constant_test_bit(long nr, const volatile unsigned long *addr)
{
return ((1UL << (nr & (BITS_PER_LONG-1))) &
(addr[nr >> _BITOPS_LONG_SHIFT])) != 0;
ffffffff829d9c1e: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9c25: fc ff df
ffffffff829d9c28: 49 8d 7f 08 lea 0x8(%r15),%rdi
ffffffff829d9c2c: 48 89 fa mov %rdi,%rdx
ffffffff829d9c2f: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9c33: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9c37: 0f 85 d5 1a 00 00 jne ffffffff829db712 <tty_ioctl+0x1d42>
ffffffff829d9c3d: 49 8b 47 08 mov 0x8(%r15),%rax
if (signal_pending(current))
return -EINTR;
ffffffff829d9c41: 49 c7 c7 fc ff ff ff mov $0xfffffffffffffffc,%r15
retval = tty_check_change(tty);
if (retval)
return retval;
if (cmd != TIOCCBRK) {
tty_wait_until_sent(tty, 0);
if (signal_pending(current))
ffffffff829d9c48: a8 04 test $0x4,%al
ffffffff829d9c4a: 75 78 jne ffffffff829d9cc4 <tty_ioctl+0x2f4>
}
/*
* Now do the stuff.
*/
switch (cmd) {
ffffffff829d9c4c: 41 81 fe 1d 54 00 00 cmp $0x541d,%r14d
ffffffff829d9c53: 0f 84 f9 0a 00 00 je ffffffff829da752 <tty_ioctl+0xd82>
ffffffff829d9c59: 0f 86 b5 00 00 00 jbe ffffffff829d9d14 <tty_ioctl+0x344>
ffffffff829d9c5f: 41 81 fe 27 54 00 00 cmp $0x5427,%r14d
ffffffff829d9c66: 0f 84 8b 0b 00 00 je ffffffff829da7f7 <tty_ioctl+0xe27>
ffffffff829d9c6c: 0f 87 a8 01 00 00 ja ffffffff829d9e1a <tty_ioctl+0x44a>
ffffffff829d9c72: 41 81 fe 22 54 00 00 cmp $0x5422,%r14d
ffffffff829d9c79: 0f 84 bc 13 00 00 je ffffffff829db03b <tty_ioctl+0x166b>
ffffffff829d9c7f: 0f 86 3d 04 00 00 jbe ffffffff829da0c2 <tty_ioctl+0x6f2>
ffffffff829d9c85: 41 81 fe 24 54 00 00 cmp $0x5424,%r14d
ffffffff829d9c8c: 0f 84 15 13 00 00 je ffffffff829dafa7 <tty_ioctl+0x15d7>
ffffffff829d9c92: 0f 82 d0 07 00 00 jb ffffffff829da468 <tty_ioctl+0xa98>
ffffffff829d9c98: 41 81 fe 25 54 00 00 cmp $0x5425,%r14d
ffffffff829d9c9f: 0f 85 a0 02 00 00 jne ffffffff829d9f45 <tty_ioctl+0x575>
*/
if (!arg)
return send_break(tty, 250);
return 0;
case TCSBRKP: /* support for POSIX tcsendbreak() */
return send_break(tty, arg ? arg*100 : 250);
ffffffff829d9ca5: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffffffff829d9cac: be fa 00 00 00 mov $0xfa,%esi
ffffffff829d9cb1: 48 85 c0 test %rax,%rax
ffffffff829d9cb4: 74 03 je ffffffff829d9cb9 <tty_ioctl+0x2e9>
ffffffff829d9cb6: 6b f0 64 imul $0x64,%eax,%esi
ffffffff829d9cb9: 48 89 df mov %rbx,%rdi
ffffffff829d9cbc: e8 7f a1 ff ff callq ffffffff829d3e40 <send_break>
ffffffff829d9cc1: 4c 63 f8 movslq %eax,%r15
/*
* Split this up, as gcc can choke on it otherwise..
*/
long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
ffffffff829d9cc4: 48 ba 00 00 00 00 00 movabs $0xdffffc0000000000,%rdx
ffffffff829d9ccb: fc ff df
if (retval == -ENOIOCTLCMD)
retval = -ENOTTY;
}
tty_ldisc_deref(ld);
return retval;
}
ffffffff829d9cce: 4c 89 f8 mov %r15,%rax
/*
* Split this up, as gcc can choke on it otherwise..
*/
long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
ffffffff829d9cd1: 4c 01 e2 add %r12,%rdx
ffffffff829d9cd4: 48 c7 02 00 00 00 00 movq $0x0,(%rdx)
ffffffff829d9cdb: 48 c7 42 08 00 00 00 movq $0x0,0x8(%rdx)
ffffffff829d9ce2: 00
ffffffff829d9ce3: 48 c7 42 10 00 00 00 movq $0x0,0x10(%rdx)
ffffffff829d9cea: 00
ffffffff829d9ceb: 48 c7 42 18 00 00 00 movq $0x0,0x18(%rdx)
ffffffff829d9cf2: 00
ffffffff829d9cf3: c7 42 20 00 00 00 00 movl $0x0,0x20(%rdx)
ffffffff829d9cfa: 48 c7 42 2c 00 00 00 movq $0x0,0x2c(%rdx)
ffffffff829d9d01: 00
if (retval == -ENOIOCTLCMD)
retval = -ENOTTY;
}
tty_ldisc_deref(ld);
return retval;
}
ffffffff829d9d02: 48 81 c4 c0 01 00 00 add $0x1c0,%rsp
ffffffff829d9d09: 5b pop %rbx
ffffffff829d9d0a: 41 5c pop %r12
ffffffff829d9d0c: 41 5d pop %r13
ffffffff829d9d0e: 41 5e pop %r14
ffffffff829d9d10: 41 5f pop %r15
ffffffff829d9d12: 5d pop %rbp
ffffffff829d9d13: c3 retq
}
/*
* Now do the stuff.
*/
switch (cmd) {
ffffffff829d9d14: 41 81 fe 10 54 00 00 cmp $0x5410,%r14d
ffffffff829d9d1b: 0f 84 3d 0b 00 00 je ffffffff829da85e <tty_ioctl+0xe8e>
ffffffff829d9d21: 77 64 ja ffffffff829d9d87 <tty_ioctl+0x3b7>
ffffffff829d9d23: 41 81 fe 0c 54 00 00 cmp $0x540c,%r14d
ffffffff829d9d2a: 0f 84 bf 11 00 00 je ffffffff829daeef <tty_ioctl+0x151f>
ffffffff829d9d30: 0f 86 df 01 00 00 jbe ffffffff829d9f15 <tty_ioctl+0x545>
ffffffff829d9d36: 41 81 fe 0e 54 00 00 cmp $0x540e,%r14d
ffffffff829d9d3d: 0f 84 81 0e 00 00 je ffffffff829dabc4 <tty_ioctl+0x11f4>
ffffffff829d9d43: 0f 87 d6 06 00 00 ja ffffffff829da41f <tty_ioctl+0xa4f>
*/
static __always_inline void
clear_bit(long nr, volatile unsigned long *addr)
{
if (IS_IMMEDIATE(nr)) {
asm volatile(LOCK_PREFIX "andb %1,%0"
ffffffff829d9d49: f0 80 a3 58 04 00 00 lock andb $0xf7,0x458(%rbx)
ffffffff829d9d50: f7
case TIOCEXCL:
set_bit(TTY_EXCLUSIVE, &tty->flags);
return 0;
case TIOCNXCL:
clear_bit(TTY_EXCLUSIVE, &tty->flags);
return 0;
ffffffff829d9d51: 45 31 ff xor %r15d,%r15d
ffffffff829d9d54: e9 6b ff ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
*/
static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
{
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
tty->driver->subtype == PTY_TYPE_MASTER)
tty = tty->link;
ffffffff829d9d59: 48 8d bb 90 04 00 00 lea 0x490(%rbx),%rdi
ffffffff829d9d60: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9d67: fc ff df
ffffffff829d9d6a: 48 89 fa mov %rdi,%rdx
ffffffff829d9d6d: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9d71: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9d75: 0f 85 94 1a 00 00 jne ffffffff829db80f <tty_ioctl+0x1e3f>
ffffffff829d9d7b: 4c 8b 93 90 04 00 00 mov 0x490(%rbx),%r10
ffffffff829d9d82: e9 c2 fd ff ff jmpq ffffffff829d9b49 <tty_ioctl+0x179>
}
/*
* Now do the stuff.
*/
switch (cmd) {
ffffffff829d9d87: 41 81 fe 14 54 00 00 cmp $0x5414,%r14d
ffffffff829d9d8e: 0f 84 6b 11 00 00 je ffffffff829daeff <tty_ioctl+0x152f>
ffffffff829d9d94: 0f 87 1c 02 00 00 ja ffffffff829d9fb6 <tty_ioctl+0x5e6>
ffffffff829d9d9a: 41 81 fe 12 54 00 00 cmp $0x5412,%r14d
ffffffff829d9da1: 0f 84 c3 04 00 00 je ffffffff829da26a <tty_ioctl+0x89a>
ffffffff829d9da7: 41 81 fe 13 54 00 00 cmp $0x5413,%r14d
ffffffff829d9dae: 0f 85 91 01 00 00 jne ffffffff829d9f45 <tty_ioctl+0x575>
static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
{
int err;
mutex_lock(&tty->winsize_mutex);
ffffffff829d9db4: 49 8d 9a b8 02 00 00 lea 0x2b8(%r10),%rbx
ffffffff829d9dbb: 31 f6 xor %esi,%esi
ffffffff829d9dbd: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829d9dc4: 48 89 df mov %rbx,%rdi
ffffffff829d9dc7: e8 04 5b 8c 02 callq ffffffff8529f8d0 <mutex_lock_nested>
static inline unsigned long __must_check
copy_to_user(void __user *to, const void *from, unsigned long n)
{
int sz = __compiletime_object_size(from);
might_fault();
ffffffff829d9dcc: be dc 02 00 00 mov $0x2dc,%esi
ffffffff829d9dd1: 48 c7 c7 c0 24 61 85 mov $0xffffffff856124c0,%rdi
ffffffff829d9dd8: e8 e3 07 bb fe callq ffffffff8158a5c0 <__might_fault>
err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
ffffffff829d9ddd: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
/* See the comment in copy_from_user() above. */
if (likely(sz < 0 || sz >= n))
n = _copy_to_user(to, from, n);
ffffffff829d9de4: 48 8b bd 30 fe ff ff mov -0x1d0(%rbp),%rdi
ffffffff829d9deb: ba 08 00 00 00 mov $0x8,%edx
ffffffff829d9df0: 49 8d b2 64 04 00 00 lea 0x464(%r10),%rsi
ffffffff829d9df7: e8 84 a3 d1 ff callq ffffffff826f4180 <_copy_to_user>
mutex_unlock(&tty->winsize_mutex);
ffffffff829d9dfc: 48 89 df mov %rbx,%rdi
ffffffff829d9dff: 49 89 c5 mov %rax,%r13
ffffffff829d9e02: e8 f9 8b 8c 02 callq ffffffff852a2a00 <mutex_unlock>
return err ? -EFAULT: 0;
ffffffff829d9e07: 41 83 fd 01 cmp $0x1,%r13d
ffffffff829d9e0b: 4d 19 ff sbb %r15,%r15
ffffffff829d9e0e: 49 f7 d7 not %r15
ffffffff829d9e11: 49 83 e7 f2 and $0xfffffffffffffff2,%r15
ffffffff829d9e15: e9 aa fe ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
}
/*
* Now do the stuff.
*/
switch (cmd) {
ffffffff829d9e1a: 41 81 fe 37 54 00 00 cmp $0x5437,%r14d
ffffffff829d9e21: 0f 84 00 09 00 00 je ffffffff829da727 <tty_ioctl+0xd57>
ffffffff829d9e27: 0f 86 74 07 00 00 jbe ffffffff829da5a1 <tty_ioctl+0xbd1>
ffffffff829d9e2d: 41 81 fe 32 54 04 80 cmp $0x80045432,%r14d
ffffffff829d9e34: 0f 84 11 08 00 00 je ffffffff829da64b <tty_ioctl+0xc7b>
ffffffff829d9e3a: 41 81 fe 40 54 04 80 cmp $0x80045440,%r14d
ffffffff829d9e41: 0f 84 5f 06 00 00 je ffffffff829da4a6 <tty_ioctl+0xad6>
ffffffff829d9e47: 41 81 fe 5d 54 00 00 cmp $0x545d,%r14d
ffffffff829d9e4e: 0f 85 f1 00 00 00 jne ffffffff829d9f45 <tty_ioctl+0x575>
static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
{
int retval = -EINVAL;
struct serial_icounter_struct icount;
memset(&icount, 0, sizeof(icount));
ffffffff829d9e54: 4c 8d bd 58 ff ff ff lea -0xa8(%rbp),%r15
ffffffff829d9e5b: ba 50 00 00 00 mov $0x50,%edx
ffffffff829d9e60: 31 f6 xor %esi,%esi
ffffffff829d9e62: 4c 89 ff mov %r15,%rdi
ffffffff829d9e65: e8 a6 f8 c1 fe callq ffffffff815f9710 <memset>
if (tty->ops->get_icount)
ffffffff829d9e6a: 48 8d 53 18 lea 0x18(%rbx),%rdx
ffffffff829d9e6e: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9e75: fc ff df
ffffffff829d9e78: 48 89 d1 mov %rdx,%rcx
ffffffff829d9e7b: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829d9e7f: 80 3c 01 00 cmpb $0x0,(%rcx,%rax,1)
ffffffff829d9e83: 0f 85 ee 1a 00 00 jne ffffffff829db977 <tty_ioctl+0x1fa7>
ffffffff829d9e89: 48 8b 43 18 mov 0x18(%rbx),%rax
ffffffff829d9e8d: 48 b9 00 00 00 00 00 movabs $0xdffffc0000000000,%rcx
ffffffff829d9e94: fc ff df
ffffffff829d9e97: 48 8d b8 e8 00 00 00 lea 0xe8(%rax),%rdi
ffffffff829d9e9e: 48 89 fe mov %rdi,%rsi
ffffffff829d9ea1: 48 c1 ee 03 shr $0x3,%rsi
ffffffff829d9ea5: 80 3c 0e 00 cmpb $0x0,(%rsi,%rcx,1)
ffffffff829d9ea9: 0f 85 a2 1a 00 00 jne ffffffff829db951 <tty_ioctl+0x1f81>
ffffffff829d9eaf: 48 8b 80 e8 00 00 00 mov 0xe8(%rax),%rax
ffffffff829d9eb6: 48 85 c0 test %rax,%rax
ffffffff829d9eb9: 0f 84 8a 00 00 00 je ffffffff829d9f49 <tty_ioctl+0x579>
ffffffff829d9ebf: 48 89 95 28 fe ff ff mov %rdx,-0x1d8(%rbp)
retval = tty->ops->get_icount(tty, &icount);
ffffffff829d9ec6: 4c 89 fe mov %r15,%rsi
ffffffff829d9ec9: 48 89 df mov %rbx,%rdi
ffffffff829d9ecc: ff d0 callq *%rax
if (retval != 0)
ffffffff829d9ece: 85 c0 test %eax,%eax
ffffffff829d9ed0: 48 8b 95 28 fe ff ff mov -0x1d8(%rbp),%rdx
ffffffff829d9ed7: 0f 85 2c 12 00 00 jne ffffffff829db109 <tty_ioctl+0x1739>
static inline unsigned long __must_check
copy_to_user(void __user *to, const void *from, unsigned long n)
{
int sz = __compiletime_object_size(from);
might_fault();
ffffffff829d9edd: be dc 02 00 00 mov $0x2dc,%esi
ffffffff829d9ee2: 48 c7 c7 c0 24 61 85 mov $0xffffffff856124c0,%rdi
ffffffff829d9ee9: e8 d2 06 bb fe callq ffffffff8158a5c0 <__might_fault>
/* See the comment in copy_from_user() above. */
if (likely(sz < 0 || sz >= n))
n = _copy_to_user(to, from, n);
ffffffff829d9eee: 48 8b bd 30 fe ff ff mov -0x1d0(%rbp),%rdi
ffffffff829d9ef5: 4c 89 fe mov %r15,%rsi
ffffffff829d9ef8: ba 50 00 00 00 mov $0x50,%edx
ffffffff829d9efd: e8 7e a2 d1 ff callq ffffffff826f4180 <_copy_to_user>
return retval;
if (copy_to_user(arg, &icount, sizeof(icount)))
ffffffff829d9f02: 48 83 f8 01 cmp $0x1,%rax
ffffffff829d9f06: 4d 19 ff sbb %r15,%r15
ffffffff829d9f09: 49 f7 d7 not %r15
ffffffff829d9f0c: 49 83 e7 f2 and $0xfffffffffffffff2,%r15
ffffffff829d9f10: e9 af fd ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
}
/*
* Now do the stuff.
*/
switch (cmd) {
ffffffff829d9f15: 41 81 fe 09 54 00 00 cmp $0x5409,%r14d
ffffffff829d9f1c: 0f 84 32 03 00 00 je ffffffff829da254 <tty_ioctl+0x884>
ffffffff829d9f22: 41 81 fe 0b 54 00 00 cmp $0x540b,%r14d
ffffffff829d9f29: 75 1a jne ffffffff829d9f45 <tty_ioctl+0x575>
/* For the moment allow fall through to the old method */
if (retval != -EINVAL)
return retval;
break;
case TCFLSH:
switch (arg) {
ffffffff829d9f2b: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffffffff829d9f32: 48 85 c0 test %rax,%rax
ffffffff829d9f35: 0f 84 65 12 00 00 je ffffffff829db1a0 <tty_ioctl+0x17d0>
ffffffff829d9f3b: 48 83 f8 02 cmp $0x2,%rax
ffffffff829d9f3f: 0f 84 5b 12 00 00 je ffffffff829db1a0 <tty_ioctl+0x17d0>
ffffffff829d9f45: 48 8d 53 18 lea 0x18(%rbx),%rdx
break;
case TIOCSSERIAL:
tty_warn_deprecated_flags(p);
break;
}
if (tty->ops->ioctl) {
ffffffff829d9f49: 48 89 d1 mov %rdx,%rcx
ffffffff829d9f4c: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9f53: fc ff df
ffffffff829d9f56: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829d9f5a: 80 3c 01 00 cmpb $0x0,(%rcx,%rax,1)
ffffffff829d9f5e: 0f 85 34 17 00 00 jne ffffffff829db698 <tty_ioctl+0x1cc8>
ffffffff829d9f64: 4c 8b 7b 18 mov 0x18(%rbx),%r15
ffffffff829d9f68: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9f6f: fc ff df
ffffffff829d9f72: 49 8d 7f 60 lea 0x60(%r15),%rdi
ffffffff829d9f76: 48 89 fa mov %rdi,%rdx
ffffffff829d9f79: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9f7d: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9f81: 0f 85 07 17 00 00 jne ffffffff829db68e <tty_ioctl+0x1cbe>
ffffffff829d9f87: 49 8b 47 60 mov 0x60(%r15),%rax
ffffffff829d9f8b: 48 85 c0 test %rax,%rax
ffffffff829d9f8e: 0f 84 75 05 00 00 je ffffffff829da509 <tty_ioctl+0xb39>
retval = tty->ops->ioctl(tty, cmd, arg);
ffffffff829d9f94: 48 8b 95 30 fe ff ff mov -0x1d0(%rbp),%rdx
ffffffff829d9f9b: 44 89 f6 mov %r14d,%esi
ffffffff829d9f9e: 48 89 df mov %rbx,%rdi
ffffffff829d9fa1: ff d0 callq *%rax
if (retval != -ENOIOCTLCMD)
ffffffff829d9fa3: 3d fd fd ff ff cmp $0xfffffdfd,%eax
ffffffff829d9fa8: 0f 84 5b 05 00 00 je ffffffff829da509 <tty_ioctl+0xb39>
if (tty->ops->tiocmget) {
retval = tty->ops->tiocmget(tty);
if (retval >= 0)
retval = put_user(retval, p);
ffffffff829d9fae: 4c 63 f8 movslq %eax,%r15
ffffffff829d9fb1: e9 0e fd ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
}
/*
* Now do the stuff.
*/
switch (cmd) {
ffffffff829d9fb6: 41 81 fe 15 54 00 00 cmp $0x5415,%r14d
ffffffff829d9fbd: 0f 84 d1 03 00 00 je ffffffff829da394 <tty_ioctl+0x9c4>
ffffffff829d9fc3: 41 81 fe 18 54 00 00 cmp $0x5418,%r14d
ffffffff829d9fca: 0f 87 75 ff ff ff ja ffffffff829d9f45 <tty_ioctl+0x575>
unsigned __user *p)
{
int retval;
unsigned int set, clear, val;
if (tty->ops->tiocmset == NULL)
ffffffff829d9fd0: 4c 8d 7b 18 lea 0x18(%rbx),%r15
ffffffff829d9fd4: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829d9fdb: fc ff df
ffffffff829d9fde: 4c 89 fa mov %r15,%rdx
ffffffff829d9fe1: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829d9fe5: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829d9fe9: 0f 85 e1 17 00 00 jne ffffffff829db7d0 <tty_ioctl+0x1e00>
ffffffff829d9fef: 4c 8b 6b 18 mov 0x18(%rbx),%r13
ffffffff829d9ff3: 48 ba 00 00 00 00 00 movabs $0xdffffc0000000000,%rdx
ffffffff829d9ffa: fc ff df
ffffffff829d9ffd: 49 8d bd d0 00 00 00 lea 0xd0(%r13),%rdi
ffffffff829da004: 48 89 f9 mov %rdi,%rcx
ffffffff829da007: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829da00b: 80 3c 11 00 cmpb $0x0,(%rcx,%rdx,1)
ffffffff829da00f: 0f 85 b1 17 00 00 jne ffffffff829db7c6 <tty_ioctl+0x1df6>
ffffffff829da015: 49 83 bd d0 00 00 00 cmpq $0x0,0xd0(%r13)
ffffffff829da01c: 00
ffffffff829da01d: 0f 84 2a 13 00 00 je ffffffff829db34d <tty_ioctl+0x197d>
return -EINVAL;
retval = get_user(val, p);
ffffffff829da023: be b5 0a 00 00 mov $0xab5,%esi
ffffffff829da028: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da02f: e8 8c 05 bb fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da034: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffffffff829da03b: e8 50 a9 d1 ff callq ffffffff826f4990 <__get_user_4>
if (retval)
ffffffff829da040: 85 c0 test %eax,%eax
ffffffff829da042: 0f 85 66 ff ff ff jne ffffffff829d9fae <tty_ioctl+0x5de>
return retval;
set = clear = 0;
switch (cmd) {
ffffffff829da048: 41 81 fe 17 54 00 00 cmp $0x5417,%r14d
ffffffff829da04f: 0f 84 5e 11 00 00 je ffffffff829db1b3 <tty_ioctl+0x17e3>
ffffffff829da055: 89 d6 mov %edx,%esi
ffffffff829da057: 81 e6 06 e0 00 00 and $0xe006,%esi
ffffffff829da05d: 41 81 fe 18 54 00 00 cmp $0x5418,%r14d
ffffffff829da064: 0f 85 1a 11 00 00 jne ffffffff829db184 <tty_ioctl+0x17b4>
case TIOCMBIC:
clear = val;
break;
case TIOCMSET:
set = val;
clear = ~val;
ffffffff829da06a: f7 d2 not %edx
ffffffff829da06c: 81 e2 06 e0 00 00 and $0xe006,%edx
break;
}
set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
return tty->ops->tiocmset(tty, set, clear);
ffffffff829da072: 4c 89 f9 mov %r15,%rcx
ffffffff829da075: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da07c: fc ff df
ffffffff829da07f: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829da083: 80 3c 01 00 cmpb $0x0,(%rcx,%rax,1)
ffffffff829da087: 0f 85 f2 14 00 00 jne ffffffff829db57f <tty_ioctl+0x1baf>
ffffffff829da08d: 4c 8b 6b 18 mov 0x18(%rbx),%r13
ffffffff829da091: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da098: fc ff df
ffffffff829da09b: 49 8d bd d0 00 00 00 lea 0xd0(%r13),%rdi
ffffffff829da0a2: 48 89 f9 mov %rdi,%rcx
ffffffff829da0a5: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829da0a9: 80 3c 01 00 cmpb $0x0,(%rcx,%rax,1)
ffffffff829da0ad: 0f 85 98 15 00 00 jne ffffffff829db64b <tty_ioctl+0x1c7b>
ffffffff829da0b3: 48 89 df mov %rbx,%rdi
ffffffff829da0b6: 41 ff 95 d0 00 00 00 callq *0xd0(%r13)
ffffffff829da0bd: e9 ec fe ff ff jmpq ffffffff829d9fae <tty_ioctl+0x5de>
}
/*
* Now do the stuff.
*/
switch (cmd) {
ffffffff829da0c2: 41 81 fe 1f 54 00 00 cmp $0x541f,%r14d
ffffffff829da0c9: 0f 84 fe 00 00 00 je ffffffff829da1cd <tty_ioctl+0x7fd>
ffffffff829da0cf: 41 81 fe 21 54 00 00 cmp $0x5421,%r14d
ffffffff829da0d6: 0f 85 69 fe ff ff jne ffffffff829d9f45 <tty_ioctl+0x575>
static int fionbio(struct file *file, int __user *p)
{
int nonblock;
if (get_user(nonblock, p))
ffffffff829da0dc: be 6f 09 00 00 mov $0x96f,%esi
ffffffff829da0e1: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da0e8: e8 d3 04 bb fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da0ed: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffffffff829da0f4: e8 97 a8 d1 ff callq ffffffff826f4990 <__get_user_4>
ffffffff829da0f9: 85 c0 test %eax,%eax
ffffffff829da0fb: 49 89 d6 mov %rdx,%r14
ffffffff829da0fe: 49 c7 c7 f2 ff ff ff mov $0xfffffffffffffff2,%r15
ffffffff829da105: 0f 85 b9 fb ff ff jne ffffffff829d9cc4 <tty_ioctl+0x2f4>
raw_spin_lock_init(&(_lock)->rlock); \
} while (0)
static __always_inline void spin_lock(spinlock_t *lock)
{
raw_spin_lock(&lock->rlock);
ffffffff829da10b: 49 8d 5d 30 lea 0x30(%r13),%rbx
ffffffff829da10f: 48 89 df mov %rbx,%rdi
ffffffff829da112: e8 69 cb 8c 02 callq ffffffff852a6c80 <_raw_spin_lock>
return -EFAULT;
spin_lock(&file->f_lock);
if (nonblock)
file->f_flags |= O_NONBLOCK;
ffffffff829da117: 49 8d 7d 70 lea 0x70(%r13),%rdi
ffffffff829da11b: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da122: fc ff df
ffffffff829da125: 48 89 fa mov %rdi,%rdx
ffffffff829da128: 48 c1 ea 03 shr $0x3,%rdx
if (get_user(nonblock, p))
return -EFAULT;
spin_lock(&file->f_lock);
if (nonblock)
ffffffff829da12c: 45 85 f6 test %r14d,%r14d
file->f_flags |= O_NONBLOCK;
ffffffff829da12f: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
if (get_user(nonblock, p))
return -EFAULT;
spin_lock(&file->f_lock);
if (nonblock)
ffffffff829da133: 0f 84 9f 0f 00 00 je ffffffff829db0d8 <tty_ioctl+0x1708>
file->f_flags |= O_NONBLOCK;
ffffffff829da139: 84 c0 test %al,%al
ffffffff829da13b: 74 08 je ffffffff829da145 <tty_ioctl+0x775>
ffffffff829da13d: 3c 03 cmp $0x3,%al
ffffffff829da13f: 0f 8e 3d 16 00 00 jle ffffffff829db782 <tty_ioctl+0x1db2>
ffffffff829da145: 41 81 4d 70 00 08 00 orl $0x800,0x70(%r13)
ffffffff829da14c: 00
raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
} while (0)
static __always_inline void spin_unlock(spinlock_t *lock)
{
raw_spin_unlock(&lock->rlock);
ffffffff829da14d: 48 89 df mov %rbx,%rdi
ffffffff829da150: 45 31 ff xor %r15d,%r15d
ffffffff829da153: e8 08 ce 8c 02 callq ffffffff852a6f60 <_raw_spin_unlock>
ffffffff829da158: e9 67 fb ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
* Locking: none (up to the driver)
*/
static int tty_tiocmget(struct tty_struct *tty, int __user *p)
{
int retval = -EINVAL;
ffffffff829da15d: 49 c7 c7 ea ff ff ff mov $0xffffffffffffffea,%r15
return 0;
case TCSBRKP: /* support for POSIX tcsendbreak() */
return send_break(tty, arg ? arg*100 : 250);
case TIOCMGET:
return tty_tiocmget(tty, p);
ffffffff829da164: e9 5b fb ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
case TIOCSBRK: /* Turn break on, unconditionally */
if (tty->ops->break_ctl)
return tty->ops->break_ctl(tty, -1);
return 0;
case TIOCCBRK: /* Turn break off, unconditionally */
if (tty->ops->break_ctl)
ffffffff829da169: 48 8d 7b 18 lea 0x18(%rbx),%rdi
ffffffff829da16d: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da174: fc ff df
ffffffff829da177: 48 89 fa mov %rdi,%rdx
ffffffff829da17a: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da17e: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da182: 0f 85 27 15 00 00 jne ffffffff829db6af <tty_ioctl+0x1cdf>
ffffffff829da188: 4c 8b 6b 18 mov 0x18(%rbx),%r13
ffffffff829da18c: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da193: fc ff df
ffffffff829da196: 49 8d bd a0 00 00 00 lea 0xa0(%r13),%rdi
ffffffff829da19d: 48 89 fa mov %rdi,%rdx
ffffffff829da1a0: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da1a4: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da1a8: 0f 85 f7 14 00 00 jne ffffffff829db6a5 <tty_ioctl+0x1cd5>
ffffffff829da1ae: 49 8b 85 a0 00 00 00 mov 0xa0(%r13),%rax
ffffffff829da1b5: 48 85 c0 test %rax,%rax
ffffffff829da1b8: 0f 84 a4 00 00 00 je ffffffff829da262 <tty_ioctl+0x892>
return tty->ops->break_ctl(tty, 0);
ffffffff829da1be: 31 f6 xor %esi,%esi
ffffffff829da1c0: 48 89 df mov %rbx,%rdi
ffffffff829da1c3: ff d0 callq *%rax
ffffffff829da1c5: 4c 63 f8 movslq %eax,%r15
ffffffff829da1c8: e9 f7 fa ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
DEFAULT_RATELIMIT_INTERVAL,
DEFAULT_RATELIMIT_BURST);
char comm[TASK_COMM_LEN];
int flags;
if (get_user(flags, &ss->flags))
ffffffff829da1cd: be e0 0a 00 00 mov $0xae0,%esi
ffffffff829da1d2: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da1d9: e8 e2 03 bb fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da1de: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffffffff829da1e5: 48 83 c0 10 add $0x10,%rax
ffffffff829da1e9: e8 a2 a7 d1 ff callq ffffffff826f4990 <__get_user_4>
ffffffff829da1ee: 85 c0 test %eax,%eax
ffffffff829da1f0: 0f 85 4f fd ff ff jne ffffffff829d9f45 <tty_ioctl+0x575>
return;
flags &= ASYNC_DEPRECATED;
if (flags && __ratelimit(&depr_flags))
ffffffff829da1f6: 41 89 d7 mov %edx,%r15d
ffffffff829da1f9: 41 81 e7 00 87 00 00 and $0x8700,%r15d
ffffffff829da200: 0f 84 3f fd ff ff je ffffffff829d9f45 <tty_ioctl+0x575>
ffffffff829da206: 48 c7 c6 a0 2c 61 85 mov $0xffffffff85612ca0,%rsi
ffffffff829da20d: 48 c7 c7 00 7d 3d 86 mov $0xffffffff863d7d00,%rdi
ffffffff829da214: e8 67 d1 cf ff callq ffffffff826d7380 <___ratelimit>
ffffffff829da219: 85 c0 test %eax,%eax
ffffffff829da21b: 0f 84 24 fd ff ff je ffffffff829d9f45 <tty_ioctl+0x575>
pr_warning("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
ffffffff829da221: 48 8d bd 18 ff ff ff lea -0xe8(%rbp),%rdi
ffffffff829da228: 65 48 8b 34 25 c0 3f mov %gs:0x13fc0,%rsi
ffffffff829da22f: 01 00
ffffffff829da231: e8 ca aa c6 fe callq ffffffff81644d00 <get_task_comm>
ffffffff829da236: 44 89 f9 mov %r15d,%ecx
ffffffff829da239: 48 89 c2 mov %rax,%rdx
ffffffff829da23c: 48 c7 c6 a0 2c 61 85 mov $0xffffffff85612ca0,%rsi
ffffffff829da243: 48 c7 c7 20 25 61 85 mov $0xffffffff85612520,%rdi
ffffffff829da24a: e8 0d eb b2 fe callq ffffffff81508d5c <printk>
ffffffff829da24f: e9 f1 fc ff ff jmpq ffffffff829d9f45 <tty_ioctl+0x575>
case TCSBRK: /* SVID version: non-zero arg --> no break */
/* non-zero arg means wait for all output data
* to be sent (performed above) but don't send break.
* This is used by the tcdrain() termios function.
*/
if (!arg)
ffffffff829da254: 48 83 bd 30 fe ff ff cmpq $0x0,-0x1d0(%rbp)
ffffffff829da25b: 00
ffffffff829da25c: 0f 84 29 0f 00 00 je ffffffff829db18b <tty_ioctl+0x17bb>
* Break handling
*/
case TIOCSBRK: /* Turn break on, unconditionally */
if (tty->ops->break_ctl)
return tty->ops->break_ctl(tty, -1);
return 0;
ffffffff829da262: 45 31 ff xor %r15d,%r15d
ffffffff829da265: e9 5a fa ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
ffffffff829da26a: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829da271: 01 00
static int tiocsti(struct tty_struct *tty, char __user *p)
{
char ch, mbz = 0;
struct tty_ldisc *ld;
if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
ffffffff829da273: 49 8d be 48 06 00 00 lea 0x648(%r14),%rdi
ffffffff829da27a: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da281: fc ff df
* FIXME: may race normal receive processing
*/
static int tiocsti(struct tty_struct *tty, char __user *p)
{
char ch, mbz = 0;
ffffffff829da284: c6 85 98 fe ff ff 00 movb $0x0,-0x168(%rbp)
struct tty_ldisc *ld;
if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
ffffffff829da28b: 48 89 fa mov %rdi,%rdx
ffffffff829da28e: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da292: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da296: 0f 85 97 16 00 00 jne ffffffff829db933 <tty_ioctl+0x1f63>
ffffffff829da29c: 4d 8b b6 48 06 00 00 mov 0x648(%r14),%r14
ffffffff829da2a3: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da2aa: fc ff df
ffffffff829da2ad: 49 8d be d0 01 00 00 lea 0x1d0(%r14),%rdi
ffffffff829da2b4: 48 89 fa mov %rdi,%rdx
ffffffff829da2b7: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da2bb: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da2bf: 0f 85 64 16 00 00 jne ffffffff829db929 <tty_ioctl+0x1f59>
ffffffff829da2c5: 49 3b 9e d0 01 00 00 cmp 0x1d0(%r14),%rbx
ffffffff829da2cc: 74 12 je ffffffff829da2e0 <tty_ioctl+0x910>
ffffffff829da2ce: bf 15 00 00 00 mov $0x15,%edi
ffffffff829da2d3: e8 78 1f 87 fe callq ffffffff8124c250 <capable>
ffffffff829da2d8: 84 c0 test %al,%al
ffffffff829da2da: 0f 84 1c 10 00 00 je ffffffff829db2fc <tty_ioctl+0x192c>
return -EPERM;
if (get_user(ch, p))
ffffffff829da2e0: be e4 08 00 00 mov $0x8e4,%esi
ffffffff829da2e5: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da2ec: e8 cf 02 bb fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da2f1: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffffffff829da2f8: e8 33 a6 d1 ff callq ffffffff826f4930 <__get_user_1>
ffffffff829da2fd: 85 c0 test %eax,%eax
ffffffff829da2ff: 88 95 58 fe ff ff mov %dl,-0x1a8(%rbp)
ffffffff829da305: 49 c7 c7 f2 ff ff ff mov $0xfffffffffffffff2,%r15
ffffffff829da30c: 0f 85 b2 f9 ff ff jne ffffffff829d9cc4 <tty_ioctl+0x2f4>
return -EFAULT;
tty_audit_tiocsti(tty, ch);
ffffffff829da312: 0f be f2 movsbl %dl,%esi
ffffffff829da315: 48 89 df mov %rbx,%rdi
ffffffff829da318: e8 a3 0c 02 00 callq ffffffff829fafc0 <tty_audit_tiocsti>
ld = tty_ldisc_ref_wait(tty);
ffffffff829da31d: 48 89 df mov %rbx,%rdi
ffffffff829da320: e8 1b 74 01 00 callq ffffffff829f1740 <tty_ldisc_ref_wait>
ld->ops->receive_buf(tty, &ch, &mbz, 1);
ffffffff829da325: 48 89 c2 mov %rax,%rdx
if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
return -EPERM;
if (get_user(ch, p))
return -EFAULT;
tty_audit_tiocsti(tty, ch);
ld = tty_ldisc_ref_wait(tty);
ffffffff829da328: 49 89 c5 mov %rax,%r13
ld->ops->receive_buf(tty, &ch, &mbz, 1);
ffffffff829da32b: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da332: fc ff df
ffffffff829da335: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da339: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da33d: 0f 85 3e 13 00 00 jne ffffffff829db681 <tty_ioctl+0x1cb1>
ffffffff829da343: 4d 8b 75 00 mov 0x0(%r13),%r14
ffffffff829da347: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da34e: fc ff df
ffffffff829da351: 49 8d 7e 70 lea 0x70(%r14),%rdi
ffffffff829da355: 48 89 fa mov %rdi,%rdx
ffffffff829da358: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da35c: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da360: 0f 85 11 13 00 00 jne ffffffff829db677 <tty_ioctl+0x1ca7>
ffffffff829da366: 48 8d 45 d8 lea -0x28(%rbp),%rax
ffffffff829da36a: 48 8d 95 98 fe ff ff lea -0x168(%rbp),%rdx
ffffffff829da371: b9 01 00 00 00 mov $0x1,%ecx
ffffffff829da376: 48 89 df mov %rbx,%rdi
tty_ldisc_deref(ld);
ffffffff829da379: 45 31 ff xor %r15d,%r15d
return -EPERM;
if (get_user(ch, p))
return -EFAULT;
tty_audit_tiocsti(tty, ch);
ld = tty_ldisc_ref_wait(tty);
ld->ops->receive_buf(tty, &ch, &mbz, 1);
ffffffff829da37c: 48 8d b0 80 fe ff ff lea -0x180(%rax),%rsi
ffffffff829da383: 41 ff 56 70 callq *0x70(%r14)
tty_ldisc_deref(ld);
ffffffff829da387: 4c 89 ef mov %r13,%rdi
ffffffff829da38a: e8 d1 74 01 00 callq ffffffff829f1860 <tty_ldisc_deref>
ffffffff829da38f: e9 30 f9 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
static int tty_tiocmget(struct tty_struct *tty, int __user *p)
{
int retval = -EINVAL;
if (tty->ops->tiocmget) {
ffffffff829da394: 48 8d 7b 18 lea 0x18(%rbx),%rdi
ffffffff829da398: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da39f: fc ff df
ffffffff829da3a2: 48 89 fa mov %rdi,%rdx
ffffffff829da3a5: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da3a9: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da3ad: 0f 85 27 13 00 00 jne ffffffff829db6da <tty_ioctl+0x1d0a>
ffffffff829da3b3: 4c 8b 73 18 mov 0x18(%rbx),%r14
ffffffff829da3b7: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da3be: fc ff df
ffffffff829da3c1: 49 8d be c8 00 00 00 lea 0xc8(%r14),%rdi
ffffffff829da3c8: 48 89 fa mov %rdi,%rdx
ffffffff829da3cb: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da3cf: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da3d3: 0f 85 f7 12 00 00 jne ffffffff829db6d0 <tty_ioctl+0x1d00>
ffffffff829da3d9: 49 8b 86 c8 00 00 00 mov 0xc8(%r14),%rax
ffffffff829da3e0: 48 85 c0 test %rax,%rax
ffffffff829da3e3: 0f 84 74 fd ff ff je ffffffff829da15d <tty_ioctl+0x78d>
retval = tty->ops->tiocmget(tty);
ffffffff829da3e9: 48 89 df mov %rbx,%rdi
ffffffff829da3ec: ff d0 callq *%rax
ffffffff829da3ee: 4c 63 f8 movslq %eax,%r15
if (retval >= 0)
ffffffff829da3f1: 45 85 ff test %r15d,%r15d
ffffffff829da3f4: 0f 88 ca f8 ff ff js ffffffff829d9cc4 <tty_ioctl+0x2f4>
retval = put_user(retval, p);
ffffffff829da3fa: be 9b 0a 00 00 mov $0xa9b,%esi
ffffffff829da3ff: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da406: e8 b5 01 bb fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da40b: 44 89 f8 mov %r15d,%eax
ffffffff829da40e: 48 8b 8d 30 fe ff ff mov -0x1d0(%rbp),%rcx
ffffffff829da415: e8 76 ec d1 ff callq ffffffff826f9090 <__put_user_4>
ffffffff829da41a: e9 8f fb ff ff jmpq ffffffff829d9fae <tty_ioctl+0x5de>
int ret;
/*
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
ffffffff829da41f: 4c 39 d3 cmp %r10,%rbx
ffffffff829da422: 0f 84 ef 0c 00 00 je ffffffff829db117 <tty_ioctl+0x1747>
return -ENOTTY;
pid = tty_get_pgrp(real_tty);
ffffffff829da428: 4c 89 d7 mov %r10,%rdi
ffffffff829da42b: e8 70 7d ff ff callq ffffffff829d21a0 <tty_get_pgrp>
ret = put_user(pid_vnr(pid), p);
ffffffff829da430: be fa 09 00 00 mov $0x9fa,%esi
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
return -ENOTTY;
pid = tty_get_pgrp(real_tty);
ffffffff829da435: 49 89 c6 mov %rax,%r14
ret = put_user(pid_vnr(pid), p);
ffffffff829da438: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da43f: e8 7c 01 bb fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da444: 4c 89 f7 mov %r14,%rdi
ffffffff829da447: e8 54 da 8a fe callq ffffffff81287ea0 <pid_vnr>
ffffffff829da44c: 48 8b 8d 30 fe ff ff mov -0x1d0(%rbp),%rcx
ffffffff829da453: e8 38 ec d1 ff callq ffffffff826f9090 <__put_user_4>
put_pid(pid);
ffffffff829da458: 4c 89 f7 mov %r14,%rdi
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
return -ENOTTY;
pid = tty_get_pgrp(real_tty);
ret = put_user(pid_vnr(pid), p);
ffffffff829da45b: 4c 63 f8 movslq %eax,%r15
put_pid(pid);
ffffffff829da45e: e8 7d de 8a fe callq ffffffff812882e0 <put_pid>
ffffffff829da463: e9 5c f8 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
static int tiocsetd(struct tty_struct *tty, int __user *p)
{
int ldisc;
int ret;
if (get_user(ldisc, p))
ffffffff829da468: be 57 0a 00 00 mov $0xa57,%esi
ffffffff829da46d: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da474: e8 47 01 bb fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da479: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffffffff829da480: e8 0b a5 d1 ff callq ffffffff826f4990 <__get_user_4>
ffffffff829da485: 85 c0 test %eax,%eax
ffffffff829da487: 49 c7 c7 f2 ff ff ff mov $0xfffffffffffffff2,%r15
ffffffff829da48e: 0f 85 30 f8 ff ff jne ffffffff829d9cc4 <tty_ioctl+0x2f4>
return -EFAULT;
ret = tty_set_ldisc(tty, ldisc);
ffffffff829da494: 89 d6 mov %edx,%esi
ffffffff829da496: 48 89 df mov %rbx,%rdi
ffffffff829da499: e8 82 7b 01 00 callq ffffffff829f2020 <tty_set_ldisc>
ffffffff829da49e: 4c 63 f8 movslq %eax,%r15
ffffffff829da4a1: e9 1e f8 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
}
static __always_inline int constant_test_bit(long nr, const volatile unsigned long *addr)
{
return ((1UL << (nr & (BITS_PER_LONG-1))) &
(addr[nr >> _BITOPS_LONG_SHIFT])) != 0;
ffffffff829da4a6: 48 8d bb 58 04 00 00 lea 0x458(%rbx),%rdi
ffffffff829da4ad: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da4b4: fc ff df
ffffffff829da4b7: 48 89 fa mov %rdi,%rdx
ffffffff829da4ba: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da4be: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da4c2: 0f 85 a5 11 00 00 jne ffffffff829db66d <tty_ioctl+0x1c9d>
ffffffff829da4c8: 4c 8b bb 58 04 00 00 mov 0x458(%rbx),%r15
clear_bit(TTY_EXCLUSIVE, &tty->flags);
return 0;
case TIOCGEXCL:
{
int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
return put_user(excl, (int __user *)p);
ffffffff829da4cf: be 31 0b 00 00 mov $0xb31,%esi
ffffffff829da4d4: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da4db: e8 e0 00 bb fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da4e0: 48 8b 8d 30 fe ff ff mov -0x1d0(%rbp),%rcx
ffffffff829da4e7: 49 c1 ef 03 shr $0x3,%r15
GEN_BINARY_RMWcc(LOCK_PREFIX "btc", *addr, "Ir", nr, "%0", "c");
}
static __always_inline int constant_test_bit(long nr, const volatile unsigned long *addr)
{
return ((1UL << (nr & (BITS_PER_LONG-1))) &
ffffffff829da4eb: 41 83 e7 01 and $0x1,%r15d
ffffffff829da4ef: 44 89 f8 mov %r15d,%eax
ffffffff829da4f2: e8 99 eb d1 ff callq ffffffff826f9090 <__put_user_4>
ffffffff829da4f7: 4c 63 f8 movslq %eax,%r15
ffffffff829da4fa: e9 c5 f7 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
* if pty, return the slave side (real_tty)
* otherwise, return self
*/
static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
{
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
ffffffff829da4ff: e8 6c fd c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829da504: e9 2f f6 ff ff jmpq ffffffff829d9b38 <tty_ioctl+0x168>
if (tty->ops->ioctl) {
retval = tty->ops->ioctl(tty, cmd, arg);
if (retval != -ENOIOCTLCMD)
return retval;
}
ld = tty_ldisc_ref_wait(tty);
ffffffff829da509: 48 89 df mov %rbx,%rdi
ffffffff829da50c: e8 2f 72 01 00 callq ffffffff829f1740 <tty_ldisc_ref_wait>
retval = -EINVAL;
if (ld->ops->ioctl) {
ffffffff829da511: 48 89 c2 mov %rax,%rdx
if (tty->ops->ioctl) {
retval = tty->ops->ioctl(tty, cmd, arg);
if (retval != -ENOIOCTLCMD)
return retval;
}
ld = tty_ldisc_ref_wait(tty);
ffffffff829da514: 49 89 c1 mov %rax,%r9
retval = -EINVAL;
if (ld->ops->ioctl) {
ffffffff829da517: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da51e: fc ff df
ffffffff829da521: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da525: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da529: 0f 85 38 12 00 00 jne ffffffff829db767 <tty_ioctl+0x1d97>
ffffffff829da52f: 4d 8b 39 mov (%r9),%r15
ffffffff829da532: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da539: fc ff df
ffffffff829da53c: 49 8d 7f 48 lea 0x48(%r15),%rdi
ffffffff829da540: 48 89 fa mov %rdi,%rdx
ffffffff829da543: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da547: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da54b: 0f 85 fe 11 00 00 jne ffffffff829db74f <tty_ioctl+0x1d7f>
ffffffff829da551: 49 8b 47 48 mov 0x48(%r15),%rax
ffffffff829da555: 49 c7 c7 ea ff ff ff mov $0xffffffffffffffea,%r15
ffffffff829da55c: 48 85 c0 test %rax,%rax
ffffffff829da55f: 74 33 je ffffffff829da594 <tty_ioctl+0xbc4>
ffffffff829da561: 4c 89 8d 28 fe ff ff mov %r9,-0x1d8(%rbp)
retval = ld->ops->ioctl(tty, file, cmd, arg);
ffffffff829da568: 48 8b 8d 30 fe ff ff mov -0x1d0(%rbp),%rcx
ffffffff829da56f: 44 89 f2 mov %r14d,%edx
ffffffff829da572: 4c 89 ee mov %r13,%rsi
ffffffff829da575: 48 89 df mov %rbx,%rdi
ffffffff829da578: ff d0 callq *%rax
ffffffff829da57a: 4c 8b 8d 28 fe ff ff mov -0x1d8(%rbp),%r9
ffffffff829da581: 4c 63 f8 movslq %eax,%r15
ffffffff829da584: 3d fd fd ff ff cmp $0xfffffdfd,%eax
ffffffff829da589: 48 c7 c0 e7 ff ff ff mov $0xffffffffffffffe7,%rax
ffffffff829da590: 4c 0f 44 f8 cmove %rax,%r15
if (retval == -ENOIOCTLCMD)
retval = -ENOTTY;
}
tty_ldisc_deref(ld);
ffffffff829da594: 4c 89 cf mov %r9,%rdi
ffffffff829da597: e8 c4 72 01 00 callq ffffffff829f1860 <tty_ldisc_deref>
return retval;
ffffffff829da59c: e9 23 f7 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
}
/*
* Now do the stuff.
*/
switch (cmd) {
ffffffff829da5a1: 41 81 fe 28 54 00 00 cmp $0x5428,%r14d
ffffffff829da5a8: 0f 84 bb fb ff ff je ffffffff829da169 <tty_ioctl+0x799>
ffffffff829da5ae: 41 81 fe 29 54 00 00 cmp $0x5429,%r14d
ffffffff829da5b5: 0f 85 8a f9 ff ff jne ffffffff829d9f45 <tty_ioctl+0x575>
{
/*
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
ffffffff829da5bb: 4c 39 d3 cmp %r10,%rbx
ffffffff829da5be: 0f 84 09 0c 00 00 je ffffffff829db1cd <tty_ioctl+0x17fd>
return -ENOTTY;
if (!real_tty->session)
ffffffff829da5c4: 49 8d 9a 50 04 00 00 lea 0x450(%r10),%rbx
ffffffff829da5cb: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da5d2: fc ff df
ffffffff829da5d5: 48 89 da mov %rbx,%rdx
ffffffff829da5d8: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da5dc: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da5e0: 0f 85 ea 0f 00 00 jne ffffffff829db5d0 <tty_ioctl+0x1c00>
ffffffff829da5e6: 49 83 ba 50 04 00 00 cmpq $0x0,0x450(%r10)
ffffffff829da5ed: 00
ffffffff829da5ee: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829da5f5: 0f 84 5c 0d 00 00 je ffffffff829db357 <tty_ioctl+0x1987>
return -ENOTTY;
return put_user(pid_vnr(real_tty->session), p);
ffffffff829da5fb: be 45 0a 00 00 mov $0xa45,%esi
ffffffff829da600: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829da607: e8 b4 ff ba fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829da60c: 48 89 da mov %rbx,%rdx
ffffffff829da60f: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da616: fc ff df
ffffffff829da619: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829da620: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da624: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da628: 0f 85 76 0f 00 00 jne ffffffff829db5a4 <tty_ioctl+0x1bd4>
ffffffff829da62e: 49 8b ba 50 04 00 00 mov 0x450(%r10),%rdi
ffffffff829da635: e8 66 d8 8a fe callq ffffffff81287ea0 <pid_vnr>
ffffffff829da63a: 48 8b 8d 30 fe ff ff mov -0x1d0(%rbp),%rcx
ffffffff829da641: e8 4a ea d1 ff callq ffffffff826f9090 <__put_user_4>
ffffffff829da646: e9 63 f9 ff ff jmpq ffffffff829d9fae <tty_ioctl+0x5de>
EXPORT_SYMBOL(tty_unregister_driver);
dev_t tty_devnum(struct tty_struct *tty)
{
return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
ffffffff829da64b: 49 8d 7a 10 lea 0x10(%r10),%rdi
ffffffff829da64f: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da656: fc ff df
ffffffff829da659: 48 89 fa mov %rdi,%rdx
ffffffff829da65c: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da660: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da664: 0f 85 81 0f 00 00 jne ffffffff829db5eb <tty_ioctl+0x1c1b>
ffffffff829da66a: 49 8b 5a 10 mov 0x10(%r10),%rbx
ffffffff829da66e: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da675: fc ff df
ffffffff829da678: 48 8d 7b 2c lea 0x2c(%rbx),%rdi
ffffffff829da67c: 48 89 fa mov %rdi,%rdx
ffffffff829da67f: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da683: 0f b6 14 02 movzbl (%rdx,%rax,1),%edx
ffffffff829da687: 48 89 f8 mov %rdi,%rax
ffffffff829da68a: 83 e0 07 and $0x7,%eax
ffffffff829da68d: 83 c0 03 add $0x3,%eax
ffffffff829da690: 38 d0 cmp %dl,%al
ffffffff829da692: 7c 08 jl ffffffff829da69c <tty_ioctl+0xccc>
ffffffff829da694: 84 d2 test %dl,%dl
ffffffff829da696: 0f 85 67 0f 00 00 jne ffffffff829db603 <tty_ioctl+0x1c33>
ffffffff829da69c: 48 8d 7b 30 lea 0x30(%rbx),%rdi
ffffffff829da6a0: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da6a7: fc ff df
ffffffff829da6aa: 44 8b 6b 2c mov 0x2c(%rbx),%r13d
ffffffff829da6ae: 48 89 f9 mov %rdi,%rcx
ffffffff829da6b1: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829da6b5: 41 c1 e5 14 shl $0x14,%r13d
ffffffff829da6b9: 0f b6 04 01 movzbl (%rcx,%rax,1),%eax
ffffffff829da6bd: 84 c0 test %al,%al
ffffffff829da6bf: 74 08 je ffffffff829da6c9 <tty_ioctl+0xcf9>
ffffffff829da6c1: 3c 03 cmp $0x3,%al
ffffffff829da6c3: 0f 8e 52 0f 00 00 jle ffffffff829db61b <tty_ioctl+0x1c4b>
ffffffff829da6c9: 49 8d 7a 20 lea 0x20(%r10),%rdi
ffffffff829da6cd: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da6d4: fc ff df
ffffffff829da6d7: 44 0b 6b 30 or 0x30(%rbx),%r13d
ffffffff829da6db: 48 89 fa mov %rdi,%rdx
ffffffff829da6de: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da6e2: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffffffff829da6e6: 44 89 eb mov %r13d,%ebx
ffffffff829da6e9: 84 c0 test %al,%al
ffffffff829da6eb: 74 08 je ffffffff829da6f5 <tty_ioctl+0xd25>
ffffffff829da6ed: 3c 03 cmp $0x3,%al
ffffffff829da6ef: 0f 8e 3e 0f 00 00 jle ffffffff829db633 <tty_ioctl+0x1c63>
ffffffff829da6f5: 41 03 5a 20 add 0x20(%r10),%ebx
tty_vhangup(tty);
return 0;
case TIOCGDEV:
{
unsigned int ret = new_encode_dev(tty_devnum(real_tty));
return put_user(ret, (unsigned int __user *)p);
ffffffff829da6f9: be 4c 0b 00 00 mov $0xb4c,%esi
return 1;
}
static inline u32 new_encode_dev(dev_t dev)
{
unsigned major = MAJOR(dev);
ffffffff829da6fe: 41 89 df mov %ebx,%r15d
ffffffff829da701: 41 c1 ef 14 shr $0x14,%r15d
unsigned minor = MINOR(dev);
return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
ffffffff829da705: 44 89 f8 mov %r15d,%eax
ffffffff829da708: 41 89 df mov %ebx,%r15d
ffffffff829da70b: 41 c1 e7 0c shl $0xc,%r15d
ffffffff829da70f: c1 e0 08 shl $0x8,%eax
ffffffff829da712: 41 81 e7 00 00 f0 ff and $0xfff00000,%r15d
ffffffff829da719: 41 09 c7 or %eax,%r15d
ffffffff829da71c: 0f b6 c3 movzbl %bl,%eax
ffffffff829da71f: 41 09 c7 or %eax,%r15d
ffffffff829da722: e9 d8 fc ff ff jmpq ffffffff829da3ff <tty_ioctl+0xa2f>
case TIOCGETD:
return put_user(tty->ldisc->ops->num, (int __user *)p);
case TIOCSETD:
return tiocsetd(tty, p);
case TIOCVHANGUP:
if (!capable(CAP_SYS_ADMIN))
ffffffff829da727: bf 15 00 00 00 mov $0x15,%edi
return -EPERM;
ffffffff829da72c: 49 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%r15
case TIOCGETD:
return put_user(tty->ldisc->ops->num, (int __user *)p);
case TIOCSETD:
return tiocsetd(tty, p);
case TIOCVHANGUP:
if (!capable(CAP_SYS_ADMIN))
ffffffff829da733: e8 18 1b 87 fe callq ffffffff8124c250 <capable>
ffffffff829da738: 84 c0 test %al,%al
ffffffff829da73a: 0f 84 84 f5 ff ff je ffffffff829d9cc4 <tty_ioctl+0x2f4>
*/
void tty_vhangup(struct tty_struct *tty)
{
tty_debug_hangup(tty, "\n");
__tty_hangup(tty, 0);
ffffffff829da740: 31 f6 xor %esi,%esi
ffffffff829da742: 48 89 df mov %rbx,%rdi
return tiocsetd(tty, p);
case TIOCVHANGUP:
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
tty_vhangup(tty);
return 0;
ffffffff829da745: 45 31 ff xor %r15d,%r15d
*/
void tty_vhangup(struct tty_struct *tty)
{
tty_debug_hangup(tty, "\n");
__tty_hangup(tty, 0);
ffffffff829da748: e8 c3 ce ff ff callq ffffffff829d7610 <__tty_hangup>
return tiocsetd(tty, p);
case TIOCVHANGUP:
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
tty_vhangup(tty);
return 0;
ffffffff829da74d: e9 72 f5 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
case TIOCGWINSZ:
return tiocgwinsz(real_tty, p);
case TIOCSWINSZ:
return tiocswinsz(real_tty, p);
case TIOCCONS:
return real_tty != tty ? -EINVAL : tioccons(file);
ffffffff829da752: 4c 39 d3 cmp %r10,%rbx
ffffffff829da755: 0f 85 02 fa ff ff jne ffffffff829da15d <tty_ioctl+0x78d>
* Locking: uses redirect_lock to guard the redirect information
*/
static int tioccons(struct file *file)
{
if (!capable(CAP_SYS_ADMIN))
ffffffff829da75b: bf 15 00 00 00 mov $0x15,%edi
ffffffff829da760: e8 eb 1a 87 fe callq ffffffff8124c250 <capable>
ffffffff829da765: 84 c0 test %al,%al
ffffffff829da767: 0f 84 8f 0b 00 00 je ffffffff829db2fc <tty_ioctl+0x192c>
return -EPERM;
if (file->f_op->write == redirected_tty_write) {
ffffffff829da76d: 49 8d 7d 28 lea 0x28(%r13),%rdi
ffffffff829da771: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da778: fc ff df
ffffffff829da77b: 48 89 fa mov %rdi,%rdx
ffffffff829da77e: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da782: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da786: 0f 85 ab 10 00 00 jne ffffffff829db837 <tty_ioctl+0x1e67>
ffffffff829da78c: 49 8b 5d 28 mov 0x28(%r13),%rbx
ffffffff829da790: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da797: fc ff df
ffffffff829da79a: 48 8d 7b 18 lea 0x18(%rbx),%rdi
ffffffff829da79e: 48 89 fa mov %rdi,%rdx
ffffffff829da7a1: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da7a5: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da7a9: 0f 85 7e 10 00 00 jne ffffffff829db82d <tty_ioctl+0x1e5d>
ffffffff829da7af: 48 81 7b 18 80 8e 9d cmpq $0xffffffff829d8e80,0x18(%rbx)
ffffffff829da7b6: 82
raw_spin_lock_init(&(_lock)->rlock); \
} while (0)
static __always_inline void spin_lock(spinlock_t *lock)
{
raw_spin_lock(&lock->rlock);
ffffffff829da7b7: 48 c7 c7 60 7f 3d 86 mov $0xffffffff863d7f60,%rdi
ffffffff829da7be: 0f 84 8c 0a 00 00 je ffffffff829db250 <tty_ioctl+0x1880>
ffffffff829da7c4: e8 b7 c4 8c 02 callq ffffffff852a6c80 <_raw_spin_lock>
if (f)
fput(f);
return 0;
}
spin_lock(&redirect_lock);
if (redirect) {
ffffffff829da7c9: 48 83 3d cf 0b f7 04 cmpq $0x0,0x4f70bcf(%rip) # ffffffff8794b3a0 <redirect>
ffffffff829da7d0: 00
ffffffff829da7d1: 0f 85 61 0a 00 00 jne ffffffff829db238 <tty_ioctl+0x1868>
*
* Atomically increments @v by 1.
*/
static __always_inline void atomic64_inc(atomic64_t *v)
{
asm volatile(LOCK_PREFIX "incq %0"
ffffffff829da7d7: f0 49 ff 45 68 lock incq 0x68(%r13)
raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
} while (0)
static __always_inline void spin_unlock(spinlock_t *lock)
{
raw_spin_unlock(&lock->rlock);
ffffffff829da7dc: 48 c7 c7 60 7f 3d 86 mov $0xffffffff863d7f60,%rdi
spin_unlock(&redirect_lock);
return -EBUSY;
}
redirect = get_file(file);
ffffffff829da7e3: 4c 89 2d b6 0b f7 04 mov %r13,0x4f70bb6(%rip) # ffffffff8794b3a0 <redirect>
ffffffff829da7ea: 45 31 ff xor %r15d,%r15d
ffffffff829da7ed: e8 6e c7 8c 02 callq ffffffff852a6f60 <_raw_spin_unlock>
ffffffff829da7f2: e9 cd f4 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
}
/*
* Break handling
*/
case TIOCSBRK: /* Turn break on, unconditionally */
if (tty->ops->break_ctl)
ffffffff829da7f7: 48 8d 7b 18 lea 0x18(%rbx),%rdi
ffffffff829da7fb: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da802: fc ff df
ffffffff829da805: 48 89 fa mov %rdi,%rdx
ffffffff829da808: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da80c: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da810: 0f 85 95 10 00 00 jne ffffffff829db8ab <tty_ioctl+0x1edb>
ffffffff829da816: 4c 8b 6b 18 mov 0x18(%rbx),%r13
ffffffff829da81a: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da821: fc ff df
ffffffff829da824: 49 8d bd a0 00 00 00 lea 0xa0(%r13),%rdi
ffffffff829da82b: 48 89 fa mov %rdi,%rdx
ffffffff829da82e: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da832: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da836: 0f 85 65 10 00 00 jne ffffffff829db8a1 <tty_ioctl+0x1ed1>
ffffffff829da83c: 49 8b 85 a0 00 00 00 mov 0xa0(%r13),%rax
ffffffff829da843: 48 85 c0 test %rax,%rax
ffffffff829da846: 0f 84 16 fa ff ff je ffffffff829da262 <tty_ioctl+0x892>
return tty->ops->break_ctl(tty, -1);
ffffffff829da84c: be ff ff ff ff mov $0xffffffff,%esi
ffffffff829da851: 48 89 df mov %rbx,%rdi
ffffffff829da854: ff d0 callq *%rax
ffffffff829da856: 4c 63 f8 movslq %eax,%r15
ffffffff829da859: e9 66 f4 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
ffffffff829da85e: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829da865: 01 00
{
unsigned long flags;
struct pid *pgrp, *tty_pgrp;
int ret = 0;
if (current->signal->tty != tty)
ffffffff829da867: 49 8d be 48 06 00 00 lea 0x648(%r14),%rdi
ffffffff829da86e: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da875: fc ff df
ffffffff829da878: 48 89 fa mov %rdi,%rdx
ffffffff829da87b: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da87f: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da883: 0f 85 00 10 00 00 jne ffffffff829db889 <tty_ioctl+0x1eb9>
ffffffff829da889: 4d 8b b6 48 06 00 00 mov 0x648(%r14),%r14
ffffffff829da890: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da897: fc ff df
ffffffff829da89a: 49 8d be d0 01 00 00 lea 0x1d0(%r14),%rdi
ffffffff829da8a1: 48 89 fa mov %rdi,%rdx
ffffffff829da8a4: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da8a8: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da8ac: 0f 85 bf 0f 00 00 jne ffffffff829db871 <tty_ioctl+0x1ea1>
ffffffff829da8b2: 4d 3b 96 d0 01 00 00 cmp 0x1d0(%r14),%r10
ffffffff829da8b9: 0f 84 cd 09 00 00 je ffffffff829db28c <tty_ioctl+0x18bc>
ffffffff829da8bf: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829da8c6: 01 00
if (retval == -EIO)
return -ENOTTY;
if (retval)
return retval;
if (!current->signal->tty ||
ffffffff829da8c8: 49 8d be 48 06 00 00 lea 0x648(%r14),%rdi
ffffffff829da8cf: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da8d6: fc ff df
ffffffff829da8d9: 48 89 fa mov %rdi,%rdx
ffffffff829da8dc: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da8e0: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da8e4: 0f 85 27 10 00 00 jne ffffffff829db911 <tty_ioctl+0x1f41>
ffffffff829da8ea: 4d 8b b6 48 06 00 00 mov 0x648(%r14),%r14
ffffffff829da8f1: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da8f8: fc ff df
ffffffff829da8fb: 49 8d be d0 01 00 00 lea 0x1d0(%r14),%rdi
ffffffff829da902: 48 89 fa mov %rdi,%rdx
ffffffff829da905: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da909: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da90d: 0f 85 e6 0f 00 00 jne ffffffff829db8f9 <tty_ioctl+0x1f29>
ffffffff829da913: 49 83 be d0 01 00 00 cmpq $0x0,0x1d0(%r14)
ffffffff829da91a: 00
ffffffff829da91b: 0f 84 dc 07 00 00 je ffffffff829db0fd <tty_ioctl+0x172d>
ffffffff829da921: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829da928: 01 00
(current->signal->tty != real_tty) ||
ffffffff829da92a: 49 8d be 48 06 00 00 lea 0x648(%r14),%rdi
ffffffff829da931: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da938: fc ff df
ffffffff829da93b: 48 89 fa mov %rdi,%rdx
ffffffff829da93e: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da942: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da946: 0f 85 eb 0b 00 00 jne ffffffff829db537 <tty_ioctl+0x1b67>
ffffffff829da94c: 4d 8b b6 48 06 00 00 mov 0x648(%r14),%r14
ffffffff829da953: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da95a: fc ff df
ffffffff829da95d: 49 8d be d0 01 00 00 lea 0x1d0(%r14),%rdi
ffffffff829da964: 48 89 fa mov %rdi,%rdx
ffffffff829da967: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da96b: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da96f: 0f 85 f2 0b 00 00 jne ffffffff829db567 <tty_ioctl+0x1b97>
if (retval == -EIO)
return -ENOTTY;
if (retval)
return retval;
if (!current->signal->tty ||
ffffffff829da975: 4d 3b 96 d0 01 00 00 cmp 0x1d0(%r14),%r10
ffffffff829da97c: 0f 85 7b 07 00 00 jne ffffffff829db0fd <tty_ioctl+0x172d>
(current->signal->tty != real_tty) ||
(real_tty->session != task_session(current)))
ffffffff829da982: 49 8d ba 50 04 00 00 lea 0x450(%r10),%rdi
ffffffff829da989: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da990: fc ff df
ffffffff829da993: 48 89 fa mov %rdi,%rdx
ffffffff829da996: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da99a: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da99e: 0f 85 ab 0b 00 00 jne ffffffff829db54f <tty_ioctl+0x1b7f>
ffffffff829da9a4: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829da9ab: 01 00
return task->group_leader->pids[PIDTYPE_PGID].pid;
}
static inline struct pid *task_session(struct task_struct *task)
{
return task->group_leader->pids[PIDTYPE_SID].pid;
ffffffff829da9ad: 49 8d be 60 04 00 00 lea 0x460(%r14),%rdi
ffffffff829da9b4: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da9bb: fc ff df
ffffffff829da9be: 4d 8b ba 50 04 00 00 mov 0x450(%r10),%r15
ffffffff829da9c5: 48 89 fa mov %rdi,%rdx
ffffffff829da9c8: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da9cc: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da9d0: 0f 85 54 0a 00 00 jne ffffffff829db42a <tty_ioctl+0x1a5a>
ffffffff829da9d6: 4d 8b b6 60 04 00 00 mov 0x460(%r14),%r14
ffffffff829da9dd: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829da9e4: fc ff df
ffffffff829da9e7: 49 8d be c8 04 00 00 lea 0x4c8(%r14),%rdi
ffffffff829da9ee: 48 89 fa mov %rdi,%rdx
ffffffff829da9f1: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829da9f5: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829da9f9: 0f 85 13 0a 00 00 jne ffffffff829db412 <tty_ioctl+0x1a42>
if (retval == -EIO)
return -ENOTTY;
if (retval)
return retval;
if (!current->signal->tty ||
(current->signal->tty != real_tty) ||
ffffffff829da9ff: 4d 3b be c8 04 00 00 cmp 0x4c8(%r14),%r15
ffffffff829daa06: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829daa0d: 0f 85 ea 06 00 00 jne ffffffff829db0fd <tty_ioctl+0x172d>
(real_tty->session != task_session(current)))
return -ENOTTY;
if (get_user(pgrp_nr, p))
ffffffff829daa13: be 19 0a 00 00 mov $0xa19,%esi
ffffffff829daa18: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829daa1f: e8 9c fb ba fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829daa24: 48 8b 85 30 fe ff ff mov -0x1d0(%rbp),%rax
ffffffff829daa2b: e8 60 9f d1 ff callq ffffffff826f4990 <__get_user_4>
ffffffff829daa30: 85 c0 test %eax,%eax
ffffffff829daa32: 49 89 d6 mov %rdx,%r14
ffffffff829daa35: 49 c7 c7 f2 ff ff ff mov $0xfffffffffffffff2,%r15
ffffffff829daa3c: 0f 85 82 f2 ff ff jne ffffffff829d9cc4 <tty_ioctl+0x2f4>
return -EFAULT;
if (pgrp_nr < 0)
ffffffff829daa42: 85 d2 test %edx,%edx
ffffffff829daa44: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829daa4b: 0f 88 0c f7 ff ff js ffffffff829da15d <tty_ioctl+0x78d>
#ifdef CONFIG_DEBUG_LOCK_ALLOC
static inline void rcu_lock_acquire(struct lockdep_map *map)
{
lock_acquire(map, 0, 0, 2, 0, NULL, _THIS_IP_);
ffffffff829daa51: 45 31 c9 xor %r9d,%r9d
ffffffff829daa54: 45 31 c0 xor %r8d,%r8d
ffffffff829daa57: 31 d2 xor %edx,%edx
ffffffff829daa59: 31 f6 xor %esi,%esi
ffffffff829daa5b: b9 02 00 00 00 mov $0x2,%ecx
ffffffff829daa60: 48 c7 c7 80 23 11 86 mov $0xffffffff86112380,%rdi
ffffffff829daa67: 48 c7 04 24 51 aa 9d movq $0xffffffff829daa51,(%rsp)
ffffffff829daa6e: 82
ffffffff829daa6f: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
ffffffff829daa76: e8 95 b2 95 fe callq ffffffff81335d10 <lock_acquire>
static inline void rcu_read_lock(void)
{
__rcu_read_lock();
__acquire(RCU);
rcu_lock_acquire(&rcu_lock_map);
RCU_LOCKDEP_WARN(!rcu_is_watching(),
ffffffff829daa7b: e8 90 c4 99 fe callq ffffffff81376f10 <debug_lockdep_rcu_enabled>
ffffffff829daa80: 85 c0 test %eax,%eax
ffffffff829daa82: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829daa89: 74 0d je ffffffff829daa98 <tty_ioctl+0x10c8>
ffffffff829daa8b: 80 3d 02 11 f9 03 00 cmpb $0x0,0x3f91102(%rip) # ffffffff8696bb94 <__warned.9527>
ffffffff829daa92: 0f 84 25 08 00 00 je ffffffff829db2bd <tty_ioctl+0x18ed>
return -EINVAL;
rcu_read_lock();
pgrp = find_vpid(pgrp_nr);
ffffffff829daa98: 44 89 f7 mov %r14d,%edi
ffffffff829daa9b: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
retval = -ESRCH;
if (!pgrp)
ffffffff829daaa2: 49 c7 c7 fd ff ff ff mov $0xfffffffffffffffd,%r15
if (get_user(pgrp_nr, p))
return -EFAULT;
if (pgrp_nr < 0)
return -EINVAL;
rcu_read_lock();
pgrp = find_vpid(pgrp_nr);
ffffffff829daaa9: e8 d2 da 8a fe callq ffffffff81288580 <find_vpid>
retval = -ESRCH;
if (!pgrp)
ffffffff829daaae: 48 85 c0 test %rax,%rax
if (get_user(pgrp_nr, p))
return -EFAULT;
if (pgrp_nr < 0)
return -EINVAL;
rcu_read_lock();
pgrp = find_vpid(pgrp_nr);
ffffffff829daab1: 49 89 c5 mov %rax,%r13
retval = -ESRCH;
if (!pgrp)
ffffffff829daab4: 0f 84 d7 00 00 00 je ffffffff829dab91 <tty_ioctl+0x11c1>
static struct pid *session_of_pgrp(struct pid *pgrp)
{
struct task_struct *p;
struct pid *sid = NULL;
p = pid_task(pgrp, PIDTYPE_PGID);
ffffffff829daaba: be 01 00 00 00 mov $0x1,%esi
ffffffff829daabf: 48 89 c7 mov %rax,%rdi
ffffffff829daac2: e8 99 db 8a fe callq ffffffff81288660 <pid_task>
if (p == NULL)
ffffffff829daac7: 48 85 c0 test %rax,%rax
ffffffff829daaca: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829daad1: 0f 84 1a 09 00 00 je ffffffff829db3f1 <tty_ioctl+0x1a21>
ffffffff829daad7: 48 8d b8 60 04 00 00 lea 0x460(%rax),%rdi
ffffffff829daade: 48 ba 00 00 00 00 00 movabs $0xdffffc0000000000,%rdx
ffffffff829daae5: fc ff df
ffffffff829daae8: 48 89 f9 mov %rdi,%rcx
ffffffff829daaeb: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829daaef: 80 3c 11 00 cmpb $0x0,(%rcx,%rdx,1)
ffffffff829daaf3: 0f 85 6f 09 00 00 jne ffffffff829db468 <tty_ioctl+0x1a98>
ffffffff829daaf9: 4c 8b b0 60 04 00 00 mov 0x460(%rax),%r14
ffffffff829dab00: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dab07: fc ff df
ffffffff829dab0a: 49 8d be c8 04 00 00 lea 0x4c8(%r14),%rdi
ffffffff829dab11: 48 89 fa mov %rdi,%rdx
ffffffff829dab14: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dab18: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dab1c: 0f 85 92 09 00 00 jne ffffffff829db4b4 <tty_ioctl+0x1ae4>
ffffffff829dab22: 49 8b 86 c8 04 00 00 mov 0x4c8(%r14),%rax
ffffffff829dab29: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829dab30: 01 00
ffffffff829dab32: 49 8d be 60 04 00 00 lea 0x460(%r14),%rdi
ffffffff829dab39: 48 ba 00 00 00 00 00 movabs $0xdffffc0000000000,%rdx
ffffffff829dab40: fc ff df
ffffffff829dab43: 48 89 f9 mov %rdi,%rcx
ffffffff829dab46: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829dab4a: 80 3c 11 00 cmpb $0x0,(%rcx,%rdx,1)
ffffffff829dab4e: 0f 85 3a 09 00 00 jne ffffffff829db48e <tty_ioctl+0x1abe>
ffffffff829dab54: 4d 8b b6 60 04 00 00 mov 0x460(%r14),%r14
ffffffff829dab5b: 48 ba 00 00 00 00 00 movabs $0xdffffc0000000000,%rdx
ffffffff829dab62: fc ff df
ffffffff829dab65: 49 8d be c8 04 00 00 lea 0x4c8(%r14),%rdi
ffffffff829dab6c: 48 89 f9 mov %rdi,%rcx
ffffffff829dab6f: 48 c1 e9 03 shr $0x3,%rcx
ffffffff829dab73: 80 3c 11 00 cmpb $0x0,(%rcx,%rdx,1)
ffffffff829dab77: 0f 85 c5 08 00 00 jne ffffffff829db442 <tty_ioctl+0x1a72>
pgrp = find_vpid(pgrp_nr);
retval = -ESRCH;
if (!pgrp)
goto out_unlock;
retval = -EPERM;
if (session_of_pgrp(pgrp) != task_session(current))
ffffffff829dab7d: 49 39 86 c8 04 00 00 cmp %rax,0x4c8(%r14)
ffffffff829dab84: 49 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%r15
ffffffff829dab8b: 0f 84 d0 07 00 00 je ffffffff829db361 <tty_ioctl+0x1991>
*
* See rcu_read_lock() for more information.
*/
static inline void rcu_read_unlock(void)
{
RCU_LOCKDEP_WARN(!rcu_is_watching(),
ffffffff829dab91: e8 7a c3 99 fe callq ffffffff81376f10 <debug_lockdep_rcu_enabled>
ffffffff829dab96: 85 c0 test %eax,%eax
ffffffff829dab98: 74 0d je ffffffff829daba7 <tty_ioctl+0x11d7>
ffffffff829dab9a: 80 3d f2 0f f9 03 00 cmpb $0x0,0x3f90ff2(%rip) # ffffffff8696bb93 <__warned.9531>
ffffffff829daba1: 0f 84 75 07 00 00 je ffffffff829db31c <tty_ioctl+0x194c>
lock_acquire(map, 0, 0, 2, 0, NULL, _THIS_IP_);
}
static inline void rcu_lock_release(struct lockdep_map *map)
{
lock_release(map, 1, _THIS_IP_);
ffffffff829daba7: 48 c7 c2 a7 ab 9d 82 mov $0xffffffff829daba7,%rdx
ffffffff829dabae: be 01 00 00 00 mov $0x1,%esi
ffffffff829dabb3: 48 c7 c7 80 23 11 86 mov $0xffffffff86112380,%rdi
ffffffff829dabba: e8 91 b5 95 fe callq ffffffff81336150 <lock_release>
ffffffff829dabbf: e9 00 f1 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
static int tiocsctty(struct tty_struct *tty, struct file *file, int arg)
{
int ret = 0;
tty_lock(tty);
ffffffff829dabc4: 48 89 df mov %rbx,%rdi
ffffffff829dabc7: e8 74 ca 8c 02 callq ffffffff852a7640 <tty_lock>
read_lock(&tasklist_lock);
ffffffff829dabcc: 48 c7 c7 80 50 04 86 mov $0xffffffff86045080,%rdi
ffffffff829dabd3: e8 98 c4 8c 02 callq ffffffff852a7070 <_raw_read_lock>
ffffffff829dabd8: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829dabdf: 01 00
if (current->signal->leader && (task_session(current) == tty->session))
ffffffff829dabe1: 49 8d be 48 06 00 00 lea 0x648(%r14),%rdi
ffffffff829dabe8: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dabef: fc ff df
ffffffff829dabf2: 48 89 fa mov %rdi,%rdx
ffffffff829dabf5: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dabf9: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dabfd: 0f 85 ee 0b 00 00 jne ffffffff829db7f1 <tty_ioctl+0x1e21>
ffffffff829dac03: 4d 8b b6 48 06 00 00 mov 0x648(%r14),%r14
ffffffff829dac0a: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dac11: fc ff df
ffffffff829dac14: 49 8d be c8 01 00 00 lea 0x1c8(%r14),%rdi
ffffffff829dac1b: 48 89 fa mov %rdi,%rdx
ffffffff829dac1e: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dac22: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffffffff829dac26: 84 c0 test %al,%al
ffffffff829dac28: 74 08 je ffffffff829dac32 <tty_ioctl+0x1262>
ffffffff829dac2a: 3c 03 cmp $0x3,%al
ffffffff829dac2c: 0f 8e c9 0b 00 00 jle ffffffff829db7fb <tty_ioctl+0x1e2b>
ffffffff829dac32: 41 8b 96 c8 01 00 00 mov 0x1c8(%r14),%edx
ffffffff829dac39: 85 d2 test %edx,%edx
ffffffff829dac3b: 0f 84 8a 00 00 00 je ffffffff829daccb <tty_ioctl+0x12fb>
ffffffff829dac41: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829dac48: 01 00
ffffffff829dac4a: 49 8d be 60 04 00 00 lea 0x460(%r14),%rdi
ffffffff829dac51: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dac58: fc ff df
ffffffff829dac5b: 48 89 fa mov %rdi,%rdx
ffffffff829dac5e: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dac62: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dac66: 0f 85 b4 08 00 00 jne ffffffff829db520 <tty_ioctl+0x1b50>
ffffffff829dac6c: 4d 8b b6 60 04 00 00 mov 0x460(%r14),%r14
ffffffff829dac73: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dac7a: fc ff df
ffffffff829dac7d: 49 8d be c8 04 00 00 lea 0x4c8(%r14),%rdi
ffffffff829dac84: 48 89 fa mov %rdi,%rdx
ffffffff829dac87: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dac8b: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dac8f: 0f 85 81 08 00 00 jne ffffffff829db516 <tty_ioctl+0x1b46>
ffffffff829dac95: 48 8d bb 50 04 00 00 lea 0x450(%rbx),%rdi
ffffffff829dac9c: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829daca3: fc ff df
ffffffff829daca6: 4d 8b b6 c8 04 00 00 mov 0x4c8(%r14),%r14
ffffffff829dacad: 48 89 fa mov %rdi,%rdx
ffffffff829dacb0: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dacb4: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dacb8: 0f 85 4e 08 00 00 jne ffffffff829db50c <tty_ioctl+0x1b3c>
ffffffff829dacbe: 4c 3b b3 50 04 00 00 cmp 0x450(%rbx),%r14
ffffffff829dacc5: 0f 84 3d 06 00 00 je ffffffff829db308 <tty_ioctl+0x1938>
ffffffff829daccb: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829dacd2: 01 00
/*
* The process must be a session leader and
* not have a controlling tty already.
*/
if (!current->signal->leader || current->signal->tty) {
ffffffff829dacd4: 49 8d be 48 06 00 00 lea 0x648(%r14),%rdi
ffffffff829dacdb: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dace2: fc ff df
ffffffff829dace5: 48 89 fa mov %rdi,%rdx
ffffffff829dace8: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dacec: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dacf0: 0f 85 e7 0a 00 00 jne ffffffff829db7dd <tty_ioctl+0x1e0d>
ffffffff829dacf6: 4d 8b b6 48 06 00 00 mov 0x648(%r14),%r14
ffffffff829dacfd: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dad04: fc ff df
ffffffff829dad07: 49 8d be c8 01 00 00 lea 0x1c8(%r14),%rdi
ffffffff829dad0e: 48 89 fa mov %rdi,%rdx
ffffffff829dad11: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dad15: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffffffff829dad19: 84 c0 test %al,%al
ffffffff829dad1b: 74 08 je ffffffff829dad25 <tty_ioctl+0x1355>
ffffffff829dad1d: 3c 03 cmp $0x3,%al
ffffffff829dad1f: 0f 8e c2 0a 00 00 jle ffffffff829db7e7 <tty_ioctl+0x1e17>
ffffffff829dad25: 41 8b 86 c8 01 00 00 mov 0x1c8(%r14),%eax
ffffffff829dad2c: 85 c0 test %eax,%eax
ffffffff829dad2e: 0f 84 bd 03 00 00 je ffffffff829db0f1 <tty_ioctl+0x1721>
ffffffff829dad34: 65 4c 8b 34 25 c0 3f mov %gs:0x13fc0,%r14
ffffffff829dad3b: 01 00
ffffffff829dad3d: 49 8d be 48 06 00 00 lea 0x648(%r14),%rdi
ffffffff829dad44: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dad4b: fc ff df
ffffffff829dad4e: 48 89 fa mov %rdi,%rdx
ffffffff829dad51: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dad55: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dad59: 0f 85 e8 0b 00 00 jne ffffffff829db947 <tty_ioctl+0x1f77>
ffffffff829dad5f: 4d 8b b6 48 06 00 00 mov 0x648(%r14),%r14
ffffffff829dad66: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dad6d: fc ff df
ffffffff829dad70: 49 8d be d0 01 00 00 lea 0x1d0(%r14),%rdi
ffffffff829dad77: 48 89 fa mov %rdi,%rdx
ffffffff829dad7a: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dad7e: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dad82: 0f 85 b5 0b 00 00 jne ffffffff829db93d <tty_ioctl+0x1f6d>
ffffffff829dad88: 49 83 be d0 01 00 00 cmpq $0x0,0x1d0(%r14)
ffffffff829dad8f: 00
ffffffff829dad90: 0f 85 5b 03 00 00 jne ffffffff829db0f1 <tty_ioctl+0x1721>
ret = -EPERM;
goto unlock;
}
if (tty->session) {
ffffffff829dad96: 4c 8d b3 50 04 00 00 lea 0x450(%rbx),%r14
ffffffff829dad9d: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dada4: fc ff df
ffffffff829dada7: 4c 89 f2 mov %r14,%rdx
ffffffff829dadaa: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dadae: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dadb2: 0f 85 01 09 00 00 jne ffffffff829db6b9 <tty_ioctl+0x1ce9>
ffffffff829dadb8: 48 83 bb 50 04 00 00 cmpq $0x0,0x450(%rbx)
ffffffff829dadbf: 00
ffffffff829dadc0: 74 46 je ffffffff829dae08 <tty_ioctl+0x1438>
/*
* This tty is already the controlling
* tty for another session group!
*/
if (arg == 1 && capable(CAP_SYS_ADMIN)) {
ffffffff829dadc2: 83 bd 30 fe ff ff 01 cmpl $0x1,-0x1d0(%rbp)
ffffffff829dadc9: 0f 85 22 03 00 00 jne ffffffff829db0f1 <tty_ioctl+0x1721>
ffffffff829dadcf: bf 15 00 00 00 mov $0x15,%edi
ffffffff829dadd4: e8 77 14 87 fe callq ffffffff8124c250 <capable>
ffffffff829dadd9: 84 c0 test %al,%al
ffffffff829daddb: 0f 84 10 03 00 00 je ffffffff829db0f1 <tty_ioctl+0x1721>
/*
* Steal it away
*/
session_clear_tty(tty->session);
ffffffff829dade1: 4c 89 f2 mov %r14,%rdx
ffffffff829dade4: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dadeb: fc ff df
ffffffff829dadee: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dadf2: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dadf6: 0f 85 2e 07 00 00 jne ffffffff829db52a <tty_ioctl+0x1b5a>
ffffffff829dadfc: 48 8b bb 50 04 00 00 mov 0x450(%rbx),%rdi
ffffffff829dae03: e8 08 e3 ff ff callq ffffffff829d9110 <session_clear_tty>
goto unlock;
}
}
/* See the comment in tty_open(). */
if ((file->f_mode & FMODE_READ) == 0 && !capable(CAP_SYS_ADMIN)) {
ffffffff829dae08: 49 8d 7d 74 lea 0x74(%r13),%rdi
ffffffff829dae0c: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dae13: fc ff df
ffffffff829dae16: 48 89 fa mov %rdi,%rdx
ffffffff829dae19: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dae1d: 0f b6 14 02 movzbl (%rdx,%rax,1),%edx
ffffffff829dae21: 48 89 f8 mov %rdi,%rax
ffffffff829dae24: 83 e0 07 and $0x7,%eax
ffffffff829dae27: 83 c0 03 add $0x3,%eax
ffffffff829dae2a: 38 d0 cmp %dl,%al
ffffffff829dae2c: 7c 08 jl ffffffff829dae36 <tty_ioctl+0x1466>
ffffffff829dae2e: 84 d2 test %dl,%dl
ffffffff829dae30: 0f 85 90 08 00 00 jne ffffffff829db6c6 <tty_ioctl+0x1cf6>
ffffffff829dae36: 41 f6 45 74 01 testb $0x1,0x74(%r13)
ffffffff829dae3b: 75 12 jne ffffffff829dae4f <tty_ioctl+0x147f>
ffffffff829dae3d: bf 15 00 00 00 mov $0x15,%edi
ffffffff829dae42: e8 09 14 87 fe callq ffffffff8124c250 <capable>
ffffffff829dae47: 84 c0 test %al,%al
ffffffff829dae49: 0f 84 a2 02 00 00 je ffffffff829db0f1 <tty_ioctl+0x1721>
ffffffff829dae4f: 65 4c 8b 2c 25 c0 3f mov %gs:0x13fc0,%r13
ffffffff829dae56: 01 00
current->signal->tty_old_pgrp = NULL;
}
static void proc_set_tty(struct tty_struct *tty)
{
spin_lock_irq(&current->sighand->siglock);
ffffffff829dae58: 49 8d bd 50 06 00 00 lea 0x650(%r13),%rdi
ffffffff829dae5f: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dae66: fc ff df
ffffffff829dae69: 48 89 fa mov %rdi,%rdx
ffffffff829dae6c: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dae70: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dae74: 0f 85 75 0a 00 00 jne ffffffff829db8ef <tty_ioctl+0x1f1f>
raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \
} while (0)
static __always_inline void spin_lock_irq(spinlock_t *lock)
{
raw_spin_lock_irq(&lock->rlock);
ffffffff829dae7a: 49 8b bd 50 06 00 00 mov 0x650(%r13),%rdi
ffffffff829dae81: 65 4c 8b 2c 25 c0 3f mov %gs:0x13fc0,%r13
ffffffff829dae88: 01 00
ffffffff829dae8a: 48 81 c7 08 08 00 00 add $0x808,%rdi
ffffffff829dae91: e8 5a bf 8c 02 callq ffffffff852a6df0 <_raw_spin_lock_irq>
__proc_set_tty(tty);
ffffffff829dae96: 48 89 df mov %rbx,%rdi
ffffffff829dae99: e8 52 b6 ff ff callq ffffffff829d64f0 <__proc_set_tty>
spin_unlock_irq(&current->sighand->siglock);
ffffffff829dae9e: 49 8d bd 50 06 00 00 lea 0x650(%r13),%rdi
ffffffff829daea5: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829daeac: fc ff df
ffffffff829daeaf: 48 89 fa mov %rdi,%rdx
ffffffff829daeb2: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829daeb6: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829daeba: 0f 85 25 0a 00 00 jne ffffffff829db8e5 <tty_ioctl+0x1f15>
raw_spin_unlock_bh(&lock->rlock);
}
static __always_inline void spin_unlock_irq(spinlock_t *lock)
{
raw_spin_unlock_irq(&lock->rlock);
ffffffff829daec0: 49 8b bd 50 06 00 00 mov 0x650(%r13),%rdi
ffffffff829daec7: 45 31 ff xor %r15d,%r15d
ffffffff829daeca: 48 81 c7 08 08 00 00 add $0x808,%rdi
ffffffff829daed1: e8 fa c0 8c 02 callq ffffffff852a6fd0 <_raw_spin_unlock_irq>
goto unlock;
}
proc_set_tty(tty);
unlock:
read_unlock(&tasklist_lock);
ffffffff829daed6: 48 c7 c7 80 50 04 86 mov $0xffffffff86045080,%rdi
ffffffff829daedd: e8 ee c3 8c 02 callq ffffffff852a72d0 <_raw_read_unlock>
tty_unlock(tty);
ffffffff829daee2: 48 89 df mov %rbx,%rdi
ffffffff829daee5: e8 06 c8 8c 02 callq ffffffff852a76f0 <tty_unlock>
if (current->signal->tty != tty)
return -ENOTTY;
no_tty();
return 0;
case TIOCSCTTY:
return tiocsctty(tty, file, arg);
ffffffff829daeea: e9 d5 ed ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
*/
static __always_inline void
set_bit(long nr, volatile unsigned long *addr)
{
if (IS_IMMEDIATE(nr)) {
asm volatile(LOCK_PREFIX "orb %1,%0"
ffffffff829daeef: f0 80 8b 58 04 00 00 lock orb $0x8,0x458(%rbx)
ffffffff829daef6: 08
return real_tty != tty ? -EINVAL : tioccons(file);
case FIONBIO:
return fionbio(file, p);
case TIOCEXCL:
set_bit(TTY_EXCLUSIVE, &tty->flags);
return 0;
ffffffff829daef7: 45 31 ff xor %r15d,%r15d
ffffffff829daefa: e9 c5 ed ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
static inline unsigned long __must_check
copy_from_user(void *to, const void __user *from, unsigned long n)
{
int sz = __compiletime_object_size(to);
might_fault();
ffffffff829daeff: be b9 02 00 00 mov $0x2b9,%esi
ffffffff829daf04: 48 c7 c7 c0 24 61 85 mov $0xffffffff856124c0,%rdi
ffffffff829daf0b: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
* Therefore limit the compile time checking to the constant size
* case, and do only runtime checking for non-constant sizes.
*/
if (likely(sz < 0 || sz >= n))
n = _copy_from_user(to, from, n);
ffffffff829daf12: 48 8d 9d d8 fe ff ff lea -0x128(%rbp),%rbx
static inline unsigned long __must_check
copy_from_user(void *to, const void __user *from, unsigned long n)
{
int sz = __compiletime_object_size(to);
might_fault();
ffffffff829daf19: e8 a2 f6 ba fe callq ffffffff8158a5c0 <__might_fault>
* Therefore limit the compile time checking to the constant size
* case, and do only runtime checking for non-constant sizes.
*/
if (likely(sz < 0 || sz >= n))
n = _copy_from_user(to, from, n);
ffffffff829daf1e: 48 8b b5 30 fe ff ff mov -0x1d0(%rbp),%rsi
ffffffff829daf25: ba 08 00 00 00 mov $0x8,%edx
ffffffff829daf2a: 48 89 df mov %rbx,%rdi
ffffffff829daf2d: e8 7e 92 d1 ff callq ffffffff826f41b0 <_copy_from_user>
*/
static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
{
struct winsize tmp_ws;
if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
ffffffff829daf32: 48 85 c0 test %rax,%rax
ffffffff829daf35: 0f 85 d5 03 00 00 jne ffffffff829db310 <tty_ioctl+0x1940>
return -EFAULT;
if (tty->ops->resize)
ffffffff829daf3b: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829daf42: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829daf49: fc ff df
ffffffff829daf4c: 49 8d 7a 18 lea 0x18(%r10),%rdi
ffffffff829daf50: 48 89 fa mov %rdi,%rdx
ffffffff829daf53: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829daf57: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829daf5b: 0f 85 93 05 00 00 jne ffffffff829db4f4 <tty_ioctl+0x1b24>
ffffffff829daf61: 4d 8b 6a 18 mov 0x18(%r10),%r13
ffffffff829daf65: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829daf6c: fc ff df
ffffffff829daf6f: 49 8d bd d8 00 00 00 lea 0xd8(%r13),%rdi
ffffffff829daf76: 48 89 fa mov %rdi,%rdx
ffffffff829daf79: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829daf7d: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829daf81: 0f 85 31 06 00 00 jne ffffffff829db5b8 <tty_ioctl+0x1be8>
ffffffff829daf87: 49 8b 85 d8 00 00 00 mov 0xd8(%r13),%rax
return tty->ops->resize(tty, &tmp_ws);
ffffffff829daf8e: 48 89 de mov %rbx,%rsi
ffffffff829daf91: 4c 89 d7 mov %r10,%rdi
{
struct winsize tmp_ws;
if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
return -EFAULT;
if (tty->ops->resize)
ffffffff829daf94: 48 85 c0 test %rax,%rax
ffffffff829daf97: 0f 84 23 02 00 00 je ffffffff829db1c0 <tty_ioctl+0x17f0>
return tty->ops->resize(tty, &tmp_ws);
ffffffff829daf9d: ff d0 callq *%rax
ffffffff829daf9f: 4c 63 f8 movslq %eax,%r15
ffffffff829dafa2: e9 1d ed ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
case TIOCSPGRP:
return tiocspgrp(tty, real_tty, p);
case TIOCGSID:
return tiocgsid(tty, real_tty, p);
case TIOCGETD:
return put_user(tty->ldisc->ops->num, (int __user *)p);
ffffffff829dafa7: 48 c7 c7 e0 1d 61 85 mov $0xffffffff85611de0,%rdi
ffffffff829dafae: be 41 0b 00 00 mov $0xb41,%esi
ffffffff829dafb3: e8 08 f6 ba fe callq ffffffff8158a5c0 <__might_fault>
ffffffff829dafb8: 48 8d bb b0 00 00 00 lea 0xb0(%rbx),%rdi
ffffffff829dafbf: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dafc6: fc ff df
ffffffff829dafc9: 48 89 fa mov %rdi,%rdx
ffffffff829dafcc: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829dafd0: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829dafd4: 0f 85 17 07 00 00 jne ffffffff829db6f1 <tty_ioctl+0x1d21>
ffffffff829dafda: 48 8b 9b b0 00 00 00 mov 0xb0(%rbx),%rbx
ffffffff829dafe1: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829dafe8: fc ff df
ffffffff829dafeb: 48 89 da mov %rbx,%rdx
ffffffff829dafee: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829daff2: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829daff6: 0f 85 e8 06 00 00 jne ffffffff829db6e4 <tty_ioctl+0x1d14>
ffffffff829daffc: 48 8b 1b mov (%rbx),%rbx
ffffffff829dafff: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db006: fc ff df
ffffffff829db009: 48 8d 7b 10 lea 0x10(%rbx),%rdi
ffffffff829db00d: 48 89 fa mov %rdi,%rdx
ffffffff829db010: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db014: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
ffffffff829db018: 84 c0 test %al,%al
ffffffff829db01a: 74 08 je ffffffff829db024 <tty_ioctl+0x1654>
ffffffff829db01c: 3c 03 cmp $0x3,%al
ffffffff829db01e: 0f 8e d7 06 00 00 jle ffffffff829db6fb <tty_ioctl+0x1d2b>
ffffffff829db024: 8b 43 10 mov 0x10(%rbx),%eax
ffffffff829db027: 48 8b 8d 30 fe ff ff mov -0x1d0(%rbp),%rcx
ffffffff829db02e: e8 5d e0 d1 ff callq ffffffff826f9090 <__put_user_4>
ffffffff829db033: 4c 63 f8 movslq %eax,%r15
ffffffff829db036: e9 89 ec ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
ffffffff829db03b: 65 4c 8b 2c 25 c0 3f mov %gs:0x13fc0,%r13
ffffffff829db042: 01 00
{
int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
return put_user(excl, (int __user *)p);
}
case TIOCNOTTY:
if (current->signal->tty != tty)
ffffffff829db044: 49 8d bd 48 06 00 00 lea 0x648(%r13),%rdi
ffffffff829db04b: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db052: fc ff df
ffffffff829db055: 48 89 fa mov %rdi,%rdx
ffffffff829db058: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db05c: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829db060: 0f 85 df 06 00 00 jne ffffffff829db745 <tty_ioctl+0x1d75>
ffffffff829db066: 4d 8b ad 48 06 00 00 mov 0x648(%r13),%r13
ffffffff829db06d: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db074: fc ff df
ffffffff829db077: 49 8d bd d0 01 00 00 lea 0x1d0(%r13),%rdi
ffffffff829db07e: 48 89 fa mov %rdi,%rdx
ffffffff829db081: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db085: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829db089: 0f 85 ac 06 00 00 jne ffffffff829db73b <tty_ioctl+0x1d6b>
ffffffff829db08f: 49 39 9d d0 01 00 00 cmp %rbx,0x1d0(%r13)
return -ENOTTY;
ffffffff829db096: 49 c7 c7 e7 ff ff ff mov $0xffffffffffffffe7,%r15
{
int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
return put_user(excl, (int __user *)p);
}
case TIOCNOTTY:
if (current->signal->tty != tty)
ffffffff829db09d: 0f 85 21 ec ff ff jne ffffffff829d9cc4 <tty_ioctl+0x2f4>
return -ENOTTY;
no_tty();
ffffffff829db0a3: e8 98 e8 ff ff callq ffffffff829d9940 <no_tty>
return 0;
ffffffff829db0a8: 45 31 ff xor %r15d,%r15d
ffffffff829db0ab: e9 14 ec ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
ffffffff829db0b0: be 16 00 00 00 mov $0x16,%esi
ffffffff829db0b5: 48 89 df mov %rbx,%rdi
ffffffff829db0b8: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db0bf: e8 9c ad ff ff callq ffffffff829d5e60 <__tty_check_change.part.24>
case TIOCSBRK:
case TIOCCBRK:
case TCSBRK:
case TCSBRKP:
retval = tty_check_change(tty);
if (retval)
ffffffff829db0c4: 85 c0 test %eax,%eax
ffffffff829db0c6: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db0cd: 0f 85 db ee ff ff jne ffffffff829d9fae <tty_ioctl+0x5de>
ffffffff829db0d3: e9 f5 ea ff ff jmpq ffffffff829d9bcd <tty_ioctl+0x1fd>
spin_lock(&file->f_lock);
if (nonblock)
file->f_flags |= O_NONBLOCK;
else
file->f_flags &= ~O_NONBLOCK;
ffffffff829db0d8: 84 c0 test %al,%al
ffffffff829db0da: 74 08 je ffffffff829db0e4 <tty_ioctl+0x1714>
ffffffff829db0dc: 3c 03 cmp $0x3,%al
ffffffff829db0de: 0f 8e a8 06 00 00 jle ffffffff829db78c <tty_ioctl+0x1dbc>
ffffffff829db0e4: 41 81 65 70 ff f7 ff andl $0xfffff7ff,0x70(%r13)
ffffffff829db0eb: ff
ffffffff829db0ec: e9 5c f0 ff ff jmpq ffffffff829da14d <tty_ioctl+0x77d>
int ret = 0;
tty_lock(tty);
read_lock(&tasklist_lock);
if (current->signal->leader && (task_session(current) == tty->session))
ffffffff829db0f1: 49 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%r15
ffffffff829db0f8: e9 d9 fd ff ff jmpq ffffffff829daed6 <tty_ioctl+0x1506>
ffffffff829db0fd: 49 c7 c7 e7 ff ff ff mov $0xffffffffffffffe7,%r15
ffffffff829db104: e9 bb eb ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
case TIOCMBIS:
return tty_tiocmset(tty, cmd, p);
case TIOCGICOUNT:
retval = tty_tiocgicount(tty, p);
/* For the moment allow fall through to the old method */
if (retval != -EINVAL)
ffffffff829db109: 83 f8 ea cmp $0xffffffea,%eax
ffffffff829db10c: 0f 85 9c ee ff ff jne ffffffff829d9fae <tty_ioctl+0x5de>
ffffffff829db112: e9 32 ee ff ff jmpq ffffffff829d9f49 <tty_ioctl+0x579>
ffffffff829db117: 65 48 8b 1c 25 c0 3f mov %gs:0x13fc0,%rbx
ffffffff829db11e: 01 00
int ret;
/*
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
ffffffff829db120: 48 8d bb 48 06 00 00 lea 0x648(%rbx),%rdi
ffffffff829db127: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db12e: fc ff df
ffffffff829db131: 48 89 fa mov %rdi,%rdx
ffffffff829db134: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db138: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829db13c: 0f 85 6c 06 00 00 jne ffffffff829db7ae <tty_ioctl+0x1dde>
ffffffff829db142: 48 8b 9b 48 06 00 00 mov 0x648(%rbx),%rbx
ffffffff829db149: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db150: fc ff df
ffffffff829db153: 48 8d bb d0 01 00 00 lea 0x1d0(%rbx),%rdi
ffffffff829db15a: 48 89 fa mov %rdi,%rdx
ffffffff829db15d: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db161: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829db165: 0f 85 2b 06 00 00 jne ffffffff829db796 <tty_ioctl+0x1dc6>
ffffffff829db16b: 4c 3b 93 d0 01 00 00 cmp 0x1d0(%rbx),%r10
ffffffff829db172: 49 c7 c7 e7 ff ff ff mov $0xffffffffffffffe7,%r15
ffffffff829db179: 0f 84 a9 f2 ff ff je ffffffff829da428 <tty_ioctl+0xa58>
ffffffff829db17f: e9 40 eb ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
retval = get_user(val, p);
if (retval)
return retval;
set = clear = 0;
switch (cmd) {
ffffffff829db184: 31 d2 xor %edx,%edx
ffffffff829db186: e9 e7 ee ff ff jmpq ffffffff829da072 <tty_ioctl+0x6a2>
/* non-zero arg means wait for all output data
* to be sent (performed above) but don't send break.
* This is used by the tcdrain() termios function.
*/
if (!arg)
return send_break(tty, 250);
ffffffff829db18b: be fa 00 00 00 mov $0xfa,%esi
ffffffff829db190: 48 89 df mov %rbx,%rdi
ffffffff829db193: e8 a8 8c ff ff callq ffffffff829d3e40 <send_break>
ffffffff829db198: 4c 63 f8 movslq %eax,%r15
ffffffff829db19b: e9 24 eb ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
case TCFLSH:
switch (arg) {
case TCIFLUSH:
case TCIOFLUSH:
/* flush tty buffer and allow ldisc to process ioctl */
tty_buffer_flush(tty, NULL);
ffffffff829db1a0: 31 f6 xor %esi,%esi
ffffffff829db1a2: 48 89 df mov %rbx,%rdi
ffffffff829db1a5: e8 36 9c 01 00 callq ffffffff829f4de0 <tty_buffer_flush>
ffffffff829db1aa: 48 8d 53 18 lea 0x18(%rbx),%rdx
break;
ffffffff829db1ae: e9 96 ed ff ff jmpq ffffffff829d9f49 <tty_ioctl+0x579>
ffffffff829db1b3: 81 e2 06 e0 00 00 and $0xe006,%edx
ffffffff829db1b9: 31 f6 xor %esi,%esi
ffffffff829db1bb: e9 b2 ee ff ff jmpq ffffffff829da072 <tty_ioctl+0x6a2>
return -EFAULT;
if (tty->ops->resize)
return tty->ops->resize(tty, &tmp_ws);
else
return tty_do_resize(tty, &tmp_ws);
ffffffff829db1c0: e8 9b 81 ff ff callq ffffffff829d3360 <tty_do_resize>
ffffffff829db1c5: 4c 63 f8 movslq %eax,%r15
ffffffff829db1c8: e9 f7 ea ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
ffffffff829db1cd: 65 48 8b 1c 25 c0 3f mov %gs:0x13fc0,%rbx
ffffffff829db1d4: 01 00
{
/*
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
ffffffff829db1d6: 48 8d bb 48 06 00 00 lea 0x648(%rbx),%rdi
ffffffff829db1dd: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db1e4: fc ff df
ffffffff829db1e7: 48 89 fa mov %rdi,%rdx
ffffffff829db1ea: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db1ee: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829db1f2: 0f 85 61 06 00 00 jne ffffffff829db859 <tty_ioctl+0x1e89>
ffffffff829db1f8: 48 8b 9b 48 06 00 00 mov 0x648(%rbx),%rbx
ffffffff829db1ff: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db206: fc ff df
ffffffff829db209: 48 8d bb d0 01 00 00 lea 0x1d0(%rbx),%rdi
ffffffff829db210: 48 89 fa mov %rdi,%rdx
ffffffff829db213: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db217: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829db21b: 0f 85 20 06 00 00 jne ffffffff829db841 <tty_ioctl+0x1e71>
ffffffff829db221: 4c 3b 93 d0 01 00 00 cmp 0x1d0(%rbx),%r10
return -ENOTTY;
ffffffff829db228: b8 e7 ff ff ff mov $0xffffffe7,%eax
{
/*
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
ffffffff829db22d: 0f 84 91 f3 ff ff je ffffffff829da5c4 <tty_ioctl+0xbf4>
ffffffff829db233: e9 76 ed ff ff jmpq ffffffff829d9fae <tty_ioctl+0x5de>
raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
} while (0)
static __always_inline void spin_unlock(spinlock_t *lock)
{
raw_spin_unlock(&lock->rlock);
ffffffff829db238: 48 c7 c7 60 7f 3d 86 mov $0xffffffff863d7f60,%rdi
ffffffff829db23f: 49 c7 c7 f0 ff ff ff mov $0xfffffffffffffff0,%r15
ffffffff829db246: e8 15 bd 8c 02 callq ffffffff852a6f60 <_raw_spin_unlock>
ffffffff829db24b: e9 74 ea ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
raw_spin_lock_init(&(_lock)->rlock); \
} while (0)
static __always_inline void spin_lock(spinlock_t *lock)
{
raw_spin_lock(&lock->rlock);
ffffffff829db250: e8 2b ba 8c 02 callq ffffffff852a6c80 <_raw_spin_lock>
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
if (file->f_op->write == redirected_tty_write) {
struct file *f;
spin_lock(&redirect_lock);
f = redirect;
ffffffff829db255: 48 8b 1d 44 01 f7 04 mov 0x4f70144(%rip),%rbx # ffffffff8794b3a0 <redirect>
raw_spin_lock_irqsave_nested(spinlock_check(lock), flags, subclass); \
} while (0)
static __always_inline void spin_unlock(spinlock_t *lock)
{
raw_spin_unlock(&lock->rlock);
ffffffff829db25c: 48 c7 c7 60 7f 3d 86 mov $0xffffffff863d7f60,%rdi
redirect = NULL;
ffffffff829db263: 48 c7 05 32 01 f7 04 movq $0x0,0x4f70132(%rip) # ffffffff8794b3a0 <redirect>
ffffffff829db26a: 00 00 00 00
spin_unlock(&redirect_lock);
if (f)
ffffffff829db26e: 45 31 ff xor %r15d,%r15d
ffffffff829db271: e8 ea bc 8c 02 callq ffffffff852a6f60 <_raw_spin_unlock>
ffffffff829db276: 48 85 db test %rbx,%rbx
ffffffff829db279: 0f 84 45 ea ff ff je ffffffff829d9cc4 <tty_ioctl+0x2f4>
fput(f);
ffffffff829db27f: 48 89 df mov %rbx,%rdi
ffffffff829db282: e8 f9 f4 c5 fe callq ffffffff8163a780 <fput>
ffffffff829db287: e9 38 ea ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
ffffffff829db28c: 4c 89 d7 mov %r10,%rdi
ffffffff829db28f: be 16 00 00 00 mov $0x16,%esi
ffffffff829db294: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db29b: e8 c0 ab ff ff callq ffffffff829d5e60 <__tty_check_change.part.24>
{
struct pid *pgrp;
pid_t pgrp_nr;
int retval = tty_check_change(real_tty);
if (retval == -EIO)
ffffffff829db2a0: 83 f8 fb cmp $0xfffffffb,%eax
ffffffff829db2a3: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db2aa: 0f 84 4d fe ff ff je ffffffff829db0fd <tty_ioctl+0x172d>
return -ENOTTY;
if (retval)
ffffffff829db2b0: 85 c0 test %eax,%eax
ffffffff829db2b2: 0f 85 f6 ec ff ff jne ffffffff829d9fae <tty_ioctl+0x5de>
ffffffff829db2b8: e9 02 f6 ff ff jmpq ffffffff829da8bf <tty_ioctl+0xeef>
static inline void rcu_read_lock(void)
{
__rcu_read_lock();
__acquire(RCU);
rcu_lock_acquire(&rcu_lock_map);
RCU_LOCKDEP_WARN(!rcu_is_watching(),
ffffffff829db2bd: e8 be e5 99 fe callq ffffffff81379880 <rcu_is_watching>
ffffffff829db2c2: 84 c0 test %al,%al
ffffffff829db2c4: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db2cb: 0f 85 c7 f7 ff ff jne ffffffff829daa98 <tty_ioctl+0x10c8>
ffffffff829db2d1: 48 c7 c2 c0 1e 61 85 mov $0xffffffff85611ec0,%rdx
ffffffff829db2d8: be 5f 03 00 00 mov $0x35f,%esi
ffffffff829db2dd: 48 c7 c7 20 1f 61 85 mov $0xffffffff85611f20,%rdi
ffffffff829db2e4: c6 05 a9 08 f9 03 01 movb $0x1,0x3f908a9(%rip) # ffffffff8696bb94 <__warned.9527>
ffffffff829db2eb: e8 50 ff 94 fe callq ffffffff8132b240 <lockdep_rcu_suspicious>
ffffffff829db2f0: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db2f7: e9 9c f7 ff ff jmpq ffffffff829daa98 <tty_ioctl+0x10c8>
* Locking: uses redirect_lock to guard the redirect information
*/
static int tioccons(struct file *file)
{
if (!capable(CAP_SYS_ADMIN))
ffffffff829db2fc: 49 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%r15
ffffffff829db303: e9 bc e9 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
int ret = 0;
tty_lock(tty);
read_lock(&tasklist_lock);
if (current->signal->leader && (task_session(current) == tty->session))
ffffffff829db308: 45 31 ff xor %r15d,%r15d
ffffffff829db30b: e9 c6 fb ff ff jmpq ffffffff829daed6 <tty_ioctl+0x1506>
*/
static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
{
struct winsize tmp_ws;
if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
ffffffff829db310: 49 c7 c7 f2 ff ff ff mov $0xfffffffffffffff2,%r15
case TIOCSTI:
return tiocsti(tty, p);
case TIOCGWINSZ:
return tiocgwinsz(real_tty, p);
case TIOCSWINSZ:
return tiocswinsz(real_tty, p);
ffffffff829db317: e9 a8 e9 ff ff jmpq ffffffff829d9cc4 <tty_ioctl+0x2f4>
*
* See rcu_read_lock() for more information.
*/
static inline void rcu_read_unlock(void)
{
RCU_LOCKDEP_WARN(!rcu_is_watching(),
ffffffff829db31c: e8 5f e5 99 fe callq ffffffff81379880 <rcu_is_watching>
ffffffff829db321: 84 c0 test %al,%al
ffffffff829db323: 0f 85 7e f8 ff ff jne ffffffff829daba7 <tty_ioctl+0x11d7>
ffffffff829db329: 48 c7 c2 60 1f 61 85 mov $0xffffffff85611f60,%rdx
ffffffff829db330: be 92 03 00 00 mov $0x392,%esi
ffffffff829db335: 48 c7 c7 20 1f 61 85 mov $0xffffffff85611f20,%rdi
ffffffff829db33c: c6 05 50 08 f9 03 01 movb $0x1,0x3f90850(%rip) # ffffffff8696bb93 <__warned.9531>
ffffffff829db343: e8 f8 fe 94 fe callq ffffffff8132b240 <lockdep_rcu_suspicious>
ffffffff829db348: e9 5a f8 ff ff jmpq ffffffff829daba7 <tty_ioctl+0x11d7>
{
int retval;
unsigned int set, clear, val;
if (tty->ops->tiocmset == NULL)
return -EINVAL;
ffffffff829db34d: b8 ea ff ff ff mov $0xffffffea,%eax
ffffffff829db352: e9 57 ec ff ff jmpq ffffffff829d9fae <tty_ioctl+0x5de>
/*
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
return -ENOTTY;
ffffffff829db357: b8 e7 ff ff ff mov $0xffffffe7,%eax
ffffffff829db35c: e9 4d ec ff ff jmpq ffffffff829d9fae <tty_ioctl+0x5de>
raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock); \
} while (0)
static __always_inline void spin_lock_irq(spinlock_t *lock)
{
raw_spin_lock_irq(&lock->rlock);
ffffffff829db361: 48 81 c3 38 03 00 00 add $0x338,%rbx
ffffffff829db368: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
ffffffff829db36f: 48 89 df mov %rbx,%rdi
ffffffff829db372: e8 79 ba 8c 02 callq ffffffff852a6df0 <_raw_spin_lock_irq>
retval = -EPERM;
if (session_of_pgrp(pgrp) != task_session(current))
goto out_unlock;
retval = 0;
spin_lock_irq(&tty->ctrl_lock);
put_pid(real_tty->pgrp);
ffffffff829db377: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db37e: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db385: fc ff df
ffffffff829db388: 4d 8d b2 48 04 00 00 lea 0x448(%r10),%r14
ffffffff829db38f: 4c 89 f2 mov %r14,%rdx
ffffffff829db392: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db396: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829db39a: 0f 85 40 01 00 00 jne ffffffff829db4e0 <tty_ioctl+0x1b10>
ffffffff829db3a0: 49 8b ba 48 04 00 00 mov 0x448(%r10),%rdi
ffffffff829db3a7: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
ffffffff829db3ae: e8 2d cf 8a fe callq ffffffff812882e0 <put_pid>
*
* Atomically increments @v by 1.
*/
static __always_inline void atomic_inc(atomic_t *v)
{
asm volatile(LOCK_PREFIX "incl %0"
ffffffff829db3b3: f0 41 ff 45 00 lock incl 0x0(%r13)
real_tty->pgrp = get_pid(pgrp);
ffffffff829db3b8: 4c 89 f2 mov %r14,%rdx
ffffffff829db3bb: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
ffffffff829db3c2: fc ff df
ffffffff829db3c5: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db3cc: 48 c1 ea 03 shr $0x3,%rdx
ffffffff829db3d0: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
ffffffff829db3d4: 0f 85 f2 00 00 00 jne ffffffff829db4cc <tty_ioctl+0x1afc>
ffffffff829db3da: 4d 89 aa 48 04 00 00 mov %r13,0x448(%r10)
raw_spin_unlock_bh(&lock->rlock);
}
static __always_inline void spin_unlock_irq(spinlock_t *lock)
{
raw_spin_unlock_irq(&lock->rlock);
ffffffff829db3e1: 48 89 df mov %rbx,%rdi
ffffffff829db3e4: 45 31 ff xor %r15d,%r15d
ffffffff829db3e7: e8 e4 bb 8c 02 callq ffffffff852a6fd0 <_raw_spin_unlock_irq>
ffffffff829db3ec: e9 a0 f7 ff ff jmpq ffffffff829dab91 <tty_ioctl+0x11c1>
struct task_struct *p;
struct pid *sid = NULL;
p = pid_task(pgrp, PIDTYPE_PGID);
if (p == NULL)
p = pid_task(pgrp, PIDTYPE_PID);
ffffffff829db3f1: 31 f6 xor %esi,%esi
ffffffff829db3f3: 4c 89 ef mov %r13,%rdi
ffffffff829db3f6: e8 65 d2 8a fe callq ffffffff81288660 <pid_task>
if (p != NULL)
ffffffff829db3fb: 48 85 c0 test %rax,%rax
ffffffff829db3fe: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db405: 0f 85 cc f6 ff ff jne ffffffff829daad7 <tty_ioctl+0x1107>
* The caller must hold rcu lock or the tasklist lock.
*/
static struct pid *session_of_pgrp(struct pid *pgrp)
{
struct task_struct *p;
struct pid *sid = NULL;
ffffffff829db40b: 31 c0 xor %eax,%eax
ffffffff829db40d: e9 17 f7 ff ff jmpq ffffffff829dab29 <tty_ioctl+0x1159>
ffffffff829db412: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db419: e8 92 ee c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db41e: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db425: e9 d5 f5 ff ff jmpq ffffffff829da9ff <tty_ioctl+0x102f>
ffffffff829db42a: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db431: e8 7a ee c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db436: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db43d: e9 94 f5 ff ff jmpq ffffffff829da9d6 <tty_ioctl+0x1006>
ffffffff829db442: 48 89 85 28 fe ff ff mov %rax,-0x1d8(%rbp)
ffffffff829db449: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
ffffffff829db450: e8 5b ee c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db455: 48 8b 85 28 fe ff ff mov -0x1d8(%rbp),%rax
ffffffff829db45c: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db463: e9 15 f7 ff ff jmpq ffffffff829dab7d <tty_ioctl+0x11ad>
ffffffff829db468: 48 89 85 28 fe ff ff mov %rax,-0x1d8(%rbp)
ffffffff829db46f: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
ffffffff829db476: e8 35 ee c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db47b: 48 8b 85 28 fe ff ff mov -0x1d8(%rbp),%rax
ffffffff829db482: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db489: e9 6b f6 ff ff jmpq ffffffff829daaf9 <tty_ioctl+0x1129>
ffffffff829db48e: 48 89 85 28 fe ff ff mov %rax,-0x1d8(%rbp)
ffffffff829db495: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
ffffffff829db49c: e8 0f ee c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db4a1: 48 8b 85 28 fe ff ff mov -0x1d8(%rbp),%rax
ffffffff829db4a8: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db4af: e9 a0 f6 ff ff jmpq ffffffff829dab54 <tty_ioctl+0x1184>
ffffffff829db4b4: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
ffffffff829db4bb: e8 f0 ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db4c0: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db4c7: e9 56 f6 ff ff jmpq ffffffff829dab22 <tty_ioctl+0x1152>
if (session_of_pgrp(pgrp) != task_session(current))
goto out_unlock;
retval = 0;
spin_lock_irq(&tty->ctrl_lock);
put_pid(real_tty->pgrp);
real_tty->pgrp = get_pid(pgrp);
ffffffff829db4cc: 4c 89 f7 mov %r14,%rdi
ffffffff829db4cf: e8 1c ef c1 fe callq ffffffff815fa3f0 <__asan_report_store8_noabort>
ffffffff829db4d4: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db4db: e9 fa fe ff ff jmpq ffffffff829db3da <tty_ioctl+0x1a0a>
retval = -EPERM;
if (session_of_pgrp(pgrp) != task_session(current))
goto out_unlock;
retval = 0;
spin_lock_irq(&tty->ctrl_lock);
put_pid(real_tty->pgrp);
ffffffff829db4e0: 4c 89 f7 mov %r14,%rdi
ffffffff829db4e3: e8 c8 ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db4e8: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db4ef: e9 ac fe ff ff jmpq ffffffff829db3a0 <tty_ioctl+0x19d0>
ffffffff829db4f4: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
{
struct winsize tmp_ws;
if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
return -EFAULT;
if (tty->ops->resize)
ffffffff829db4fb: e8 b0 ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db500: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db507: e9 55 fa ff ff jmpq ffffffff829daf61 <tty_ioctl+0x1591>
int ret = 0;
tty_lock(tty);
read_lock(&tasklist_lock);
if (current->signal->leader && (task_session(current) == tty->session))
ffffffff829db50c: e8 9f ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db511: e9 a8 f7 ff ff jmpq ffffffff829dacbe <tty_ioctl+0x12ee>
ffffffff829db516: e8 95 ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db51b: e9 75 f7 ff ff jmpq ffffffff829dac95 <tty_ioctl+0x12c5>
ffffffff829db520: e8 8b ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db525: e9 42 f7 ff ff jmpq ffffffff829dac6c <tty_ioctl+0x129c>
*/
if (arg == 1 && capable(CAP_SYS_ADMIN)) {
/*
* Steal it away
*/
session_clear_tty(tty->session);
ffffffff829db52a: 4c 89 f7 mov %r14,%rdi
ffffffff829db52d: e8 7e ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db532: e9 c5 f8 ff ff jmpq ffffffff829dadfc <tty_ioctl+0x142c>
ffffffff829db537: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
if (retval == -EIO)
return -ENOTTY;
if (retval)
return retval;
if (!current->signal->tty ||
(current->signal->tty != real_tty) ||
ffffffff829db53e: e8 6d ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db543: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db54a: e9 fd f3 ff ff jmpq ffffffff829da94c <tty_ioctl+0xf7c>
ffffffff829db54f: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
(real_tty->session != task_session(current)))
ffffffff829db556: e8 55 ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db55b: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db562: e9 3d f4 ff ff jmpq ffffffff829da9a4 <tty_ioctl+0xfd4>
ffffffff829db567: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
if (retval == -EIO)
return -ENOTTY;
if (retval)
return retval;
if (!current->signal->tty ||
(current->signal->tty != real_tty) ||
ffffffff829db56e: e8 3d ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db573: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db57a: e9 f6 f3 ff ff jmpq ffffffff829da975 <tty_ioctl+0xfa5>
clear = ~val;
break;
}
set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
return tty->ops->tiocmset(tty, set, clear);
ffffffff829db57f: 4c 89 ff mov %r15,%rdi
ffffffff829db582: 89 95 28 fe ff ff mov %edx,-0x1d8(%rbp)
ffffffff829db588: 89 b5 30 fe ff ff mov %esi,-0x1d0(%rbp)
ffffffff829db58e: e8 1d ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db593: 8b 95 28 fe ff ff mov -0x1d8(%rbp),%edx
ffffffff829db599: 8b b5 30 fe ff ff mov -0x1d0(%rbp),%esi
ffffffff829db59f: e9 e9 ea ff ff jmpq ffffffff829da08d <tty_ioctl+0x6bd>
*/
if (tty == real_tty && current->signal->tty != real_tty)
return -ENOTTY;
if (!real_tty->session)
return -ENOTTY;
return put_user(pid_vnr(real_tty->session), p);
ffffffff829db5a4: 48 89 df mov %rbx,%rdi
ffffffff829db5a7: e8 04 ed c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db5ac: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db5b3: e9 76 f0 ff ff jmpq ffffffff829da62e <tty_ioctl+0xc5e>
ffffffff829db5b8: 4c 89 95 30 fe ff ff mov %r10,-0x1d0(%rbp)
{
struct winsize tmp_ws;
if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
return -EFAULT;
if (tty->ops->resize)
ffffffff829db5bf: e8 ec ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db5c4: 4c 8b 95 30 fe ff ff mov -0x1d0(%rbp),%r10
ffffffff829db5cb: e9 b7 f9 ff ff jmpq ffffffff829daf87 <tty_ioctl+0x15b7>
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
return -ENOTTY;
if (!real_tty->session)
ffffffff829db5d0: 48 89 df mov %rbx,%rdi
ffffffff829db5d3: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db5da: e8 d1 ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db5df: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db5e6: e9 fb ef ff ff jmpq ffffffff829da5e6 <tty_ioctl+0xc16>
ffffffff829db5eb: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
EXPORT_SYMBOL(tty_unregister_driver);
dev_t tty_devnum(struct tty_struct *tty)
{
return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
ffffffff829db5f2: e8 b9 ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db5f7: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db5fe: e9 67 f0 ff ff jmpq ffffffff829da66a <tty_ioctl+0xc9a>
ffffffff829db603: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db60a: e8 61 ec c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db60f: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db616: e9 81 f0 ff ff jmpq ffffffff829da69c <tty_ioctl+0xccc>
ffffffff829db61b: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db622: e8 49 ec c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db627: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db62e: e9 96 f0 ff ff jmpq ffffffff829da6c9 <tty_ioctl+0xcf9>
ffffffff829db633: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db63a: e8 31 ec c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db63f: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db646: e9 aa f0 ff ff jmpq ffffffff829da6f5 <tty_ioctl+0xd25>
ffffffff829db64b: 89 95 28 fe ff ff mov %edx,-0x1d8(%rbp)
ffffffff829db651: 89 b5 30 fe ff ff mov %esi,-0x1d0(%rbp)
clear = ~val;
break;
}
set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
return tty->ops->tiocmset(tty, set, clear);
ffffffff829db657: e8 54 ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db65c: 8b 95 28 fe ff ff mov -0x1d8(%rbp),%edx
ffffffff829db662: 8b b5 30 fe ff ff mov -0x1d0(%rbp),%esi
ffffffff829db668: e9 46 ea ff ff jmpq ffffffff829da0b3 <tty_ioctl+0x6e3>
}
static __always_inline int constant_test_bit(long nr, const volatile unsigned long *addr)
{
return ((1UL << (nr & (BITS_PER_LONG-1))) &
(addr[nr >> _BITOPS_LONG_SHIFT])) != 0;
ffffffff829db66d: e8 3e ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db672: e9 51 ee ff ff jmpq ffffffff829da4c8 <tty_ioctl+0xaf8>
return -EPERM;
if (get_user(ch, p))
return -EFAULT;
tty_audit_tiocsti(tty, ch);
ld = tty_ldisc_ref_wait(tty);
ld->ops->receive_buf(tty, &ch, &mbz, 1);
ffffffff829db677: e8 34 ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db67c: e9 e5 ec ff ff jmpq ffffffff829da366 <tty_ioctl+0x996>
ffffffff829db681: 4c 89 ef mov %r13,%rdi
ffffffff829db684: e8 27 ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db689: e9 b5 ec ff ff jmpq ffffffff829da343 <tty_ioctl+0x973>
break;
case TIOCSSERIAL:
tty_warn_deprecated_flags(p);
break;
}
if (tty->ops->ioctl) {
ffffffff829db68e: e8 1d ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db693: e9 ef e8 ff ff jmpq ffffffff829d9f87 <tty_ioctl+0x5b7>
ffffffff829db698: 48 89 d7 mov %rdx,%rdi
ffffffff829db69b: e8 10 ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db6a0: e9 bf e8 ff ff jmpq ffffffff829d9f64 <tty_ioctl+0x594>
case TIOCSBRK: /* Turn break on, unconditionally */
if (tty->ops->break_ctl)
return tty->ops->break_ctl(tty, -1);
return 0;
case TIOCCBRK: /* Turn break off, unconditionally */
if (tty->ops->break_ctl)
ffffffff829db6a5: e8 06 ec c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db6aa: e9 ff ea ff ff jmpq ffffffff829da1ae <tty_ioctl+0x7de>
ffffffff829db6af: e8 fc eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db6b4: e9 cf ea ff ff jmpq ffffffff829da188 <tty_ioctl+0x7b8>
if (!current->signal->leader || current->signal->tty) {
ret = -EPERM;
goto unlock;
}
if (tty->session) {
ffffffff829db6b9: 4c 89 f7 mov %r14,%rdi
ffffffff829db6bc: e8 ef eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db6c1: e9 f2 f6 ff ff jmpq ffffffff829dadb8 <tty_ioctl+0x13e8>
goto unlock;
}
}
/* See the comment in tty_open(). */
if ((file->f_mode & FMODE_READ) == 0 && !capable(CAP_SYS_ADMIN)) {
ffffffff829db6c6: e8 a5 eb c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db6cb: e9 66 f7 ff ff jmpq ffffffff829dae36 <tty_ioctl+0x1466>
static int tty_tiocmget(struct tty_struct *tty, int __user *p)
{
int retval = -EINVAL;
if (tty->ops->tiocmget) {
ffffffff829db6d0: e8 db eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db6d5: e9 ff ec ff ff jmpq ffffffff829da3d9 <tty_ioctl+0xa09>
ffffffff829db6da: e8 d1 eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db6df: e9 cf ec ff ff jmpq ffffffff829da3b3 <tty_ioctl+0x9e3>
case TIOCSPGRP:
return tiocspgrp(tty, real_tty, p);
case TIOCGSID:
return tiocgsid(tty, real_tty, p);
case TIOCGETD:
return put_user(tty->ldisc->ops->num, (int __user *)p);
ffffffff829db6e4: 48 89 df mov %rbx,%rdi
ffffffff829db6e7: e8 c4 eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db6ec: e9 0b f9 ff ff jmpq ffffffff829daffc <tty_ioctl+0x162c>
ffffffff829db6f1: e8 ba eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db6f6: e9 df f8 ff ff jmpq ffffffff829dafda <tty_ioctl+0x160a>
ffffffff829db6fb: e8 70 eb c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db700: e9 1f f9 ff ff jmpq ffffffff829db024 <tty_ioctl+0x1654>
kfree(tty);
}
static inline struct tty_struct *file_tty(struct file *file)
{
return ((struct tty_file_private *)file->private_data)->tty;
ffffffff829db705: 48 89 df mov %rbx,%rdi
ffffffff829db708: e8 a3 eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db70d: e9 a1 e3 ff ff jmpq ffffffff829d9ab3 <tty_ioctl+0xe3>
ffffffff829db712: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db719: e8 92 eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db71e: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db725: e9 13 e5 ff ff jmpq ffffffff829d9c3d <tty_ioctl+0x26d>
return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
}
static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
{
return test_ti_thread_flag(task_thread_info(tsk), flag);
ffffffff829db72a: e8 81 eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db72f: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db736: e9 df e4 ff ff jmpq ffffffff829d9c1a <tty_ioctl+0x24a>
{
int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
return put_user(excl, (int __user *)p);
}
case TIOCNOTTY:
if (current->signal->tty != tty)
ffffffff829db73b: e8 70 eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db740: e9 4a f9 ff ff jmpq ffffffff829db08f <tty_ioctl+0x16bf>
ffffffff829db745: e8 66 eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db74a: e9 17 f9 ff ff jmpq ffffffff829db066 <tty_ioctl+0x1696>
ffffffff829db74f: 4c 89 8d 28 fe ff ff mov %r9,-0x1d8(%rbp)
if (retval != -ENOIOCTLCMD)
return retval;
}
ld = tty_ldisc_ref_wait(tty);
retval = -EINVAL;
if (ld->ops->ioctl) {
ffffffff829db756: e8 55 eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db75b: 4c 8b 8d 28 fe ff ff mov -0x1d8(%rbp),%r9
ffffffff829db762: e9 ea ed ff ff jmpq ffffffff829da551 <tty_ioctl+0xb81>
ffffffff829db767: 4c 89 cf mov %r9,%rdi
ffffffff829db76a: 4c 89 8d 28 fe ff ff mov %r9,-0x1d8(%rbp)
ffffffff829db771: e8 3a eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db776: 4c 8b 8d 28 fe ff ff mov -0x1d8(%rbp),%r9
ffffffff829db77d: e9 ad ed ff ff jmpq ffffffff829da52f <tty_ioctl+0xb5f>
if (get_user(nonblock, p))
return -EFAULT;
spin_lock(&file->f_lock);
if (nonblock)
file->f_flags |= O_NONBLOCK;
ffffffff829db782: e8 e9 ea c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db787: e9 b9 e9 ff ff jmpq ffffffff829da145 <tty_ioctl+0x775>
else
file->f_flags &= ~O_NONBLOCK;
ffffffff829db78c: e8 df ea c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db791: e9 4e f9 ff ff jmpq ffffffff829db0e4 <tty_ioctl+0x1714>
ffffffff829db796: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
int ret;
/*
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
ffffffff829db79d: e8 0e eb c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db7a2: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db7a9: e9 bd f9 ff ff jmpq ffffffff829db16b <tty_ioctl+0x179b>
ffffffff829db7ae: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db7b5: e8 f6 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db7ba: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db7c1: e9 7c f9 ff ff jmpq ffffffff829db142 <tty_ioctl+0x1772>
unsigned __user *p)
{
int retval;
unsigned int set, clear, val;
if (tty->ops->tiocmset == NULL)
ffffffff829db7c6: e8 e5 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db7cb: e9 45 e8 ff ff jmpq ffffffff829da015 <tty_ioctl+0x645>
ffffffff829db7d0: 4c 89 ff mov %r15,%rdi
ffffffff829db7d3: e8 d8 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db7d8: e9 12 e8 ff ff jmpq ffffffff829d9fef <tty_ioctl+0x61f>
/*
* The process must be a session leader and
* not have a controlling tty already.
*/
if (!current->signal->leader || current->signal->tty) {
ffffffff829db7dd: e8 ce ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db7e2: e9 0f f5 ff ff jmpq ffffffff829dacf6 <tty_ioctl+0x1326>
ffffffff829db7e7: e8 84 ea c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db7ec: e9 34 f5 ff ff jmpq ffffffff829dad25 <tty_ioctl+0x1355>
int ret = 0;
tty_lock(tty);
read_lock(&tasklist_lock);
if (current->signal->leader && (task_session(current) == tty->session))
ffffffff829db7f1: e8 ba ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db7f6: e9 08 f4 ff ff jmpq ffffffff829dac03 <tty_ioctl+0x1233>
ffffffff829db7fb: e8 70 ea c1 fe callq ffffffff815fa270 <__asan_report_load4_noabort>
ffffffff829db800: e9 2d f4 ff ff jmpq ffffffff829dac32 <tty_ioctl+0x1262>
* if pty, return the slave side (real_tty)
* otherwise, return self
*/
static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
{
if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
ffffffff829db805: e8 a6 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db80a: e9 00 e3 ff ff jmpq ffffffff829d9b0f <tty_ioctl+0x13f>
tty->driver->subtype == PTY_TYPE_MASTER)
tty = tty->link;
ffffffff829db80f: e8 9c ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db814: e9 62 e5 ff ff jmpq ffffffff829d9d7b <tty_ioctl+0x3ab>
ffffffff829db819: e8 92 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db81e: e9 6e e2 ff ff jmpq ffffffff829d9a91 <tty_ioctl+0xc1>
ffffffff829db823: e8 88 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db828: e9 a8 e2 ff ff jmpq ffffffff829d9ad5 <tty_ioctl+0x105>
static int tioccons(struct file *file)
{
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
if (file->f_op->write == redirected_tty_write) {
ffffffff829db82d: e8 7e ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db832: e9 78 ef ff ff jmpq ffffffff829da7af <tty_ioctl+0xddf>
ffffffff829db837: e8 74 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db83c: e9 4b ef ff ff jmpq ffffffff829da78c <tty_ioctl+0xdbc>
ffffffff829db841: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
{
/*
* (tty == real_tty) is a cheap way of
* testing if the tty is NOT a master pty.
*/
if (tty == real_tty && current->signal->tty != real_tty)
ffffffff829db848: e8 63 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db84d: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db854: e9 c8 f9 ff ff jmpq ffffffff829db221 <tty_ioctl+0x1851>
ffffffff829db859: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db860: e8 4b ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db865: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db86c: e9 87 f9 ff ff jmpq ffffffff829db1f8 <tty_ioctl+0x1828>
ffffffff829db871: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
{
unsigned long flags;
struct pid *pgrp, *tty_pgrp;
int ret = 0;
if (current->signal->tty != tty)
ffffffff829db878: e8 33 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db87d: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db884: e9 29 f0 ff ff jmpq ffffffff829da8b2 <tty_ioctl+0xee2>
ffffffff829db889: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db890: e8 1b ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db895: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db89c: e9 e8 ef ff ff jmpq ffffffff829da889 <tty_ioctl+0xeb9>
}
/*
* Break handling
*/
case TIOCSBRK: /* Turn break on, unconditionally */
if (tty->ops->break_ctl)
ffffffff829db8a1: e8 0a ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db8a6: e9 91 ef ff ff jmpq ffffffff829da83c <tty_ioctl+0xe6c>
ffffffff829db8ab: e8 00 ea c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db8b0: e9 61 ef ff ff jmpq ffffffff829da816 <tty_ioctl+0xe46>
ffffffff829db8b5: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
{
unsigned long flags;
struct pid *pgrp, *tty_pgrp;
int ret = 0;
if (current->signal->tty != tty)
ffffffff829db8bc: e8 ef e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db8c1: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db8c8: e9 ca e2 ff ff jmpq ffffffff829d9b97 <tty_ioctl+0x1c7>
ffffffff829db8cd: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db8d4: e8 d7 e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db8d9: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db8e0: e9 db e2 ff ff jmpq ffffffff829d9bc0 <tty_ioctl+0x1f0>
static void proc_set_tty(struct tty_struct *tty)
{
spin_lock_irq(&current->sighand->siglock);
__proc_set_tty(tty);
spin_unlock_irq(&current->sighand->siglock);
ffffffff829db8e5: e8 c6 e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db8ea: e9 d1 f5 ff ff jmpq ffffffff829daec0 <tty_ioctl+0x14f0>
current->signal->tty_old_pgrp = NULL;
}
static void proc_set_tty(struct tty_struct *tty)
{
spin_lock_irq(&current->sighand->siglock);
ffffffff829db8ef: e8 bc e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db8f4: e9 81 f5 ff ff jmpq ffffffff829dae7a <tty_ioctl+0x14aa>
ffffffff829db8f9: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
if (retval == -EIO)
return -ENOTTY;
if (retval)
return retval;
if (!current->signal->tty ||
ffffffff829db900: e8 ab e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db905: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db90c: e9 02 f0 ff ff jmpq ffffffff829da913 <tty_ioctl+0xf43>
ffffffff829db911: 4c 89 95 28 fe ff ff mov %r10,-0x1d8(%rbp)
ffffffff829db918: e8 93 e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db91d: 4c 8b 95 28 fe ff ff mov -0x1d8(%rbp),%r10
ffffffff829db924: e9 c1 ef ff ff jmpq ffffffff829da8ea <tty_ioctl+0xf1a>
static int tiocsti(struct tty_struct *tty, char __user *p)
{
char ch, mbz = 0;
struct tty_ldisc *ld;
if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
ffffffff829db929: e8 82 e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db92e: e9 92 e9 ff ff jmpq ffffffff829da2c5 <tty_ioctl+0x8f5>
ffffffff829db933: e8 78 e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db938: e9 5f e9 ff ff jmpq ffffffff829da29c <tty_ioctl+0x8cc>
/*
* The process must be a session leader and
* not have a controlling tty already.
*/
if (!current->signal->leader || current->signal->tty) {
ffffffff829db93d: e8 6e e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db942: e9 41 f4 ff ff jmpq ffffffff829dad88 <tty_ioctl+0x13b8>
ffffffff829db947: e8 64 e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db94c: e9 0e f4 ff ff jmpq ffffffff829dad5f <tty_ioctl+0x138f>
ffffffff829db951: 48 89 95 20 fe ff ff mov %rdx,-0x1e0(%rbp)
ffffffff829db958: 48 89 85 28 fe ff ff mov %rax,-0x1d8(%rbp)
static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
{
int retval = -EINVAL;
struct serial_icounter_struct icount;
memset(&icount, 0, sizeof(icount));
if (tty->ops->get_icount)
ffffffff829db95f: e8 4c e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db964: 48 8b 95 20 fe ff ff mov -0x1e0(%rbp),%rdx
ffffffff829db96b: 48 8b 85 28 fe ff ff mov -0x1d8(%rbp),%rax
ffffffff829db972: e9 38 e5 ff ff jmpq ffffffff829d9eaf <tty_ioctl+0x4df>
ffffffff829db977: 48 89 d7 mov %rdx,%rdi
ffffffff829db97a: 48 89 95 28 fe ff ff mov %rdx,-0x1d8(%rbp)
ffffffff829db981: e8 2a e9 c1 fe callq ffffffff815fa2b0 <__asan_report_load8_noabort>
ffffffff829db986: 48 8b 95 28 fe ff ff mov -0x1d8(%rbp),%rdx
ffffffff829db98d: e9 f7 e4 ff ff jmpq ffffffff829d9e89 <tty_ioctl+0x4b9>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment