tty driver(4)

最新推荐文章于 2022-04-20 12:30:00 发布
最新推荐文章于 2022-04-20 12:30:00 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： tty driver 文章标签： tty driver
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011279649/article/details/9389325
版权

与tty_write相关的数据成员

struct tty_struct {/*在tty_io层维护*/
    unsigned char *write_buf;
    int write_cnt;
}

1]数据从用户空间copy到内核空间

tty_write -> do_tty_write(ld->ops->write, tty, file, buf, count)
{
    tty_write_lock(tty, file->f_flags & O_NDELAY);
    /*
     * We chunk up writes into a temporary buffer. This
     * simplifies low-level drivers immensely, since they
     * don't have locking issues and user mode accesses.
     *
     * But if TTY_NO_WRITE_SPLIT is set, we should use a
     * big chunk-size..
     *
     * The default chunk-size is 2kB, because the NTTY
     * layer has problems with bigger chunks. It will
     * claim to be able to handle more characters than
     * it actually does.
     *
     * FIXME: This can probably go away now except that 64K chunks
     * are too likely to fail unless switched to vmalloc...
     */
    chunk = 2048;
    if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
        chunk = 65536;
    if (count < chunk)
        chunk = count;
    /*申请kernel memory for writing operation*/
    /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
    if (tty->write_cnt < chunk) {
        unsigned char *buf_chunk;

        if (chunk < 1024)
            chunk = 1024;

        buf_chunk = kmalloc(chunk, GFP_KERNEL);
        if (!buf_chunk) {
            ret = -ENOMEM;
            goto out;
        }
        kfree(tty->write_buf);
        tty->write_cnt = chunk;
        tty->write_buf = buf_chunk;
    }
    /*把来自用户空间的数据copy到内核空间*/
    copy_from_user(tty->write_buf, buf, size);
    /*调用行规write operation*/
    write(tty, file, tty->write_buf, size);

    tty_write_unlock(tty);
}

2]数据从内核write_buffer到行规/tty_driver

n_tty_write(struct tty_struct *tty, struct file *file,
       const unsigned char *buf, size_t nr)
    -> tty->ops->write(tty, b, nr);
        -> {
            smd_stream_write_avail(tty_info->ch);
            smd_stream_write(tty_info->ch, buf, len);
           }

tty 写操作流程

1. tty_io 层

1.1 tty_write

/**

 *    tty_write        -    write method for tty device file
 *    @file: tty file pointer
 *    @buf: user data to write
 *    @count: bytes to write
 *    @ppos: unused
 *
 *    Write data to a tty device via the line discipline.
 *
 *    Locking:
 *        Locks the line discipline as required
 *        Writes to the tty driver are serialized by the atomic_write_lock
 *    and are then processed in chunks to the device. The line discipline
 *    write method will not be invoked in parallel for each device.
 */

static ssize_t tty_write(struct file *file, const char __user *buf,
                        size_t count, loff_t *ppos)
{
    struct inode *inode = file->f_path.dentry->d_inode;
    struct tty_struct *tty = file_tty(file);
     struct tty_ldisc *ld;
    ssize_t ret;

/*1. check the input arguments */

    if (tty_paranoia_check(tty, inode, "tty_write"))
        return -EIO;
    if (!tty || !tty->ops->write ||
        (test_bit(TTY_IO_ERROR, &tty->flags)))
        return -EIO; 
    /* Short term debug to catch buggy drivers */
    if (tty->ops->write_room == NULL)
        printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
            tty->driver->name);

/*2. get the line discipline by tty */

    ld = tty_ldisc_ref_wait(tty);

/*3. call do_tty_write with ldops write operation */

    if (!ld->ops->write)
        ret = -EIO;
    else
        ret = do_tty_write(ld->ops->write, tty, file, buf, count);

/*4. free a tty ldisc reference */

    tty_ldisc_deref(ld);
    return ret;
}

1.2 do_tty_write

/*
 * Split writes up in sane blocksizes to avoid
 * denial-of-service type attacks
 */
