linux kernel下输入输出console如何实现

最近工作在调试usb虚拟串口，让其作为kernel启动的调试串口，以及user空间的输入输出控制台。

利用这个机会，学习下printk如何选择往哪个console输出以及user空间下控制台如何选择，记录与此，与大家共享，也方便自己以后翻阅。

Kernel版本号：3.4.55

依照我的思路（还是时间顺序）分了4部分，指定kernel调试console ，  kernel下printk console的选择 ，kernel下console的注册，user空间console的选择。

一 指定kernel调试console

首先看kernel启动时如何获取和处理指定的console参数。

kernel的启动参数cmdline可以指定调试console，如指定‘console=ttyS0,115200’,

kernel如何解析cmdline，我之前写了一篇博文如下：

http://blog.csdn.net/skyflying2012/article/details/41142801

根据之前的分析，cmdline中有console=xxx，start_kernel中parse_args遍历.init.setup段所有obs_kernel_param。

kernel/printk.c中注册了‘console=’的解析函数console_setup（注册了obs_kernel_param），所以匹配成功，会调用console_setup来解析，如下：

[cpp] view plain copy
 
  1. static int __init console_setup(char *str)  
  2. {  
  3.     char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for index */  
  4.     char *s, *options, *brl_options = NULL;  
  5.     int idx;   
  6.   
  7. #ifdef CONFIG_A11Y_BRAILLE_CONSOLE  
  8.     if (!memcmp(str, "brl,", 4)) {  
  9.         brl_options = "";  
  10.         str += 4;  
  11.     } else if (!memcmp(str, "brl=", 4)) {  
  12.         brl_options = str + 4;   
  13.         str = strchr(brl_options, ',');  
  14.         if (!str) {  
  15.             printk(KERN_ERR "need port name after brl= ");  
  16.             return 1;  
  17.         }      
  18.         *(str++) = 0;   
  19.     }      
  20. #endif  
  21.   
  22.     /* 
  23.      * Decode str into name, index, options. 
  24.      */  
  25.     if (str[0] >= '0' && str[0] <= '9') {  
  26.         strcpy(buf, "ttyS");  
  27.         strncpy(buf + 4, str, sizeof(buf) - 5);  
  28.     } else {  
  29.         strncpy(buf, str, sizeof(buf) - 1);  
  30.     }  
  31.     buf[sizeof(buf) - 1] = 0;  
  32.     if ((options = strchr(str, ',')) != NULL)  
  33.         *(options++) = 0;  
  34. #ifdef __sparc__  
  35.     if (!strcmp(str, "ttya"))  
  36.         strcpy(buf, "ttyS0");  
  37.     if (!strcmp(str, "ttyb"))  
  38.         strcpy(buf, "ttyS1");  
  39. #endif  
  40.     for (s = buf; *s; s++)  
  41.         if ((*s >= '0' && *s <= '9') || *s == ',')  
  42.             break;  
  43.     idx = simple_strtoul(s, NULL, 10);  
  44.     *s = 0;  
  45.   
  46.     __add_preferred_console(buf, idx, options, brl_options);  
  47.     console_set_on_cmdline = 1;  
  48.     return 1;  
  49. }  
  50. __setup("console=", console_setup);  


参数是console=的值字符串，如“ttyS0,115200”,console_setup对console=参数值做解析，以ttyS0,115200为例，最后buf=“ttyS”，idx=0,options="115200",brl_options=NULL。调用__add_preferred_console如下：







