【驅動】串口驅動分析(二)-tty core

tty這個名稱源于電傳打字節(jié)的簡稱，在linux表示各種終端，終端通常都跟硬件相對應。比如對應于輸入設備鍵盤鼠標，輸出設備顯示器的控制終端和串口終端。也有對應于不存在設備的pty驅動。在如此眾多的終端模型之中，linux是怎么將它們統(tǒng)一建模的呢？這就是我們今天要討論的問題。

tty驅動概貌

tty架構如下所示：

如上圖所示,用戶空間主要是通過系統(tǒng)調用與tty core交互。tty core根據(jù)用空間操作的類型再選擇跟line discipline和tty driver交互。

例如，設置硬件的ioctl指令就直接交給tty_driver處理。read和write操作就會交給 line discipline處理。

Line discipline是線路規(guī)程的意思。正如它的名字一樣，它表示的是這條終端”線程”的輸入與輸出規(guī)范設置。主要用來進行輸入/輸出數(shù)據(jù)的預處理。

處理之后，就會將數(shù)據(jù)交給tty driver ，它將字符轉換成終端可以理解的字串。將其傳給終端設備。

值得注意的是，這個架構沒有為tty driver 提供read操作。也就是說tty core 和line discipline都沒有辦法從tty driver里直接讀終端信息。這是因為tty driver對應的hardware并不一定是輸入數(shù)據(jù)和輸出 數(shù)據(jù)的共同負載者。

例如控制終端，輸出設備是顯示器，輸入設備是鍵盤?；谶@樣的原理。在line discipline中有一個輸入緩存區(qū)，并提供了一個名叫receive_buf()的接口函數(shù)。對應的終端設備只要調用line discipine的receiver_buf函數(shù)，將數(shù)據(jù)寫入到輸入緩存區(qū)就可以了。如果一個設備同時是輸入設備又是輸出設備。那在設備的中斷處理中調用receive_buf()將數(shù)據(jù)寫入即可.

tty驅動接口分析

tty_init()

/*
?*?Ok,?now?we?can?initialize?the?rest?of?the?tty?devices?and?can?count
?*?on?memory?allocations,?interrupts?etc..
?*/
int?__init?tty_init(void)
{
?tty_sysctl_init();
?cdev_init(&tty_cdev,?&tty_fops);
?if?(cdev_add(&tty_cdev,?MKDEV(TTYAUX_MAJOR,?0),?1)?||
?????register_chrdev_region(MKDEV(TTYAUX_MAJOR,?0),?1,?"/dev/tty")?<?0)
??panic("Couldn't?register?/dev/tty?drivern");
?device_create(tty_class,?NULL,?MKDEV(TTYAUX_MAJOR,?0),?NULL,?"tty");

?cdev_init(&console_cdev,?&console_fops);
?if?(cdev_add(&console_cdev,?MKDEV(TTYAUX_MAJOR,?1),?1)?||
?????register_chrdev_region(MKDEV(TTYAUX_MAJOR,?1),?1,?"/dev/console")?<?0)
??panic("Couldn't?register?/dev/console?drivern");
?consdev?=?device_create_with_groups(tty_class,?NULL,
?????????MKDEV(TTYAUX_MAJOR,?1),?NULL,
?????????cons_dev_groups,?"console");
?if?(IS_ERR(consdev))
??consdev?=?NULL;

#ifdef?CONFIG_VT
?vty_init(&console_fops);
#endif
?return?0;
}

tty_init主要做了以下工作：

1. 初始化 tty 子系統(tǒng)的 sysctl 相關設置，包括注冊 sysctl 參數(shù)、創(chuàng)建 sysctl 目錄等。初始化 tty 設備的字符設備對象，并將其與 tty 設備操作函數(shù)

tty_fops

1. 綁定。同時，創(chuàng)建一個名為 "tty" 的 tty 設備節(jié)點，并將其設備號設置為

MKDEV(TTYAUX_MAJOR, 0)

1. 。初始化控制臺設備的字符設備對象，并將其添加到字符設備系統(tǒng)中。同時，創(chuàng)建一個名為 "console" 的控制臺設備節(jié)點，并將其設備號設置為

MKDEV(TTYAUX_MAJOR, 1)