static inline ssize_t do_tty_write(
    ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
    struct tty_struct *tty,
    struct file *file,
    const char __user *buf,
    size_t count)
{
    ssize_t ret, written = 0;
    unsigned int chunk;

/*1. get the atomic_write_lock */

    ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
    if (ret < 0)
        return ret;

    /*
     * We chunk up writes into a temporary buffer. This
     * simplifies low-level drivers immensely, since they
     * don't have locking issues and user mode accesses.
     *
     * But if TTY_NO_WRITE_SPLIT is set, we should use a
     * big chunk-size..
     *
     * The default chunk-size is 2kB, because the NTTY
     * layer has problems with bigger chunks. It will
     * claim to be able to handle more characters than
     * it actually does.
     *
     * FIXME: This can probably go away now except that 64K chunks
     * are too likely to fail unless switched to vmalloc...
     */

/*2. 分配 write_buf and update the member of write_cnt, write_buf*/

    chunk = 2048;
    if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
        chunk = 65536;
    if (count < chunk)
        chunk = count;

    /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
    if (tty->write_cnt < chunk) {
        unsigned char *buf_chunk;

        if (chunk < 1024)
            chunk = 1024;

        buf_chunk = kmalloc(chunk, GFP_KERNEL);
        if (!buf_chunk) {
            ret = -ENOMEM;
            goto out;
        }
        kfree(tty->write_buf);
        tty->write_cnt = chunk;
        tty->write_buf = buf_chunk;
    }

/*3. Do the write .. */

    for (;;) {
        size_t size = count;
        if (size > chunk)
            size = chunk;
        ret = -EFAULT;
    /*3.1 把来自用户空间的数据保存到分配的 write_buf内*/
        if (copy_from_user(tty->write_buf, buf, size))
            break;
    /*3.2 通过函数指针调用 n_tty_write*/
        ret = write(tty, file, tty->write_buf, size);
        if (ret <= 0)
            break;
        written += ret;
        buf += ret;
        count -= ret;
        if (!count)
            break;
        ret = -ERESTARTSYS;
        /*signal pending,外界发送命令停止传送等情况*/
        if (signal_pending(current))
            break;
        cond_resched();
    }

/*4. 有数据写入，更新 inode的时间信息，估计就是最后一次写入时间*/

    if (written) {
        struct inode *inode = file->f_path.dentry->d_inode;
        inode->i_mtime = current_fs_time(inode->i_sb);
        ret = written;
    }
out:

/*5. 释放atomic_write_lock*/

    tty_write_unlock(tty);
    return ret;
}

2. n_tty层


/**
 *    n_tty_write        -    write function for tty
 *    @tty: tty device
 *    @file: file object
 *    @buf: userspace buffer pointer
 *    @nr: size of I/O
 *
 *    Write function of the terminal device.  This is serialized with
 *    respect to other write callers but not to termios changes, reads
 *    and other such events.  Since the receive code will echo characters,
 *    thus calling driver write methods, the output_lock is used in
 *    the output processing functions called here as well as in the
 *    echo processing function to protect the column state and space
 *    left in the buffer.
 *
 *    This code must be sure never to sleep through a hangup.
 *
 *    Locking: output_lock to protect column state and space left
 *         (note that the process_output*() functions take this
 *          lock themselves)
 */

static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
               const unsigned char *buf, size_t nr)
{
    const unsigned char *b = buf;
    DECLARE_WAITQUEUE(wait, current);
    int c;
    ssize_t retval = 0;
/*不知这里的 waitqueue什么个意思？*/
    add_wait_queue(&tty->write_wait, &wait);
    while (1) {
        set_current_state(TASK_INTERRUPTIBLE);
            while (nr > 0) {
/*这里是多次写入的，如果期望写入的大小和返回值【实际写入的】不一致，继续写剩下的
 *这有点流控的意思，不知道写操作的流控是怎样实现的？
 */
                c = tty->ops->write(tty, b, nr);
                if (c < 0) {
                    retval = c;
                    goto break_out;
                }
                if (!c)
                    break;
                b += c;
                nr -= c;
            }

        if (!nr)
            break;
        if (file->f_flags & O_NONBLOCK) {
            retval = -EAGAIN;
            break;
        }
        schedule();
    }
break_out:
    __set_current_state(TASK_RUNNING);
    remove_wait_queue(&tty->write_wait, &wait);
    if (b - buf != nr && tty->fasync)
        set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
    return (b - buf) ? b - buf : retval;
}

3. 硬件具体的层