[cpp] view plain copy

 






    

  1. /* 
    2. 

  2.  * If exclusive_console is non-NULL then only this console is to be printed to. 
    3. 

  3.  */  
    4. 

  4. static struct console *exclusive_console;  
    5. 

  5.   
    6. 

  6. /* 
    7. 

  7.  *  Array of consoles built from command line options (console=) 
    8. 

  8.  */  
    9. 

  9. struct console_cmdline  
    10. 

  10. {                    
    11. 

  11.     char    name[8];            /* Name of the driver       */  
    12. 

  12.     int index;              /* Minor dev. to use        */  
    13. 

  13.     char    *options;           /* Options for the driver   */  
    14. 

  14. #ifdef CONFIG_A11Y_BRAILLE_CONSOLE  
    15. 

  15.     char    *brl_options;           /* Options for braille driver */  
    16. 

  16. #endif  
    17. 

  17. };  
    18. 

  18.   
    19. 

  19. #define MAX_CMDLINECONSOLES 8  
    20. 

  20.           
    21. 

  21. static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];  
    22. 

  22. static int selected_console = -1;  
    23. 

  23. static int preferred_console = -1;  
    24. 

  24. int console_set_on_cmdline;  
    25. 

  25. EXPORT_SYMBOL(console_set_on_cmdline);  
    26. 

  26. static int __add_preferred_console(char *name, int idx, char *options,  
    27. 

  27.                    char *brl_options)  
    28. 

  28. {  
    29. 

  29.     struct console_cmdline *c;  
    30. 

  30.     int i;  
    31. 

  31.   
    32. 

  32.     /* 
    33. 

  33.      *  See if this tty is not yet registered, and 
    34. 

  34.      *  if we have a slot free. 
    35. 

  35.      */  
    36. 

  36.     for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0]; i++)  
    37. 

  37.         if (strcmp(console_cmdline[i].name, name) == 0 &&  
    38. 

  38.               console_cmdline[i].index == idx) {  
    39. 

  39.                 if (!brl_options)  
    40. 

  40.                     selected_console = i;  
    41. 

  41.                 return 0;  
    42. 

  42.         }  
    43. 

  43.     if (i == MAX_CMDLINECONSOLES)  
    44. 

  44.         return -E2BIG;  
    45. 

  45.     if (!brl_options)  
    46. 

  46.         selected_console = i;  
    47. 

  47.     c = &console_cmdline[i];  
    48. 

  48.     strlcpy(c->name, name, sizeof(c->name));  
    49. 

  49.     c->options = options;  
    50. 

  50. #ifdef CONFIG_A11Y_BRAILLE_CONSOLE  
    51. 

  51.     c->brl_options = brl_options;  
    52. 

  52. #endif  
    53. 

  53.     c->index = idx;  
    54. 

  54.     return 0;  
    55. 

  55. }  
    56. 







kernel利用结构体数组console_cmdline[8],最多可支持8个cmdline传入的console参数。


__add_preferred_console将name idx options保存到数组下一个成员console_cmdline结构体中，如果数组中已有重名，则不添加，并置selected_console为最新添加的console_cmdline的下标号。


比如cmdline中有“console=ttyS0,115200 console=ttyS1,9600”


则在console_cmdline[8]数组中console_cmdline[0]代表ttyS0，console_cmdline[1]代表ttyS1，而selected_console=1.



二 kernel下printk console的选择


kernel下调试信息是通过printk输出，如果要kernel正常打印，则需要搞明白printk怎么选择输出的设备。


关于printk的实现原理，我在刚工作的时候写过一篇博文，kernel版本是2.6.21的，但是原理还是一致的，可供参考：


http://blog.csdn.net/skyflying2012/article/details/7970341


printk首先将输出内容添加到一个kernel缓冲区中，叫log_buf，log_buf相关代码如下：







[cpp] view plain copy

 






    

  1. #define MAX_CMDLINECONSOLES 8  
    2. 

  2.   
    3. 

  3. static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];  
    4. 

  4. static int selected_console = -1;  
    5. 

  5. static int preferred_console = -1;  
    6. 

  6. int console_set_on_cmdline;  
    7. 

  7. EXPORT_SYMBOL(console_set_on_cmdline);  
    8. 

  8.   
    9. 

  9. /* Flag: console code may call schedule() */  
    10. 

  10. static int console_may_schedule;  
    11. 

  11.   
    12. 

  12. #ifdef CONFIG_PRINTK  
    13. 

  13.           
    14. 

  14. static char __log_buf[__LOG_BUF_LEN];  
    15. 

  15. static char *log_buf = __log_buf;  
    16. 

  16. static int log_buf_len = __LOG_BUF_LEN;  
    17. 

  17. static unsigned logged_chars; /* Number of chars produced since last read+clear operation */  
    18. 

  18. static int saved_console_loglevel = -1;  
    19. 