。該控制臺設備節(jié)點還將在 sysfs 中創(chuàng)建一個名為 "console" 的目錄，并在該目錄下創(chuàng)建多個屬性文件，用于控制控制臺的一些屬性。如果內(nèi)核支持虛擬終端，則初始化虛擬終端。

這里我們看到了熟悉的cdev_init(),device_create()之類的函數(shù)，這正是字符設備的創(chuàng)建流程。因此，我們說串口驅動也是一個字符設備驅動。

而在serial8250_init()中，會調用platform_driver_register()去注冊serial8250_isa_driver，在設備樹節(jié)點和serial8250_isa_driver name匹配的時候，就會進入probe流程。因此，也可以說串口驅動是總線設備驅動模型。

tty_alloc_driver

/*?Use?TTY_DRIVER_*?flags?below?*/
#define?tty_alloc_driver(lines,?flags)?
??__tty_alloc_driver(lines,?THIS_MODULE,?flags)

__tty_alloc_driver()用于分配一個 tty 驅動程序的數(shù)據(jù)結構 struct tty_driver，并對其一些常用字段進行初始化。

/**
?*?__tty_alloc_driver?--?allocate?tty?driver
?*?@lines:?count?of?lines?this?driver?can?handle?at?most
?*?@owner:?module?which?is?repsonsible?for?this?driver
?*?@flags:?some?of?TTY_DRIVER_*?flags,?will?be?set?in?driver->flags
?*
?*?This?should?not?be?called?directly,?some?of?the?provided?macros?should?be
?*?used?instead.?Use?IS_ERR?and?friends?on?@retval.
?*/
struct?tty_driver?*__tty_alloc_driver(unsigned?int?lines,?struct?module?*owner,
??unsigned?long?flags)
{
?struct?tty_driver?*driver;
?unsigned?int?cdevs?=?1;
?int?err;

?if?(!lines?||?(flags?&?TTY_DRIVER_UNNUMBERED_NODE?&&?lines?>?1))
??return?ERR_PTR(-EINVAL);
?
????/*分配一個?struct?tty_driver?結構體，并對其中的一些字段進行初始化，包括?num、owner、flags?等*/
?driver?=?kzalloc(sizeof(struct?tty_driver),?GFP_KERNEL);
?if?(!driver)
??return?ERR_PTR(-ENOMEM);

?kref_init(&driver->kref);
?driver->magic?=?TTY_DRIVER_MAGIC;
?driver->num?=?lines;
?driver->owner?=?owner;
?driver->flags?=?flags;
????
?/*如果?TTY_DRIVER_DEVPTS_MEM?標志位沒有被設置，那么函數(shù)會分配?driver->ttys?和?driver->termios，否則不需要分配*/
?if?(!(flags?&?TTY_DRIVER_DEVPTS_MEM))?{
??driver->ttys?=?kcalloc(lines,?sizeof(*driver->ttys),
????GFP_KERNEL);
??driver->termios?=?kcalloc(lines,?sizeof(*driver->termios),
????GFP_KERNEL);
??if?(!driver->ttys?||?!driver->termios)?{
???err?=?-ENOMEM;
???goto?err_free_all;
??}
?}
?
????/*如果?TTY_DRIVER_DYNAMIC_ALLOC?標志位沒有被設置，那么函數(shù)會分配?driver->ports，否則不需要分配*/
?if?(!(flags?&?TTY_DRIVER_DYNAMIC_ALLOC))?{
??driver->ports?=?kcalloc(lines,?sizeof(*driver->ports),
????GFP_KERNEL);
??if?(!driver->ports)?{
???err?=?-ENOMEM;
???goto?err_free_all;
??}
??cdevs?=?lines;
?}
????
?/*函數(shù)會根據(jù)?lines?的值分配相應數(shù)量的?driver->cdevs*/
?driver->cdevs?=?kcalloc(cdevs,?sizeof(*driver->cdevs),?GFP_KERNEL);
?if?(!driver->cdevs)?{
??err?=?-ENOMEM;
??goto?err_free_all;
?}

?return?driver;
err_free_all:
?kfree(driver->ports);
?kfree(driver->ttys);
?kfree(driver->termios);
?kfree(driver->cdevs);
?kfree(driver);
?return?ERR_PTR(err);
}

tty_register_driver

tty_register_driver用于注冊 tty 驅動程序的，被 tty 驅動程序調用以將自己注冊到內(nèi)核中。