static int smd_tty_write(struct tty_struct *tty,
             const unsigned char *buf, int len)
{
    struct smd_tty_info *info = tty->driver_data;
    int avail;

    /* if we're writing to a packet channel we will
    ** never be able to write more data than there
    ** is currently space for
    */
    avail = smd_write_avail(info->ch);
    if (len > avail)
        len = avail;
    return smd_write(info->ch, buf, len);
}


4 总结

tty write操作分问3个层次 tty_io, n_tty,  设备具体的tty_driver.从中个层次间的调用关系也
看出，设备具体的要实现那些函数，或者那些函数是必须的。
    int  (*write_room)(struct tty_struct *tty);    /*有多少写空间*/
    int  (*write)(struct tty_struct * tty,        /*具体硬件相关的写操作*/    
              const unsigned char *buf, int count);



static ssize_t tty_write(struct file *file, const char __user *buf,
                        size_t count, loff_t *ppos)
{
    struct inode *inode = file->f_path.dentry->d_inode;
    struct tty_struct *tty = file_tty(file);
     struct tty_ldisc *ld;
    ssize_t ret;

    if (tty_paranoia_check(tty, inode, "tty_write"))
        return -EIO;
    if (!tty || !tty->ops->write ||
        (test_bit(TTY_IO_ERROR, &tty->flags)))
            return -EIO;
    /* Short term debug to catch buggy drivers */
    if (tty->ops->write_room == NULL)
        printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
            tty->driver->name);
    ld = tty_ldisc_ref_wait(tty);
    if (!ld->ops->write)
        ret = -EIO;
    else
        ret = do_tty_write(ld->ops->write, tty, file, buf, count);
    tty_ldisc_deref(ld);
    return ret;
}

/*
 * Split writes up in sane blocksizes to avoid
 * denial-of-service type attacks
 */
static inline ssize_t do_tty_write(
    ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
    struct tty_struct *tty,
    struct file *file,
    const char __user *buf,
    size_t count)
{
    ssize_t ret, written = 0;
    unsigned int chunk;

    ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
    if (ret < 0)
        return ret;

    /*
     * We chunk up writes into a temporary buffer. This
     * simplifies low-level drivers immensely, since they
     * don't have locking issues and user mode accesses.
     *
     * But if TTY_NO_WRITE_SPLIT is set, we should use a
     * big chunk-size..
     *
     * The default chunk-size is 2kB, because the NTTY
     * layer has problems with bigger chunks. It will
     * claim to be able to handle more characters than
     * it actually does.
     *
     * FIXME: This can probably go away now except that 64K chunks
     * are too likely to fail unless switched to vmalloc...
     */
    chunk = 2048;
    if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
        chunk = 65536;
    if (count < chunk)
        chunk = count;

    /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
    if (tty->write_cnt < chunk) {
        unsigned char *buf_chunk;

        if (chunk < 1024)
            chunk = 1024;

        buf_chunk = kmalloc(chunk, GFP_KERNEL);
        if (!buf_chunk) {
            ret = -ENOMEM;
            goto out;
        }
        kfree(tty->write_buf);
        tty->write_cnt = chunk;
        tty->write_buf = buf_chunk;
    }

/* Do the write ..
 * 这个过程会被阻塞吗？
 **/
    for (;;) {
        size_t size = count;
        if (size > chunk)
            size = chunk;
        ret = -EFAULT;
        if (copy_from_user(tty->write_buf, buf, size))
            break;
        ret = write(tty, file, tty->write_buf, size);
        if (ret <= 0)
            break;
        written += ret;
        buf += ret;
        count -= ret;
        if (!count)
            break;
        ret = -ERESTARTSYS;
        if (signal_pending(current))
            break;
        cond_resched();
    }
    if (written) {
        struct inode *inode = file->f_path.dentry->d_inode;
        inode->i_mtime = current_fs_time(inode->i_sb);
        ret = written;
    }
out:
    tty_write_unlock(tty);
    return ret;
}


/**
 *    n_tty_write        -    write function for tty
 *    @tty: tty device
 *    @file: file object
 *    @buf: userspace buffer pointer
 *    @nr: size of I/O
 **/