log_buf的大小由kernel menuconfig配置，我配置的CONFIG_LOG_BUF_SHIFT为17，则log_buf为128k。



printk内容会一直存在log_buf中，log_buf满了之后则会从头在开始存，覆盖掉原来的数据。


根据printk的实现原理，printk最后调用console_unlock实现log_buf数据刷出到指定设备。


这里先不关心printk如何处理log buf数据(比如添加内容级别)，只关心printk如何一步步找到指定的输出设备，根据printk.c代码，可以找到如下线索。


printk->vprintk->console_unlock->call_console_drivers->_call_console_drivers->_call_console_drivers->__call_console_drivers


看线索最底层__call_console_drivers代码。如下：







[cpp] view plain copy

 






    

  1. /* 
    2. 

  2.  * Call the console drivers on a range of log_buf 
    3. 

  3.  */  
    4. 

  4. static void __call_console_drivers(unsigned start, unsigned end)  
    5. 

  5. {  
    6. 

  6.     struct console *con;  
    7. 

  7.   
    8. 

  8.     for_each_console(con) {  
    9. 

  9.         if (exclusive_console && con != exclusive_console)  
    10. 

  10.             continue;  
    11. 

  11.         if ((con->flags & CON_ENABLED) && con->write &&  
    12. 

  12.                 (cpu_online(smp_processor_id()) ||  
    13. 

  13.                 (con->flags & CON_ANYTIME)))  
    14. 

  14.             con->write(con, &LOG_BUF(start), end - start);  
    15. 

  15.     }  
    16. 

  16. }  
    17. 



for_each_console定义如下：







[cpp] view plain copy

 






    

  1. /*           
    2. 

  2.  * for_each_console() allows you to iterate on each console 
    3. 

  3.  */               
    4. 

  4. #define for_each_console(con)   
    5. 

  5.     for (con = console_drivers; con != NULL; con = con->next)  
    6. 



遍历console_drivers链表所有console struct，如果有exclusive_console，则调用与exclusive_console一致console的write，


如果exclusive_console为NULL，则调用所有ENABLE的console的write方法将log buf中start到end的内容发出。


可以看出，execlusive_console来指定printk输出唯一console，如果未指定，则向所有enable的console写。


默认情况下execlusive_console=NULL，所以printk默认是向所有enable的console写！


只有一种情况是指定execlusive_console，就是在console注册时，下面会讲到。


到这里就很明了了，kernel下每次printk打印，首先存log_buf，然后遍历console_drivers，找到合适console(execlusive_console或所有enable的)，刷出log。


console_drivers链表的成员是哪里来的，谁会指定execulsive_console？接着来看下一部分，kernel下console的注册



三 kernel下console的注册


上面分析可以看出，作为kernel移植最基本的一步，kernel下printk正常输出，最重要的一点是在console_drivers链表中添加console struct。那谁来完成这个工作？


答案是register_console函数，在printk.c中，下面来分析下该函数。