/*
?*?Called?by?a?tty?driver?to?register?itself.
?*/
int?tty_register_driver(struct?tty_driver?*driver)
{
?int?error;
?int?i;
?dev_t?dev;
?struct?device?*d;
????
?/*確認是否要內(nèi)核動態(tài)分配主設備號*/
?if?(!driver->major)?{
????????/*函數(shù)調用?alloc_chrdev_region?函數(shù)來動態(tài)分配主設備號，并將分配的主設備號和次設備號保存在?driver->major?和?driver->minor_start?字段中*/
??error?=?alloc_chrdev_region(&dev,?driver->minor_start,
??????driver->num,?driver->name);
??if?(!error)?{
???driver->major?=?MAJOR(dev);
???driver->minor_start?=?MINOR(dev);
??}
?}?else?{
????????/*已經(jīng)預先分配了主設備號，函數(shù)調用?register_chrdev_region?函數(shù)來注冊設備號*/
??dev?=?MKDEV(driver->major,?driver->minor_start);
??error?=?register_chrdev_region(dev,?driver->num,?driver->name);
?}
?if?(error?<?0)
??goto?err;
?/*判斷是否設置了?TTY_DRIVER_DYNAMIC_ALLOC?標志位*/
?if?(driver->flags?&?TTY_DRIVER_DYNAMIC_ALLOC)?{
????????/*需要動態(tài)分配?tty?設備號，函數(shù)調用?tty_cdev_add?函數(shù)來添加?tty?設備號，并將每個?tty?設備的字符設備注冊到內(nèi)核中*/
??error?=?tty_cdev_add(driver,?dev,?0,?driver->num);
??if?(error)
???goto?err_unreg_char;
?}

?mutex_lock(&tty_mutex);
????/*將?driver?添加到鏈表?tty_drivers?中*/
?list_add(&driver->tty_drivers,?&tty_drivers);
?mutex_unlock(&tty_mutex);
????
?/*判斷?TTY_DRIVER_DYNAMIC_DEV?標志位是否設置*/
?if?(!(driver->flags?&?TTY_DRIVER_DYNAMIC_DEV))?{
??for?(i?=?0;?i?<?driver->num;?i++)?{
????????????/*需要注冊固定的?tty?設備號，函數(shù)在循環(huán)中調用?tty_register_device?函數(shù)來注冊每個?tty?設備號，并將每個?tty?設備注冊到內(nèi)核中*/
???d?=?tty_register_device(driver,?i,?NULL);
???if?(IS_ERR(d))?{
????error?=?PTR_ERR(d);
????goto?err_unreg_devs;
???}
??}
?}
????/*注冊?/proc/tty/drivers?目錄中的信息*/
?proc_tty_register_driver(driver);
????/*將?driver?結構體中的?flags?字段設置為?TTY_DRIVER_INSTALLED，表示該驅動程序已經(jīng)被成功注冊到內(nèi)核中*/
?driver->flags?|=?TTY_DRIVER_INSTALLED;
?return?0;

err_unreg_devs:
?for?(i--;?i?>=?0;?i--)
??tty_unregister_device(driver,?i);

?mutex_lock(&tty_mutex);
?list_del(&driver->tty_drivers);
?mutex_unlock(&tty_mutex);

err_unreg_char:
?unregister_chrdev_region(dev,?driver->num);
err:
?return?error;
}

tty_register_driver()函數(shù)操作比較簡單。就是為tty_driver創(chuàng)建字符設備。然后將字符設備的操作集指定為tty_fops。并且將tty_driver 掛載到tty_drivers鏈表中。這個鏈表中是以設備號為關鍵字找到對應的driver。

特別的。如果沒有定義TTY_DRIVER_DYNAMIC_DEV。還會在sysfs中創(chuàng)建一個類設備。這樣主要是為了udev管理設備。

tty_unregister_device

tty_unregister_device用于注銷一個 tty 設備。該函數(shù)的作用是銷毀設備節(jié)點和字符設備，以便于釋放與該 tty 設備相關的資源，例如內(nèi)存和設備文件等.

/**
?*??tty_unregister_device?-?unregister?a?tty?device
?*??@driver:?the?tty?driver?that?describes?the?tty?device
?*??@index:?the?index?in?the?tty?driver?for?this?tty?device
?*
?*??If?a?tty?device?is?registered?with?a?call?to?tty_register_device()?then
?*?this?function?must?be?called?when?the?tty?device?is?gone.
?*
?*?Locking:???
?*/