static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,
               const unsigned char *buf, size_t nr)
{
    const unsigned char *b = buf;
    DECLARE_WAITQUEUE(wait, current);
    int c;
    ssize_t retval = 0;

    add_wait_queue(&tty->write_wait, &wait);

    while (1) {
/* 设置状态TASK_INTERRUPTIBLE，应该并不会把进程设置为睡眠状态，直到schedule()
 *
 **/
        set_current_state(TASK_INTERRUPTIBLE);
        if (signal_pending(current)) {
            retval = -ERESTARTSYS;
            break;
        }

        while (nr > 0) {
            c = tty->ops->write(tty, b, nr);
            if (c < 0) {
                retval = c;
                goto break_out;
            }
            /* 如果这里写入数据为0，当前进程将会sleep,什么时候醒啊？
             * 这里看是存在隐患的。
             **/
            if (!c)
                break;
            b += c;
            nr -= c;
        }


        if (!nr)
            break;
        if (file->f_flags & O_NONBLOCK) {
            retval = -EAGAIN;
            break;
        }
        schedule();
    }
break_out:
    __set_current_state(TASK_RUNNING);
    remove_wait_queue(&tty->write_wait, &wait);
    if (b - buf != nr && tty->fasync)
        set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
    return (b - buf) ? b - buf : retval;
}

static int smd_tty_write(struct tty_struct *tty,
             const unsigned char *buf, int len)
{
    struct smd_tty_info *tty_info = tty->driver_data;
    int avail;
    dbg("enter %s\n",__func__);
    /* if we're writing to a packet channel we will
    ** never be able to write more data than there
    ** is currently space for
    */
    avail = smd_stream_write_avail(tty_info->ch);
    dbg("avail=%d\n", avail);
    if (len > avail)
        len = avail;

    if (len) {
        len = smd_stream_write(tty_info->ch, buf, len);
        smd_send_intr(tty_info->a2b_int_tx);
    }

    return len;
}