[cpp] view plain copy

 






    

  1. void register_console(struct console *newcon)  
    2. 

  2. {  
    3. 

  3.     int i;  
    4. 

  4.     unsigned long flags;  
    5. 

  5.     struct console *bcon = NULL;  
    6. 

  6.   
    7. 

  7.     //如果注册的是bootconsole（kernel早期启动打印），需要检查console_drivers中  
    8. 

  8.     //没有“real console”也就是说bootconsole必须是第一个注册的console。  
    9. 

  9.     if (console_drivers && newcon->flags & CON_BOOT) {  
    10. 

  10.         /* find the last or real console */  
    11. 

  11.         for_each_console(bcon) {  
    12. 

  12.             if (!(bcon->flags & CON_BOOT)) {  
    13. 

  13.                 printk(KERN_INFO "Too late to register bootconsole %s%d
",  
    14. 

  14.                     newcon->name, newcon->index);  
    15. 

  15.                 return;  
    16. 

  16.             }  
    17. 

  17.         }  
    18. 

  18.     }  
    19. 

  19.   
    20. 

  20.     if (console_drivers && console_drivers->flags & CON_BOOT)  
    21. 

  21.         bcon = console_drivers;  
    22. 

  22.   
    23. 

  23.     //preferred console为console_cmdline中最后一个console  
    24. 

  24.     if (preferred_console < 0 || bcon || !console_drivers)  
    25. 

  25.         preferred_console = selected_console;  
    26. 

  26.   
    27. 

  27.     if (newcon->early_setup)  
    28. 

  28.         newcon->early_setup();  
    29. 

  29.   
    30. 

  30.     if (preferred_console < 0) {  
    31. 

  31.         if (newcon->index < 0)  
    32. 

  32.             newcon->index = 0;  
    33. 

  33.         if (newcon->setup == NULL ||  
    34. 

  34.             newcon->setup(newcon, NULL) == 0) {  
    35. 

  35.             newcon->flags |= CON_ENABLED;  
    36. 

  36.             if (newcon->device) {  
    37. 

  37.                 newcon->flags |= CON_CONSDEV;  
    38. 

  38.                 preferred_console = 0;  
    39. 

  39.             }  
    40. 

  40.         }  
    41. 

  41.     }  
    42. 

  42.   
    43. 

  43.     //检查newcon是否是cmdline指定的console，如果是，则使能(CON_ENABLE)并初始化该console  
    44. 

  44.     for (i = 0; i < MAX_CMDLINECONSOLES && console_cmdline[i].name[0];  
    45. 

  45.             i++) {  
    46. 

  46.         if (strcmp(console_cmdline[i].name, newcon->name) != 0)  
    47. 

  47.             continue;  
    48. 

  48.         if (newcon->index >= 0 &&  
    49. 

  49.             newcon->index != console_cmdline[i].index)  
    50. 

  50.             continue;  
    51. 

  51.         if (newcon->index < 0)  
    52. 

  52.             newcon->index = console_cmdline[i].index;  
    53. 

  53. #ifdef CONFIG_A11Y_BRAILLE_CONSOLE  
    54. 

  54.         if (console_cmdline[i].brl_options) {  
    55. 

  55.             newcon->flags |= CON_BRL;  
    56. 

  56.             braille_register_console(newcon,  
    57. 

  57.                     console_cmdline[i].index,  
    58. 

  58.                     console_cmdline[i].options,  
    59. 

  59.                     console_cmdline[i].brl_options);  
    60. 

  60.             return;  
    61. 

  61.         }  
    62. 

  62. #endif  
    63. 

  63.         if (newcon->setup &&  
    64. 

  64.             newcon->setup(newcon, console_cmdline[i].options) != 0)  
    65. 

  65.             break;  
    66. 

  66.         newcon->flags |= CON_ENABLED;  
    67. 

  67.         newcon->index = console_cmdline[i].index;  
    68. 

  68.         if (i == selected_console) {  
    69. 

  69.             //如果newcon是cmdline指定的最新的console，则置位CONSDEV  
    70. 

  70.             newcon->flags |= CON_CONSDEV;  
    71. 

  71.             preferred_console = selected_console;  
    72. 

  72.         }  
    73. 

  73.         break;  
    74. 

  74.     }  
    75. 

  75.   
    76. 

  76.     //该console没有使能，退出  
    77. 

  77.     if (!(newcon->flags & CON_ENABLED))  
    78. 

  78.         return;  
    79. 

  79.   
    80. 

  80.     //如果有bootconsole，则newcon不需要输出register之前的log，因为如果bootconsole和newcon是同一个设备  
    81. 

  81.     //则之前的log就输出2次  
    82. 

  82.     if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))  
    83. 

  83.         newcon->flags &= ~CON_PRINTBUFFER;  
    84. 

  84.   
    85. 

  85.     //把newcon加入console_drivers链表，对于置位CON_CONSDEV的con，放在链表首  
    86. 

  86.     console_lock();  
    87. 

  87.     if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {  
    88. 

  88.         newcon->next = console_drivers;  
    89. 

  89.         console_drivers = newcon;  
    90. 

  90.         if (newcon->next)  
    91. 

  91.             newcon->next->flags &= ~CON_CONSDEV;  
    92. 

  92.     } else {  
    93. 

  93.         newcon->next = console_drivers->next;  
    94. 

  94.         console_drivers->next = newcon;  
    95. 

  95.     }  
    96. 

  96.     if (newcon->flags & CON_PRINTBUFFER) {  
    97. 

  97.         //如果newcon置位PRINTBUFFER,则将log全部刷出  
    98. 

  98.         raw_spin_lock_irqsave(&logbuf_lock, flags);  
    99. 

  99.         con_start = log_start;  
    100. 

  100.         raw_spin_unlock_irqrestore(&logbuf_lock, flags);  
    101. 

  101.         //修改printk输出的指定唯一exclusive_console为newcon  
    102. 

  102.         //保证将之前的log只输出到newcon  
    103. 

  103.         exclusive_console = newcon;  
    104. 

  104.     }  
    105. 

  105.     //解锁console，刷出log到newcon  
    106. 

  106.     console_unlock();  
    107. 

  107.     console_sysfs_notify();  
    108. 

  108.   
    109. 

  109.     //如果有bootconsole，则unregister bootconsole（从console_drivers中删掉）  
    110. 

  110.     //并告诉使用者现在console切换  
    111. 

  111.     if (bcon &&  
    112. 

  112.         ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&  
    113. 

  113.         !keep_bootcon) {  
    114. 

  114.         /* we need to iterate through twice, to make sure we print 
    115. 

  115.          * everything out, before we unregister the console(s) 
    116. 

  116.          */  
    117. 

  117.         printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled
",  
    118. 

  118.             newcon->name, newcon->index);  
    119. 

  119.         for_each_console(bcon)  
    120. 

  120.             if (bcon->flags & CON_BOOT)  
    121. 

  121.                 unregister_console(bcon);  
    122. 

  122.     } else {  
    123. 

  123.         printk(KERN_INFO "%sconsole [%s%d] enabled
",  
    124. 

  124.             (newcon->flags & CON_BOOT) ? "boot" : "" ,  
    125. 

  125.             newcon->name, newcon->index);  
    126. 

  126.     }  
    127. 

  127. }  
    128. 