void?tty_unregister_device(struct?tty_driver?*driver,?unsigned?index)
{
?device_destroy(tty_class,
??MKDEV(driver->major,?driver->minor_start)?+?index);
?if?(!(driver->flags?&?TTY_DRIVER_DYNAMIC_ALLOC))?{
??cdev_del(driver->cdevs[index]);
??driver->cdevs[index]?=?NULL;
?}
}

tty_unregister_device所做工作如下：

1. 調用

device_destroy

1. 函數(shù)來銷毀 tty 設備對應的設備節(jié)點。接受兩個參數(shù)：第一個參數(shù)

tty_class

1. 表示 tty 類，第二個參數(shù)是 tty 設備的設備號，其中

MKDEV(driver->major, driver->minor_start) + index

1. 表示 tty 設備的設備號，

driver->major

1. 表示 tty 設備的主設備號，

driver->minor_start

1. 表示 tty 設備的次設備號的起始值，

index

1. 表示 tty 設備的索引如果該 tty 驅動程序不是動態(tài)分配的，則調用

cdev_del

函數(shù)來注銷該 tty 設備對應的字符設備。

get_tty_driver

get_tty_driver作用是在用戶空間的應用程序使用 tty 設備時，獲取對應的 tty 驅動程序的信息。

/**
?*?get_tty_driver??-?find?device?of?a?tty
?*?@dev_t:?device?identifier
?*?@index:?returns?the?index?of?the?tty
?*
?*?This?routine?returns?a?tty?driver?structure,?given?a?device?number
?*?and?also?passes?back?the?index?number.
?*
?*?Locking:?caller?must?hold?tty_mutex
?*/

static?struct?tty_driver?*get_tty_driver(dev_t?device,?int?*index)
{
?struct?tty_driver?*p;
?
????/**/
?list_for_each_entry(p,?&tty_drivers,?tty_drivers)?{
??dev_t?base?=?MKDEV(p->major,?p->minor_start);
??if?(device?<?base?||?device?>=?base?+?p->num)
???continue;
??*index?=?device?-?base;
??return?tty_driver_kref_get(p);
?}
?return?NULL;
}

首先使用 list_for_each_entry 循環(huán)遍歷全局鏈表 tty_drivers，該鏈表中保存了所有已經(jīng)注冊的 tty 驅動程序。對于每個 tty 驅動程序，函數(shù)將其設備號的起始值和結束值計算出來，如果給定設備號不在這個范圍內(nèi)，則繼續(xù)遍歷下一個 tty 驅動程序。

如果給定設備號在某個 tty 驅動程序的范圍內(nèi)，則計算出該設備號對應的 tty 設備的索引值，并調用 tty_driver_kref_get 函數(shù)來獲取該 tty 驅動程序的引用計數(shù)。函數(shù)返回該 tty 驅動程序的結構體指針，并將找到的 tty 設備的索引值保存到 index 參數(shù)中。

需要注意的是，函數(shù)在訪問全局鏈表 tty_drivers 時，需要持有互斥鎖 tty_mutex。因為多個應用程序可能同時訪問同一個 tty 驅動程序，如果沒有互斥鎖保護，可能會導致并發(fā)問題。

tty_open

從注冊的過程可以看到，所有的操作都會對應到tty_fops中。Open操作對應的操作接口是tty_open()，用于打開一個 tty 設備。函數(shù)的作用是在用戶空間的應用程序使用 tty 設備時，打開對應的 tty 設備，并初始化相應的數(shù)據(jù)結構。

/**
?*?tty_open??-?open?a?tty?device
?*?@inode:?inode?of?device?file
?*?@filp:?file?pointer?to?tty
?*
?*?tty_open?and?tty_release?keep?up?the?tty?count?that?contains?the
?*?number?of?opens?done?on?a?tty.?We?cannot?use?the?inode-count,?as
?*?different?inodes?might?point?to?the?same?tty.
?*
?*?Open-counting?is?needed?for?pty?masters,?as?well?as?for?keeping
?*?track?of?serial?lines:?DTR?is?dropped?when?the?last?close?happens.
?*?(This?is?not?done?solely?through?tty->count,?now.??-?Ted?1/27/92)
?*
?*?The?termios?state?of?a?pty?is?reset?on?first?open?so?that
?*?settings?don't?persist?across?reuse.
?*
?*?Locking:?tty_mutex?protects?tty,?tty_lookup_driver?and?tty_init_dev.
?*???tty->count?should?protect?the?rest.
?*???->siglock?protects?->signal/->sighand
?*
?*?Note:?the?tty_unlock/lock?cases?without?a?ref?are?only?safe?due?to
?*?tty_mutex
?*/