shuai_wen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tty_driver
04-06
4. **缓冲管理**：在硬件和用户空间程序之间，TTY驱动程序维护输入和输出缓冲区，确保数据传输的同步和高效。 5. **多任务支持**：在Linux中，多个进程可能同时尝试访问同一个TTY设备。驱动程序必须处理这种并发...
串口卡住问题分析与解决
孤独行者的专栏
03-15 2806
系统卡死问题分析
Linux tty驱动学习 - UART驱动的write操作流程
sbctsp的博客
01-06 8000
从tty核心层到最后把数据写入到硬件，整个操作流程如下：tty_write() -> do_tty_write() -> n_tty_write() -> uart_write() -> serial8250_start_tx() -> serial_out()。也就是从tty核心层到线路规程，然后到tty驱动层，再到UART驱动层，最后到UART端口的输出寄存器中。 首先看tty核心的写操作t
Linux UART 驱动 Part-2 （tty 层流程）
StephenZhou
08-13 3707
目录 1、Operations 1.1、file operation 1.2、tty operations 1.3、tty_ldisc_ops 1.4、uart_ops 2、Open 流程 3、Write 流程 3.1、tty_write 3.2、n_tty_write 3.3、uart_write 3.4、start_tx 4、Read 流程 4.1、tty_read ...
Linux设备模型之tty驱动架构分析
pan0755的博客
06-16 8157
Linux设备模型之tty驱动架构分析         一：前言 Tty这个名称源于电传打字节的简称。在linux表示各种终端。终端通常都跟硬件相对应。比如对应于输入设备键盘鼠标。输出设备显示器的控制 终端和串口终端.也有对应于不存在设备的pty驱动。在如此众多的终端模型之中，linux是怎么将它们统一建模的呢?这就是我
tty.zip_linux tty_linux tty_linux tty driver_tty_tty.zip
09-21
当我们提到"driver_tty_tty.zip"时，这可能是一个包含有关Linux TTY驱动程序源代码或文档的压缩包。这个压缩包可能包含了如何配置、编译和调试TTY驱动程序的信息，这对于开发者来说是非常宝贵的资源。通过分析和学习...
tty_driver.rar_between_linux tty
09-19
4. **流量控制**：为了防止数据溢出或过快的数据传输，TTY驱动必须实现流量控制机制，如xon/xoff（软件流控）或RTS/CTS/DTR/DSR（硬件流控）。 5. **信号处理**：TTY驱动也负责处理来自用户的信号，如中断(INTR)、...
tty_driver.rar_between_tty
09-19
This structure defines the interface between the low-level tty driver and the tty routines. The following routines can be defined unless noted otherwise, they are optional, and can be filled in with a...
tty_driver.rar_If..._linux tty_tty
09-14
"tty_driver.rar_If..._linux_tty_tty"这个标题暗示了我们正在讨论一个关于Linux TTY驱动程序的压缩包，可能包含源代码文件，如"tty_driver.c"。这个驱动程序是操作系统内核的一部分，它负责处理来自终端或模拟终端...
linux tty core code,linux tty core 源码分析（5）
weixin_30878051的博客
05-25 154
tty设备的读操作tty_write首先对读操作的需求做检查，然后调用ldisc->write操作默认即write_chain函数。wrtie_chain通过tty->ops->write或者tty->ops->flush_chars把数据写入到设备中，两者都实现时后者有限。其中write_room函数是用来检测缓存于空间./*** tty_write - writ...
LINUX设备驱动之tty及console驱动(二)
GangsterPan的专栏
03-27 2241
接着分析tty_read和tty_write函数。 0873       static ssize_t tty_read(struct file *file, char __user *buf, size_t count, 0874                            loff_t *ppos) 0875       { 0876              int i;
linux kernal pwn STARCTF 2019 hackme（二）劫持tty_struct ioctl && 劫持tty_struct write
yongbaoii的博客
04-20 373
承接上文
tty_read和tty_write
weixin_37303427的博客
01-29 1801
一、tty_read 对于tty_read这个函数，很多标志我也没有弄得太清楚，但是问题不大，以后有机会在看。我觉得重点是看数据怎么从cdc驱动到通过线路规划到tty，再从tty到用户空间。标志位等东西都是为这一个数据的流程服务的。 static ssize_t tty_read(struct file *file, char __user *buf, size_t count,      ...
Linux串口驱动分析write
xiong6034的专栏
04-27 428
文章来自：http://blog.csdn.net/longwang155069/article/details/42780331 /*和read的分析过程一样， 我们首先分析tty_write*/      /*最重要的就是do_tty_write函数。 前面都是一些合法性判断*/   static ssize_t tty_write(struct file *file, con
Line Disciplines
Tracy Mcgrady的专栏
05-29 1321
在Linux tty子系统中，Line Disciplines处在底层驱动与上层应用的之间，先来看一个例子：#include #include #include #include static int my_ldisc_tty_open(struct tty_struct *tty) { printk("%s\n", __func__); if (tty->ops->write
Linux终端和Line discipline图解
Netfilter
12-16 9224
昨晚的圣诞晚会嗨爆全场，灯光音响很棒，然而最终还是没有中奖…回到家已经午夜，喝了一瓶真露想再写篇关于终端的随笔以解惑，但不知不觉就困了，于是就睡了，早上本来想早起，自然醒来已经七点半了，醒来并没有意识到今天很冷，第一件事反而是想中午一家人去吃顿川味火锅底料，这也算是响应老板们的号召了。所以说，我必须在11点前把这篇文章写完。  Line discipline，到底翻译成行规程还是线路规程，没有统一的
内核调试工具ftrace
塔通天的博客
05-16 6628
文章目录1、ftrace基本介绍2、基本用法2.1、实例演示2.2、结构展示 1、ftrace基本介绍 ftrace 的作用是帮助开发人员了解 Linux 内核的运行时行为，以便进行故障调试或性能分析。 最早 ftrace 是一个 function tracer，仅能够记录内核的函数调用流程。如今 ftrace 已经成为一个 framework，采用 plugin 的方式支持开发人员添加更多种类的 trace 功能。 2、基本用法 首先编译内核，使内核支持ftrace。 通过以上配置，使得内核支持ftr
终端设备驱动之tty_write函数
思考的智慧，知识源于思考
05-11 5660
1、tty_write函数源码： static ssize_t tty_write(struct file * file, const char * buf, size_t count, loff_t *ppos) { int is_console; struct tty_struct * tty; struct inode *inode = file->f_dentry->d_ino
cat /proc/tty/driver/ttyAMA 数据解析
最新发布
03-27
/cat /proc/tty/driver/ttyAMA 是Linux系统中的一个文件路径，用于查看和解析ttyAMA驱动程序的相关信息。ttyAMA是指串行通信设备，通常用于与外部设备进行串行通信，比如串口设备。 在/cat /proc/tty/driver/ttyAMA...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值