如果之前注册了bootconsole，则不会将该次register之前的log刷出，防止bootconsole和该次注册的newcon是同一个物理设备时，log打印2次。


如果没有bootconsole，则会指定exclusive_console=newcon，console_unlock时，刷新全部log到该指定exclusive console。


console_unlock结束时会将exclusive_console置NULL，所以exclusive console默认情况下就是NULL。


最后会unregister bootconsole，是将bootconsole从console_drivers中删除，这样之后的printk就不会想bootconsole输出了。


有意思的一个地方是，在unregister bootconsole之前的printk：







[cpp] view plain copy

 






    

  1. printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled
",  
    2. 

  2.             newcon->name, newcon->index);  
    3. 



因为此时bootconsole还没删掉，而newconsole已经加入console_drivers，如果bootconsole和newconsole是同一个物理设备，我们会看到这句printk会出现2次哦！




如果在cmdline指定2个I/O设备，如“console==ttyS0,115200 console=ttyS1,115200”，因ttyS设备都是serial driver中注册的real console，所以会看到kernel的打印分别出现在2个串口上！


boot console和real console差别在于bootconsole注册于kernel启动早期，方便对于kernel早期启动进行调试打印。


那这些console是在哪里调用register_console进行注册的？


bootconsole的注册，如arch/arm/kernel/early_printk.c，是在parse_args参数解析阶段注册bootconsole。


在start_kernel中console_init函数也会遍历.con_initcall.init段中所有注册函数，而这些注册函数也可以来注册bootconsole。


.con_initcall.init段中函数的注册可以使用宏定义console_initcall。这些函数中调用register_console，方便在kernel初期实现printk打印。