static?int?tty_open(struct?inode?*inode,?struct?file?*filp)
{
?struct?tty_struct?*tty;
?int?noctty,?retval;
?struct?tty_driver?*driver?=?NULL;
?int?index;
?dev_t?device?=?inode->i_rdev;
?unsigned?saved_flags?=?filp->f_flags;

?nonseekable_open(inode,?filp);

retry_open:
????/*分配一個?tty?結構體*/
?retval?=?tty_alloc_file(filp);
?if?(retval)
??return?-ENOMEM;
?
????/*檢查文件的標志位，如果包含?O_NOCTTY?標志，則禁止將該?tty?設備設置為控制終端*/
?noctty?=?filp->f_flags?&?O_NOCTTY;
?index??=?-1;
?retval?=?0;
?/*嘗試打開當前的?tty?設備*/
?tty?=?tty_open_current_tty(device,?filp);
?if?(!tty)?{
??mutex_lock(&tty_mutex);
????????/*根據(jù)設備號來查找對應的?tty?驅動程序，并初始化該?tty?設備，將找到的?tty?驅動程序保存到?driver?變量中*/
??driver?=?tty_lookup_driver(device,?filp,?&noctty,?&index);
??if?(IS_ERR(driver))?{
???retval?=?PTR_ERR(driver);
???goto?err_unlock;
??}

??/*?check?whether?we're?reopening?an?existing?tty?*/
????????/*查找對應的?tty?設備，并將找到的?tty?設備結構體指針保存到?tty?變量中*/
??tty?=?tty_driver_lookup_tty(driver,?inode,?index);
??if?(IS_ERR(tty))?{
???retval?=?PTR_ERR(tty);
???goto?err_unlock;
??}

??if?(tty)?{
????????????/*如果找到了該?tty?設備，則需要重新打開該?tty?設備*/
???mutex_unlock(&tty_mutex);
???retval?=?tty_lock_interruptible(tty);
???tty_kref_put(tty);??/*?drop?kref?from?tty_driver_lookup_tty()?*/
???if?(retval)?{
????if?(retval?==?-EINTR)
?????retval?=?-ERESTARTSYS;
????goto?err_unref;
???}
???retval?=?tty_reopen(tty);
???if?(retval?<?0)?{
????tty_unlock(tty);
????tty?=?ERR_PTR(retval);
???}
??}?else?{?/*?Returns?with?the?tty_lock?held?for?now?*/
????????????/*需要初始化該?tty?設備*/
???tty?=?tty_init_dev(driver,?index);
????????????/*為該?tty?設備分配一個?tty?結構體，并對其進行初始化*/
???mutex_unlock(&tty_mutex);
??}

??tty_driver_kref_put(driver);
?}

?if?(IS_ERR(tty))?{
??retval?=?PTR_ERR(tty);
??if?(retval?!=?-EAGAIN?||?signal_pending(current))
???goto?err_file;
??tty_free_file(filp);
??schedule();
??goto?retry_open;
?}
?/*將該?tty?設備與文件結構體相關聯(lián)*/
?tty_add_file(tty,?filp);

?check_tty_count(tty,?__func__);
????/*如果該?tty?設備是一個偽終端主設備，則需要將?noctty?標志設置為?1*/
?if?(tty->driver->type?==?TTY_DRIVER_TYPE_PTY?&&
?????tty->driver->subtype?==?PTY_TYPE_MASTER)
??noctty?=?1;

?tty_debug_hangup(tty,?"(tty?count=%d)n",?tty->count);
?
????/*調用?tty?設備的?open?函數(shù)*/
?if?(tty->ops->open)
??retval?=?tty->ops->open(tty,?filp);
?else
??retval?=?-ENODEV;
?filp->f_flags?=?saved_flags;

?if?(retval)?{
??tty_debug_hangup(tty,?"error?%d,?releasing...n",?retval);

??tty_unlock(tty);?/*?need?to?call?tty_release?without?BTM?*/
??tty_release(inode,?filp);
??if?(retval?!=?-ERESTARTSYS)
???return?retval;

??if?(signal_pending(current))
???return?retval;

??schedule();
??/*
???*?Need?to?reset?f_op?in?case?a?hangup?happened.
???*/
??if?(tty_hung_up_p(filp))
???filp->f_op?=?&tty_fops;
??goto?retry_open;
?}
?clear_bit(TTY_HUPPED,?&tty->flags);


?read_lock(&tasklist_lock);
?spin_lock_irq(&current->sighand->siglock);
?if?(!noctty?&&
?????current->signal->leader?&&
?????!current->signal->tty?&&
?????tty->session?==?NULL)?{
??/*
???*?Don't?let?a?process?that?only?has?write?access?to?the?tty
???*?obtain?the?privileges?associated?with?having?a?tty?as
???*?controlling?terminal?(being?able?to?reopen?it?with?full
???*?access?through?/dev/tty,?being?able?to?perform?pushback).
???*?Many?distributions?set?the?group?of?all?ttys?to?"tty"?and
???*?grant?write-only?access?to?all?terminals?for?setgid?tty
???*?binaries,?which?should?not?imply?full?privileges?on?all?ttys.
???*
???*?This?could?theoretically?break?old?code?that?performs?open()
???*?on?a?write-only?file?descriptor.?In?that?case,?it?might?be
???*?necessary?to?also?permit?this?if
???*?inode_permission(inode,?MAY_READ)?==?0.
???*/
??if?(filp->f_mode?&?FMODE_READ)
???__proc_set_tty(tty);
?}
?spin_unlock_irq(&current->sighand->siglock);
?read_unlock(&tasklist_lock);
?tty_unlock(tty);
?return?0;
err_unlock:
?mutex_unlock(&tty_mutex);
err_unref:
?/*?after?locks?to?avoid?deadlock?*/
?if?(!IS_ERR_OR_NULL(driver))
??tty_driver_kref_put(driver);
err_file:
?tty_free_file(filp);
?return?retval;
}