realconsole的注册，是在各个driver，如serial加载时完成。


经过上面分析，对于一个新实现的输入输出设备，如果要将其作为kernel下的printk调试输出设备，需要2步：


（1）register console，console struct如下：







[cpp] view plain copy

 








    

  1. struct console {  
    2. 

  2.     char    name[16];  
    3. 

  3.     void    (*write)(struct console *, const char *, unsigned);  
    4. 

  4.     int (*read)(struct console *, char *, unsigned);  
    5. 

  5.     struct tty_driver *(*device)(struct console *, int *);   
    6. 

  6.     void    (*unblank)(void);  
    7. 

  7.     int (*setup)(struct console *, char *);   
    8. 

  8.     int (*early_setup)(void);  
    9. 

  9.     short   flags;  
    10. 

  10.     short   index;  
    11. 

  11.     int cflag;  
    12. 

  12.     void    *data;  
    13. 

  13.     struct   console *next;  
    14. 

  14. };  
    15. 





定义一个console，因为kernel调试信息是单向的，没有交互，所以只需要实现write即可，还需要实现setup函数，进行设备初始化（如设置波特率等），以及标志位flags（将所有log刷出），举个例子，如下：








[cpp] view plain copy

 








    

  1. static struct console u_console =  
    2. 

  2. {  
    3. 

  3.     .name       = "ttyS",  
    4. 

  4.     .write      = u_console_write,  
    5. 

  5.     .setup      = u_console_setup,  
    6. 

  6.     .flags      = CON_PRINTBUFFER,  
    7. 

  7.     .index      = 0,  
    8. 

  8.     .data       = &u_reg,  
    9. 

  9. };static int __init  
    10. 

  10. u_console_init(void)  
    11. 

  11. {  
    12. 

  12.     register_console(&u_console);  
    13. 

  13.     return 0;  
    14. 

  14. }  
    15. 







为了调试方便，可以在console_init调用该函数进行注册，则需要







[cpp] view plain copy

 






    

  1. console_initcall(u_console_init);  
    2. 



也可以在kernel加载driver时调用，则需要在driver的probe时调用u_console_init，但是这样只能等driver调register_console之后，console_unlock才将所有log刷出，之前的log都会存在log buf中。



（2）cmdline指定调试console，在kernel的cmdline添加参数console=ttyS0,115200




四 user空间console的选择


用户空间的输入输出依赖于其控制台使用的哪个，这里有很多名词，如控制台，tty，console等，这些名字我也很晕，不用管他们的真正含义，搞嵌入式，直接找到它的实现，搞明白从最上层软件，到最底层硬件，如何操作，还有什么会不清楚呢。


在start_kernel中最后起内核init进程时，如下：







[cpp] view plain copy

 








    

  1. /* Open the /dev/console on the rootfs, this should never fail */  
    2. 

  2.     if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)  
    3. 

  3.         printk(KERN_WARNING "Warning: unable to open an initial console.
");  
    4. 

  4.   
    5. 

  5.     (void) sys_dup(0);  
    6. 

  6.     (void) sys_dup(0);  
    7. 





去打开console设备，console设备做了控制台。



console设备文件的创建在driver/tty/tty_io.c中，如下：







[cpp] view plain copy

 








    

  1. static const struct file_operations console_fops = {  
    2. 

  2.     .llseek     = no_llseek,  
    3. 

  3.     .read       = tty_read,  
    4. 

  4.     .write      = redirected_tty_write,  
    5. 

  5.     .poll       = tty_poll,  
    6. 

  6.     .unlocked_ioctl = tty_ioctl,  
    7. 

  7.     .compat_ioctl   = tty_compat_ioctl,  
    8. 

  8.     .open       = tty_open,  
    9. 

  9.     .release    = tty_release,  
    10. 

  10.     .fasync     = tty_fasync,  
    11. 

  11. };  
    12. 

  12. int __init tty_init(void)  
    13. 

  13. {  
    14. 

  14.     cdev_init(&tty_cdev, &tty_fops);  
    15. 

  15.     if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||  
    16. 

  16.         register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)  
    17. 

  17.         panic("Couldn't register /dev/tty driver
");  
    18. 

  18.     device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");  
    19. 

  19.   
    20. 

  20.     cdev_init(&console_cdev, &console_fops);  
    21. 

  21.     if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||  
    22. 

  22.         register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)  
    23. 

  23.         panic("Couldn't register /dev/console driver
");  
    24. 

  24.     consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,  
    25. 

  25.                   "console");  
    26. 

  26.     if (IS_ERR(consdev))  
    27. 

  27.         consdev = NULL;  
    28. 

  28.     else  
    29. 

  29.         WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);  
    30. 

  30.       
    31. 

  31. #ifdef CONFIG_VT  
    32. 

  32.     vty_init(&console_fops);  
    33. 

  33. #endif  
    34. 

  34.     return 0;  
    35. 

  35. }  
    36. 








console的操作函数都是使用的tty的操作函数，看open的实现，如何找到具体的操作设备：








[cpp] view plain copy

 






    

  1. static int tty_open(struct inode *inode, struct file *filp)  
    2. 

  2. {  
    3. 

  3.     struct tty_struct *tty;  
    4. 

  4.     int noctty, retval;  
    5. 

  5.     struct tty_driver *driver = NULL;  
    6. 

  6.     int index;  
    7. 

  7.     dev_t device = inode->i_rdev;  
    8. 

  8.     unsigned saved_flags = filp->f_flags;  
    9. 

  9.       
    10. 

  10.     nonseekable_open(inode, filp);  
    11. 

  11.   
    12. 

  12. retry_open:  
    13. 

  13.     retval = tty_alloc_file(filp);  
    14. 

  14.     if (retval)   
    15. 

  15.         return -ENOMEM;  
    16. 

  16.       
    17. 

  17.     noctty = filp->f_flags & O_NOCTTY;  
    18. 

  18.     index  = -1;  
    19. 

  19.     retval = 0;  
    20. 

  20.   
    21. 

  21.     mutex_lock(&tty_mutex);  
    22. 

  22.     tty_lock();  
    23. 

  23.   
    24. 

  24.     tty = tty_open_current_tty(device, filp);  
    25. 

  25.     if (IS_ERR(tty)) {  
    26. 

  26.         retval = PTR_ERR(tty);  
    27. 

  27.         goto err_unlock;  
    28. 

  28.     } else if (!tty) {  
    29. 

  29.         driver = tty_lookup_driver(device, filp, &noctty, &index);  
    30. 

  30.         if (IS_ERR(driver)) {  
    31. 

  31.             retval = PTR_ERR(driver);  
    32. 

  32.             goto err_unlock;  
    33. 

  33.         }  /* check whether we're reopening an existing tty */  
    34. 

  34.         tty = tty_driver_lookup_tty(driver, inode, index);  
    35. 

  35.         if (IS_ERR(tty)) {  
    36. 

  36.             retval = PTR_ERR(tty);  
    37. 

  37.             goto err_unlock;  
    38. 

  38.         }  
    39. 

  39.     }  
    40. 



}





首先tty_open_current_tty找该进程所对应的tty，因为init进程我们并没有制定tty，所以该函数返回NULL。



接下来调用tty_lookup_driver，如下：