函數(shù)所作工作如下：

在打開 tty 設備時，該函數(shù)會檢查文件的標志位，如果包含 O_NOCTTY 標志，則禁止將該 tty 設備設置為控制終端。這是因為如果一個進程打開一個 tty 設備并將其設置為控制終端，其他進程就無法再將該 tty 設備設置為控制終端，這可能會導致一些問題。

如果打開當前的 tty 設備失敗，則需要根據(jù)設備號來查找對應的 tty 驅動程序，并初始化該 tty 設備。在查找 tty 驅動程序時，需要調用 tty_lookup_driver 函數(shù)來查找對應的 tty 驅動程序，并將找到的 tty 驅動程序保存到 driver 變量中。如果找不到對應的 tty 驅動程序，則返回錯誤碼。

如果找到了對應的 tty 驅動程序，則調用 tty_driver_lookup_tty 函數(shù)來查找對應的 tty 設備，并將找到的 tty 設備結構體指針保存到 tty 變量中。如果找到了該 tty 設備，則需要重新打開該 tty 設備。否則，需要初始化該 tty 設備。在初始化 tty 設備時，需要調用 tty_init_dev 函數(shù)來為該 tty 設備分配一個 tty 結構體，并對其進行初始化。

在打開 tty 設備之后，函數(shù)會調用 tty_add_file 函數(shù)將該 tty 設備與文件結構體相關聯(lián)。此外，如果該 tty 設備是一個偽終端主設備，則需要將 noctty 標志設置為 1。

最后，函數(shù)會調用 tty 設備的 open 函數(shù)，如果存在的話，來進行一些特定的操作。如果 open 函數(shù)返回錯誤碼，則需要釋放該 tty 設備并返回錯誤碼。如果 open 函數(shù)返回 -ERESTARTSYS，則需要重新打開該 tty 設備。如果有中斷發(fā)生，也需要重新打開該 tty 設備。

tty_write

tty_write()作用是將用戶數(shù)據(jù)寫入 tty 設備，并通過線路規(guī)則（line discipline）進行處理。

線路規(guī)則是 tty 設備的一種機制，用于處理和轉換從用戶進程到內(nèi)核和設備的數(shù)據(jù)流。在寫入 tty 設備之前，需要獲取該 tty 設備的線路規(guī)則，并調用其 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?tty_struct?*tty?=?file_tty(file);
??struct?tty_ldisc?*ld;
?ssize_t?ret;

?if?(tty_paranoia_check(tty,?file_inode(file),?"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;
}

tty_write()所作工作如下：

首先從文件指針中獲取tty_struct數(shù)據(jù)結構的指針，表示要寫入的 tty 設備。檢查傳入的tty_struct指針是否有效，以及是否有其他進程正在訪問該 tty 設備。如果出現(xiàn)問題，返回輸入/輸出錯誤碼-EIO。檢查tty_struct指針是否有效、tty 設備是否支持寫操作，以及是否已經(jīng)出現(xiàn)了輸入/輸出錯誤。如果出現(xiàn)問題，返回輸入/輸出錯誤碼-EIO。

檢查 tty 設備是否實現(xiàn)了write_room方法，如果沒有，則輸出錯誤信息。獲取 tty 設備的線路規(guī)則（line discipline），并等待獲取成功。檢查線路規(guī)則的write方法是否存在，如果不存在，返回輸入/輸出錯誤碼-EIO。否則，調用do_tty_write函數(shù)，將數(shù)據(jù)寫入 tty 設備。釋放線路規(guī)則引用計數(shù)器。返回寫入操作的結果，如果寫入成功，則返回寫入的字節(jié)數(shù)；否則，返回相應的錯誤碼。

tty_read

/**
?*?tty_read?-?read?method?for?tty?device?files
?*?@file:?pointer?to?tty?file
?*?@buf:?user?buffer
?*?@count:?size?of?user?buffer
?*?@ppos:?unused
?*
?*?Perform?the?read?system?call?function?on?this?terminal?device.?Checks
?*?for?hung?up?devices?before?calling?the?line?discipline?method.
?*
?*?Locking:
?*??Locks?the?line?discipline?internally?while?needed.?Multiple
?*?read?calls?may?be?outstanding?in?parallel.
?*/

static?ssize_t?tty_read(struct?file?*file,?char?__user?*buf,?size_t?count,
???loff_t?*ppos)
{
?int?i;
?struct?inode?*inode?=?file_inode(file);
?struct?tty_struct?*tty?=?file_tty(file);
?struct?tty_ldisc?*ld;

?if?(tty_paranoia_check(tty,?inode,?"tty_read"))
??return?-EIO;
?if?(!tty?||?(test_bit(TTY_IO_ERROR,?&tty->flags)))
??return?-EIO;

?/*?We?want?to?wait?for?the?line?discipline?to?sort?out?in?this
????situation?*/
?ld?=?tty_ldisc_ref_wait(tty);
?if?(ld->ops->read)
??i?=?ld->ops->read(tty,?file,?buf,?count);
?else
??i?=?-EIO;
?tty_ldisc_deref(ld);

?if?(i?>?0)
??tty_update_time(&inode->i_atime);

?return?i;
}

tty_read()實現(xiàn)終端設備文件讀操作的函數(shù) 。

獲取tty_struct結構體、inode和line discipline對象的指針。調用tty_paranoia_check()函數(shù)檢查tty_struct結構體是否可用。如果檢查失敗，返回 -EIO。檢查tty_struct結構體是否為空或者TTY_IO_ERROR標志位已經(jīng)設置。如果是，則返回 -EIO。

獲取line discipline對象的引用，確保它不會在tty_read()函數(shù)執(zhí)行期間被卸載。檢查line discipline的read()方法是否可用。如果可用，則調用該方法進行讀取操作，并將返回的字節(jié)數(shù)保存在變量 i 中。如果不可用，返回 -EIO。釋放line discipline的引用。如果讀取操作成功，調用tty_update_time()函數(shù)更新 inode 的訪問時間。返回讀取的字節(jié)數(shù)。

小結

在這一節(jié)里，只對tty的構造做一個分析，具體的比如線路規(guī)程的內(nèi)容我們了解知道就好，這里不做深入分析。

本文參考

https://blog.csdn.net/pan0755/article/details/51693178

https://blog.csdn.net/qq_43286311/article/details/117824804

https://www.jianshu.com/p/09e87a725ed4

https://blog.csdn.net/weixin_40407893/article/details/117956968

https://blog.csdn.net/pan0755/article/details/51693178