[cpp] view plain copy

 






    

  1. static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,  
    2. 

  2.         int *noctty, int *index)  
    3. 

  3. {  
    4. 

  4.     struct tty_driver *driver;  
    5. 

  5.   
    6. 

  6.     switch (device) {  
    7. 

  7. #ifdef CONFIG_VT  
    8. 

  8.     case MKDEV(TTY_MAJOR, 0): {  
    9. 

  9.         extern struct tty_driver *console_driver;  
    10. 

  10.         driver = tty_driver_kref_get(console_driver);  
    11. 

  11.         *index = fg_console;  
    12. 

  12.         *noctty = 1;  
    13. 

  13.         break;  
    14. 

  14.     }  
    15. 

  15. #endif  
    16. 

  16.     case MKDEV(TTYAUX_MAJOR, 1): {  
    17. 

  17.         struct tty_driver *console_driver = console_device(index);  
    18. 

  18.         if (console_driver) {  
    19. 

  19.             driver = tty_driver_kref_get(console_driver);  
    20. 

  20.             if (driver) {  
    21. 

  21.                 /* Don't let /dev/console block */  
    22. 

  22.                 filp->f_flags |= O_NONBLOCK;  
    23. 

  23.                 *noctty = 1;  
    24. 

  24.                 break;  
    25. 

  25.             }  
    26. 

  26.         }  
    27. 

  27.         return ERR_PTR(-ENODEV);  
    28. 

  28.     }  
    29. 

  29.     default:  
    30. 

  30.         driver = get_tty_driver(device, index);  
    31. 

  31.         if (!driver)  
    32. 

  32.             return ERR_PTR(-ENODEV);  
    33. 

  33.         break;  
    34. 

  34.     }  
    35. 

  35.     return driver;  
    36. 

  36. }  
    37. 



console设备文件，次设备号是1，根据代码，会调用console_device来获取对应的tty_driver，如下：








[cpp] view plain copy

 






    

  1. struct tty_driver *console_device(int *index)  
    2. 

  2. {         
    3. 

  3.     struct console *c;  
    4. 

  4.     struct tty_driver *driver = NULL;  
    5. 

  5.   
    6. 

  6.     console_lock();   
    7. 

  7.     for_each_console(c) {  
    8. 

  8.         if (!c->device)  
    9. 

  9.             continue;   
    10. 

  10.         driver = c->device(c, index);  
    11. 

  11.         if (driver)  
    12. 

  12.             break;  
    13. 

  13.     }     
    14. 

  14.     console_unlock();  
    15. 

  15.     return driver;  
    16. 

  16. }  
    17. 



又遇到了熟悉的for_each_console，遍历console_drivers链表，对于存在device成员的console，调用device方法，获取tty_driver,退出遍历。



之后对于该console设备的读写操作都是基于该tty_driver。


所有的输入输出设备都会注册tty_driver。


所以，对于一个新实现的输入输出设备，如果想让其即作为kernel的printk输出设备，也作为user空间的控制台，则需要在上面u_console基础上再实现device方法成员，来返回该设备的tty_driver。



那么还有一个问题：


如果cmdline指定2个I/O设备，“console=ttyS0,115200 console=ttyS1,115200”，user空间选择哪个作为console？


用户空间console open时，console_device遍历console_drivers，找到有device成员的console，获取tty_driver，就会退出遍历。


所以哪个console放在console_drivers前面，就会被选择为user空间的console。


在分析register_console时，如果要注册的newcon是cmdline指定的最新的console（i = selected_console），则置位CON_CONSDEV，


而在后面newcon加入console_drivers时，判断该置位，置位CON_CONSDEV,则将newcon加入到console_drivers的链表头，否则插入到后面。


所以这里user空间会选择ttyS1作为用户控件的console！



总结下，kernel和user空间下都有一个console，关系到kernel下printk的方向和user下printf的方向，实现差别还是很大的。


kernel下的console是输入输出设备driver中实现的简单的输出console，只实现write函数，并且是直接输出到设备。



user空间下的console，实际就是tty的一个例子，所有操作函数都继承与tty，全功能，可以打开 读写 关闭，所以对于console的读写，都是由kernel的tty层来最终发送到设备。


kernel的tty层之下还有ldisc线路规程层，线路规程层之下才是具体设备的driver。


ldisc层处理一些对于控制台来说有意义的输入输出字符，比如输入的crtl+C，输出的‘
‘进过线路规程会变为’

‘。



所以对于kernel下console的write方法，不要忘记，对于log buf中'
'的处理，实现一个简单的线路规程！


 嵌入式全新视频：www.makeru.com.cn/?t=12


嵌入式学习交流群：561213221



        

	      

	    

	  

	  

	    
      
        【推广】
        免费学中医，健康全家人
      
	  

    

    

          原文地址：https://www.cnblogs.com/huan-huan/p/8493063.html