jgdu1981
jgdu1981

四 linux tty驱动

四 linux tty驱动_第1张图片

一. tty结构体

1.tty_driver

[cpp] view plain copy
  1. struct tty_driver {  
  2.     int magic;  
  3.     struct kref kref;   //参考计数  
  4.     struct cdev cdev;   //字符设备  
  5.     struct module   *owner; //模块所有者  
  6.     const char  *driver_name;   //驱动名  
  7.     const char  *name;  //设备名  
  8.     int name_base;  
  9.     int major;  //主设备号  
  10.     int minor_start;    //起始次设备号  
  11.     int minor_num;  //设备个数  
  12.     int num;    //分配了的tty设备个数  
  13.     short   type;   //tty设备的类型  
  14.     short   subtype;    //tty设备子类型  
  15.     struct ktermios init_termios;   //初始化的ktermios  
  16.     int flags;  //tty驱动标志  
  17.     struct proc_dir_entry *proc_entry;  //procfs入口  
  18.     struct tty_driver *other;  
  19.     struct tty_struct **ttys;  
  20.     struct ktermios **termios;  
  21.     struct ktermios **termios_locked;  
  22.     void *driver_state;  
  23.     const struct tty_operations *ops;   //操作函数集  
  24.     struct list_head tty_drivers;   //驱动链表  
  25. };  

1.1 tty->flag

[cpp] view plain copy
  1. #define TTY_DRIVER_INSTALLED    0x0001  
  2. #define TTY_DRIVER_RESET_TERMIOS    0x0002  
  3. #define TTY_DRIVER_REAL_RAW     0x0004  
  4. #define TTY_DRIVER_DYNAMIC_DEV  0x0008  
  5. #define TTY_DRIVER_DEVPTS_MEM   0x0010  
  6. #define TTY_DRIVER_HARDWARE_BREAK   0x0020  

1.2 tty->type tty设备类型

[cpp] view plain copy
  1. #define TTY_DRIVER_TYPE_SYSTEM  0x0001  
  2. #define TTY_DRIVER_TYPE_CONSOLE 0x0002  
  3. #define TTY_DRIVER_TYPE_SERIAL  0x0003  
  4. #define TTY_DRIVER_TYPE_PTY     0x0004  
  5. #define TTY_DRIVER_TYPE_SCC     0x0005  /* scc driver */  
  6. #define TTY_DRIVER_TYPE_SYSCONS 0x0006  

2.ktermios结构体

[cpp] view plain copy
  1. struct ktermios {  
  2.     tcflag_t c_iflag;   /* input mode flags */  //输入模式标志  
  3.     tcflag_t c_oflag;   /* output mode flags */ //输出模式标志  
  4.     tcflag_t c_cflag;   /* control mode flags */    //控制模式标志  
  5.     tcflag_t c_lflag;   /* local mode flags */  //本地模式标志  
  6.     cc_t c_line;    /* line discipline */   //线路规程类型  
  7.     cc_t c_cc[NCCS];    /* control characters */    //控制字符  
  8.     speed_t c_ispeed;   /* input speed */       //输入速度  
  9.     speed_t c_ospeed;   /* output speed */      //输出速度  
  10. };  

3.tty_struct

[cpp] view plain copy
  1. struct tty_struct {  
  2.     int magic;  //魔数  
  3.     struct kref kref;   //参考计数  
  4.     struct device *dev; //设备文件  
  5.     struct tty_driver *driver;  //tty驱动  
  6.     const struct tty_operations *ops;   //tty操作函数集  
  7.     int index;    
  8.     struct mutex ldisc_mutex;  
  9.     struct tty_ldisc *ldisc;    //线路规程  
  10.     struct mutex termios_mutex;  
  11.     spinlock_t ctrl_lock;  
  12.     struct ktermios *termios, *termios_locked;  
  13.     struct termiox *termiox;  
  14.     char name[64];  //名字  
  15.     struct pid *pgrp;  
  16.     struct pid *session;  
  17.     unsigned long flags;  
  18.     int count;  
  19.     struct winsize winsize;  
  20.     unsigned char stopped:1, hw_stopped:1, flow_stopped:1, packet:1;  
  21.     unsigned char low_latency:1, warned:1;  
  22.     unsigned char ctrl_status;  
  23.     unsigned int receive_room;  
  24.     struct tty_struct *link;  
  25.     struct fasync_struct *fasync;  
  26.     struct tty_bufhead buf;  
  27.     int alt_speed;  
  28.     wait_queue_head_t write_wait;  
  29.     wait_queue_head_t read_wait;  
  30.     struct work_struct hangup_work;  
  31.     void *disc_data;  
  32.     void *driver_data;  
  33.     struct list_head tty_files;  
  34. #define N_TTY_BUF_SIZE 4096  
  35.     unsigned int column;  
  36.     unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;  
  37.     unsigned char closing:1;  
  38.     unsigned char echo_overrun:1;  
  39.     unsigned short minimum_to_wake;  
  40.     unsigned long overrun_time;  
  41.     int num_overrun;  
  42.     unsigned long process_char_map[256/(8*sizeof(unsigned long))];  
  43.     char *read_buf;  
  44.     int read_head;  
  45.     int read_tail;  
  46.     int read_cnt;  
  47.     unsigned long read_flags[N_TTY_BUF_SIZE/(8*sizeof(unsigned long))];  
  48.     unsigned char *echo_buf;  
  49.     unsigned int echo_pos;  
  50.     unsigned int echo_cnt;  
  51.     int canon_data;  
  52.     unsigned long canon_head;  
  53.     unsigned int canon_column;  
  54.     struct mutex atomic_read_lock;  
  55.     struct mutex atomic_write_lock;  
  56.     struct mutex output_lock;  
  57.     struct mutex echo_lock;  
  58.     unsigned char *write_buf;  
  59.     int write_cnt;  
  60.     spinlock_t read_lock;  
  61.     struct work_struct SAK_work;  
  62.     struct tty_port *port;  
  63. };  

4.tty_ldisc线路规程

[cpp] view plain copy
  1. struct tty_ldisc {  
  2.     struct tty_ldisc_ops *ops;  
  3.     atomic_t users;  
  4. };  

4.1 线路规程操作函数集

[cpp] view plain copy
  1. struct tty_ldisc_ops {  
  2.     int magic;  
  3.     char    *name;  
  4.     int num;  
  5.     int flags;  
  6.     int (*open)(struct tty_struct *);  
  7.     void    (*close)(struct tty_struct *);  
  8.     void    (*flush_buffer)(struct tty_struct *tty);  
  9.     ssize_t (*chars_in_buffer)(struct tty_struct *tty);  
  10.     ssize_t (*read)(struct tty_struct * tty, struct file * file,unsigned char __user * buf, size_t nr);  
  11.     ssize_t (*write)(struct tty_struct * tty, struct file * file,const unsigned char * buf, size_t nr);   
  12.     int (*ioctl)(struct tty_struct * tty, struct file * file,unsigned int cmd, unsigned long arg);  
  13.     long    (*compat_ioctl)(struct tty_struct * tty, struct file * file,unsigned int cmd, unsigned long arg);  
  14.     void    (*set_termios)(struct tty_struct *tty, struct ktermios * old);  
  15.     unsigned int (*poll)(struct tty_struct *, struct file *,struct poll_table_struct *);  
  16.     int (*hangup)(struct tty_struct *tty);  
  17.     void    (*receive_buf)(struct tty_struct *, const unsigned char *cp,char *fp, int count);  
  18.     void    (*write_wakeup)(struct tty_struct *);  
  19.     void    (*dcd_change)(struct tty_struct *, unsigned int,struct timespec *);  
  20.     struct  module *owner;  
  21.     int refcount;  
  22. };  


二.系统初始化

设备类初始化

[cpp] view plain copy
  1. static int __init tty_class_init(void)  
  2. {  
  3.     tty_class = class_create(THIS_MODULE, "tty");   //创建tty类  
  4.     if (IS_ERR(tty_class))  
  5.         return PTR_ERR(tty_class);  
  6.     tty_class->devnode = tty_devnode;    //指定tty设备节点  
  7.     return 0;  
  8. }  

字符设备初始化

[cpp] view plain copy
  1. int __init tty_init(void)  
  2. {  
  3.     cdev_init(&tty_cdev, &tty_fops);    //初始化tty字符设备  
  4.     if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||   //添加tty字符设备  
  5.         register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)   //注册/dev/tty字符设备  
  6.         panic("Couldn't register /dev/tty driver\n");  
  7.     device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,"tty"); //注册tty设备  
  8.     cdev_init(&console_cdev, &console_fops);    //初始化console字符设备  
  9.     if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||   //添加console字符设备  
  10.         register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)   //注册/dev/console设备  
  11.         panic("Couldn't register /dev/console driver\n");  
  12.     device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,"console"); //创建console设备  
  13. #ifdef CONFIG_VT  
  14.     vty_init(&console_fops);  
  15. #endif  
  16.     return 0;  
  17. }  

虚拟终端/dev/tty0初始化vty_init

[cpp] view plain copy
  1. int __init vty_init(const struct file_operations *console_fops)  
  2. {  
  3.     cdev_init(&vc0_cdev, console_fops);  
  4.     if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)  
  5.         panic("Couldn't register /dev/tty0 driver\n");  
  6.     device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");  //创建/dev/tty0 (4,0)  
  7.     vcs_init();  
  8.     console_driver = alloc_tty_driver(MAX_NR_CONSOLES);  
  9.     if (!console_driver)  
  10.         panic("Couldn't allocate console driver\n");  
  11.     console_driver->owner = THIS_MODULE;  
  12.     console_driver->name = "tty";  
  13.     console_driver->name_base = 1;  
  14.     console_driver->major = TTY_MAJOR;  
  15.     console_driver->minor_start = 1;  
  16.     console_driver->type = TTY_DRIVER_TYPE_CONSOLE;  
  17.     console_driver->init_termios = tty_std_termios;  
  18.     if (default_utf8)  
  19.         console_driver->init_termios.c_iflag |= IUTF8;  
  20.     console_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;  
  21.     tty_set_operations(console_driver, &con_ops);  
  22.     if (tty_register_driver(console_driver))  
  23.         panic("Couldn't register console driver\n");  
  24.     kbd_init();  
  25.     console_map_init();  
  26. #ifdef CONFIG_MDA_CONSOLE  
  27.     mda_console_init();  
  28. #endif  
  29.     return 0;  
  30. }  


 

三.tty初始化步骤

1.分配tty结构体

[cpp] view plain copy
  1. struct tty_driver *alloc_tty_driver(int lines)  
  2. {  
  3.     struct tty_driver *driver;  
  4.     driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);    //分配内存  
  5.     if (driver) {  
  6.         kref_init(&driver->kref);    //引用计数+1  
  7.         driver->magic = TTY_DRIVER_MAGIC;    //设置魔数0x5402  
  8.         driver->num = lines; //设置tty line个数  
  9.     }  
  10.     return driver;  
  11. }  


2.填充tty结构体成员

3.注册tty设备驱动

[cpp] view plain copy
  1. int tty_register_driver(struct tty_driver *driver)  
  2. {  
  3.     int error;  
  4.     int i;  
  5.     dev_t dev;  
  6.     void **p = NULL;  
  7.     struct device *d;  
  8.   
  9.     if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM) && driver->num) {  
  10.         p = kzalloc(driver->num * 2 * sizeof(void *), GFP_KERNEL);  
  11.         if (!p)  
  12.             return -ENOMEM;  
  13.     }  
  14.     if (!driver->major) {    //指定了主设备号  
  15.         error = alloc_chrdev_region(&dev, driver->minor_start,driver->num, driver->name);  //分配多个设备号  
  16.         if (!error) {  
  17.             driver->major = MAJOR(dev);  //主设备号  
  18.             driver->minor_start = MINOR(dev);    //次设备号  
  19.         }  
  20.     } else {  
  21.         dev = MKDEV(driver->major, driver->minor_start);  //获取第一个设备号  
  22.         error = register_chrdev_region(dev, driver->num, driver->name);   //分配多个设备号     
  23.     }  
  24.     if (error < 0) {  
  25.         kfree(p);  
  26.         return error;  
  27.     }  
  28.     if (p) {  
  29.         driver->ttys = (struct tty_struct **)p;  //tty_struct  
  30.         driver->termios = (struct ktermios **)(p + driver->num);  //ktermios  
  31. k   } else {  
  32.         driver->ttys = NULL;  
  33.         driver->termios = NULL;  
  34.     }  
  35.   
  36.     cdev_init(&driver->cdev, &tty_fops); //初始化字符设备  
  37.     driver->cdev.owner = driver->owner;   //设置模块所有者  
  38.     error = cdev_add(&driver->cdev, dev, driver->num);    //添加字符设备  
  39.     if (error) {  
  40.         unregister_chrdev_region(dev, driver->num);  
  41.         driver->ttys = NULL;  
  42.         driver->termios = NULL;  
  43.         kfree(p);  
  44.         return error;  
  45.     }  
  46.   
  47.     mutex_lock(&tty_mutex);  
  48.     list_add(&driver->tty_drivers, &tty_drivers);        //添加到全局tty_drivers链表  
  49.     mutex_unlock(&tty_mutex);  
  50.   
  51.     if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) { //标志动态创建设备标志  
  52.         for (i = 0; i < driver->num; i++) {  
  53.             d = tty_register_device(driver, i, NULL);   //添加tty设备文件/dev/ttyXX  
  54.             if (IS_ERR(d)) {  
  55.                 error = PTR_ERR(d);  
  56.                 goto err;  
  57.             }  
  58.         }  
  59.     }  
  60.     proc_tty_register_driver(driver);   //设置tty在/proc下的接口  
  61.     driver->flags |= TTY_DRIVER_INSTALLED;  
  62.     return 0;  
  63.   
  64. err:  
  65.     for (i--; i >= 0; i--)  
  66.         tty_unregister_device(driver, i);  
  67.   
  68.     mutex_lock(&tty_mutex);  
  69.     list_del(&driver->tty_drivers);  
  70.     mutex_unlock(&tty_mutex);  
  71.   
  72.     unregister_chrdev_region(dev, driver->num);  
  73.     driver->ttys = NULL;  
  74.     driver->termios = NULL;  
  75.     kfree(p);  
  76.     return error;  
  77. }  

4.创建tty设备文件/dev/ttyXXX

[cpp] view plain copy
  1. struct device *tty_register_device(struct tty_driver *driver, unsigned index,struct device *device)  
  2. {  
  3.     char name[64];  
  4.     dev_t dev = MKDEV(driver->major, driver->minor_start) + index;    //获取设备号  
  5.     if (index >= driver->num) {  
  6.         printk(KERN_ERR "Attempt to register invalid tty line number (%d).\n", index);  
  7.         return ERR_PTR(-EINVAL);  
  8.     }  
  9.     if (driver->type == TTY_DRIVER_TYPE_PTY) //伪终端  
  10.         pty_line_name(driver, index, name);  
  11.     else                    //"/dev/ttyXXX"  
  12.         tty_line_name(driver, index, name);  
  13.     return device_create(tty_class, device, dev, NULL, name);   //创建设备文件  
  14. }  

5.tty设备文件捆绑的操作函数集tty_fops

[cpp] view plain copy
  1. static const struct file_operations tty_fops = {  
  2.     .llseek     = no_llseek,  
  3.     .read       = tty_read,  
  4.     .write      = tty_write,  
  5.     .poll       = tty_poll,  
  6.     .unlocked_ioctl = tty_ioctl,  
  7.     .compat_ioctl   = tty_compat_ioctl,  
  8.     .open       = tty_open,  
  9.     .release        = tty_release,  
  10.     .fasync     = tty_fasync,  
  11. };  


四. tty的操作

当打开/dev/ttyXX的时候会调用tty_open函数

tty_open操作

[cpp] view plain copy
  1. static int tty_open(struct inode *inode, struct file *filp)  
  2. {  
  3.     struct tty_struct *tty = NULL;  
  4.     int noctty, retval;  
  5.     struct tty_driver *driver;  
  6.     int index;  
  7.     dev_t device = inode->i_rdev;    //通过i节点获取设备号  
  8.     unsigned saved_flags = filp->f_flags;  
  9.     nonseekable_open(inode, filp);  //设置打开关联文件的模式  
  10. retry_open:  
  11.     noctty = filp->f_flags & O_NOCTTY;   //设置O_NOCTTY标志  
  12.     index  = -1;  
  13.     retval = 0;  
  14.     mutex_lock(&tty_mutex);  
  15.     tty_lock();  
  16.     if (device == MKDEV(TTYAUX_MAJOR, 0)) { //打开的设备是/dev/tty (5,0)  
  17.         tty = get_current_tty();    //取当前进程tty_struct  
  18.         if (!tty) {  
  19.             tty_unlock();  
  20.             mutex_unlock(&tty_mutex);  
  21.             return -ENXIO;  
  22.         }  
  23.         driver = tty_driver_kref_get(tty->driver);   //获取tty_driver  
  24.         index = tty->index;  
  25.         filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */  
  26.         tty_kref_put(tty);      //引用计数  
  27.         goto got_driver;  
  28.     }  
  29. #ifdef CONFIG_VT    //虚拟终端设备 /dev/tty0  
  30.     if (device == MKDEV(TTY_MAJOR, 0)) {    //(4,0)  
  31.         extern struct tty_driver *console_driver;  
  32.         driver = tty_driver_kref_get(console_driver);   //获取tty_struct  
  33.         index = fg_console;  
  34.         noctty = 1;  
  35.         goto got_driver;  
  36.     }  
  37. #endif  
  38.     if (device == MKDEV(TTYAUX_MAJOR, 1)) { //打开的是/dev/console (5,1)  
  39.         struct tty_driver *console_driver = console_device(&index); //获取console对应的tty_driver  
  40.         if (console_driver) {  
  41.             driver = tty_driver_kref_get(console_driver);   //获取tty_struct  
  42.             if (driver) {  
  43.                 filp->f_flags |= O_NONBLOCK;  
  44.                 noctty = 1;  
  45.                 goto got_driver;  
  46.             }  
  47.         }  
  48.         tty_unlock();  
  49.         mutex_unlock(&tty_mutex);  
  50.         return -ENODEV;  
  51.     }  
  52.     driver = get_tty_driver(device, &index);    //获取tty_driver,设置次设备号(索引值) 非特殊的tty  
  53.     if (!driver) {  
  54.         tty_unlock();  
  55.         mutex_unlock(&tty_mutex);  
  56.         return -ENODEV;  
  57.     }  
  58. got_driver:  
  59.     if (!tty) {  
  60.         tty = tty_driver_lookup_tty(driver, inode, index);  //获取tty_drivver的tty_struct  
  61.         if (IS_ERR(tty)) {  
  62.             tty_unlock();  
  63.             mutex_unlock(&tty_mutex);  
  64.             return PTR_ERR(tty);  
  65.         }  
  66.     }  
  67.     if (tty) {  //若tty_struct不为空  
  68.         retval = tty_reopen(tty);  
  69.         if (retval)  
  70.             tty = ERR_PTR(retval);  
  71.     } else  //若tty_struct为空  
  72.         tty = tty_init_dev(driver, index, 0);   //调用tty_init_dev函数(下面分析)  
  73.     mutex_unlock(&tty_mutex);  
  74.     tty_driver_kref_put(driver);    //增加引用计数  
  75.     if (IS_ERR(tty)) {  
  76.         tty_unlock();  
  77.         return PTR_ERR(tty);  
  78.     }  
  79.     retval = tty_add_file(tty, filp);  
  80.     if (retval) {  
  81.         tty_unlock();  
  82.         return retval;  
  83.     }  
  84.     check_tty_count(tty, "tty_open");  
  85.     if (tty->driver->type == TTY_DRIVER_TYPE_PTY && tty->driver->subtype == PTY_TYPE_MASTER)  
  86.         noctty = 1;  
  87. #ifdef TTY_DEBUG_HANGUP  
  88.     printk(KERN_DEBUG "opening %s...", tty->name);  
  89. #endif  
  90.     if (!retval) {  
  91.         if (tty->ops->open)   //若tty_struct存在open方法  
  92.             retval = tty->ops->open(tty, filp);   //则调用其open方法  
  93.         else  
  94.             retval = -ENODEV;  
  95.     }  
  96.     filp->f_flags = saved_flags;  
  97.     if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&!capable(CAP_SYS_ADMIN))  
  98.         retval = -EBUSY;  
  99.     if (retval) {  
  100. #ifdef TTY_DEBUG_HANGUP  
  101.         printk(KERN_DEBUG "error %d in opening %s...", retval,tty->name);  
  102. #endif  
  103.         tty_unlock(); /* need to call tty_release without BTM */  
  104.         tty_release(inode, filp);  
  105.         if (retval != -ERESTARTSYS)  
  106.             return retval  
  107.         if (signal_pending(current))  
  108.             return retval;  
  109.         schedule();  
  110.         tty_lock();  
  111.         if (filp->f_op == &hung_up_tty_fops)  
  112.             filp->f_op = &tty_fops;  
  113.         tty_unlock();  
  114.         goto retry_open;  
  115.     }  
  116.     tty_unlock();  
  117.     mutex_lock(&tty_mutex);  
  118.     tty_lock();  
  119.     spin_lock_irq(¤t->sighand->siglock);  
  120.     if (!noctty && current->signal->leader &&!current->signal->tty && tty->session == NULL)  
  121.         __proc_set_tty(current, tty);  
  122.     spin_unlock_irq(¤t->sighand->siglock);  
  123.     tty_unlock();  
  124.     mutex_unlock(&tty_mutex);  
  125.     return 0;  
  126. }  

tty_init_dev函数

[cpp] view plain copy
  1. struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,int first_ok)  
  2. {  
  3.     struct tty_struct *tty;  
  4.     int retval;  
  5.   
  6.     if (driver->subtype == PTY_TYPE_MASTER &&(driver->flags & TTY_DRIVER_DEVPTS_MEM) && !first_ok) {  
  7.         return ERR_PTR(-EIO);  
  8.     }  
  9.     if (!try_module_get(driver->owner))  
  10.         return ERR_PTR(-ENODEV);  
  11.   
  12.     tty = alloc_tty_struct();   //分配tty_struct  
  13.     if (!tty)  
  14.         goto fail_no_mem;  
  15.     initialize_tty_struct(tty, driver, idx);    //初始化tty_struct  
  16.   
  17.     retval = tty_driver_install_tty(driver, tty);   //调用tty_driver的install方法,并初始化termios  
  18.     if (retval < 0) {  
  19.         free_tty_struct(tty);  
  20.         module_put(driver->owner);  
  21.         return ERR_PTR(retval);  
  22.     }  
  23.   
  24.     retval = tty_ldisc_setup(tty, tty->link);    //调用线路规程的open方法,及线路规程link的open方法  
  25.     if (retval)  
  26.         goto release_mem_out;  
  27.     return tty;  
  28.   
  29. fail_no_mem:  
  30.     module_put(driver->owner);  
  31.     return ERR_PTR(-ENOMEM);  
  32.   
  33. release_mem_out:  
  34.     if (printk_ratelimit())  
  35.         printk(KERN_INFO "tty_init_dev: ldisc open failed,clearing slot %d\n", idx);  
  36.     release_tty(tty, idx);  
  37.     return ERR_PTR(retval);  
  38. }  

tty_init_dev>>>initialize_tty_struct

[cpp] view plain copy
  1. void initialize_tty_struct(struct tty_struct *tty,struct tty_driver *driver, int idx)  
  2. {  
  3.     memset(tty, 0, sizeof(struct tty_struct));  //初始化tty_struct  
  4.     kref_init(&tty->kref);  
  5.     tty->magic = TTY_MAGIC;  //魔数  
  6.     tty_ldisc_init(tty);    //初始化线路规程  
  7.     tty->session = NULL;  
  8.     tty->pgrp = NULL;  
  9.     tty->overrun_time = jiffies;  
  10.     tty->buf.head = tty->buf.tail = NULL;  
  11.     tty_buffer_init(tty);  
  12.     mutex_init(&tty->termios_mutex);  
  13.     mutex_init(&tty->ldisc_mutex);  
  14.     init_waitqueue_head(&tty->write_wait);   //初始化写等待队列头  
  15.     init_waitqueue_head(&tty->read_wait);    //初始化读等待队列头  
  16.     INIT_WORK(&tty->hangup_work, do_tty_hangup);  
  17.     mutex_init(&tty->atomic_read_lock);  
  18.     mutex_init(&tty->atomic_write_lock);  
  19.     mutex_init(&tty->output_lock);  
  20.     mutex_init(&tty->echo_lock);  
  21.     spin_lock_init(&tty->read_lock);  
  22.     spin_lock_init(&tty->ctrl_lock);  
  23.     INIT_LIST_HEAD(&tty->tty_files);  
  24.     INIT_WORK(&tty->SAK_work, do_SAK_work);  
  25.   
  26.     tty->driver = driver;    //tty_struct->driver=tty_driver 捆绑tty_struct和tty_driver  
  27.     tty->ops = driver->ops;   //tty_strcut的操作函数集=tty_driver的操作函数集  
  28.     tty->index = idx;    //设置索引值  
  29.     tty_line_name(driver, idx, tty->name);  
  30.     tty->dev = tty_get_device(tty);  //设置tty_struct的设备文件  
  31. }  

tty_init_dev>>>initialize_tty_struct>>>tty_ldisc_init

[cpp] view plain copy
  1. void tty_ldisc_init(struct tty_struct *tty)  
  2. {  
  3.     struct tty_ldisc *ld = tty_ldisc_get(N_TTY);    //获取线路规程数组tty_ldiscs[N_TTY]项  
  4.     if (IS_ERR(ld))  
  5.         panic("n_tty: init_tty");  
  6.     tty_ldisc_assign(tty, ld);  //设置线路规程  
  7. }  

在start_kernel-->console_init-->tty_ldisc_begin-->tty_register_ldisc将tty_ldiscs[N_TTY]=tty_ldisc_N_TTY

tty_driver_install_tty

[cpp] view plain copy
  1. static int tty_driver_install_tty(struct tty_driver *driver,struct tty_struct *tty)  
  2. {  
  3.     int idx = tty->index;  
  4.     int ret;  
  5.   
  6.     if (driver->ops->install) {   //tty驱动操作函数集存在install方法  
  7.         ret = driver->ops->install(driver, tty);  //则调用install方法  
  8.         return ret;  
  9.     }  
  10.   
  11.     if (tty_init_termios(tty) == 0) {   //初始化termios  
  12.         tty_driver_kref_get(driver);  
  13.         tty->count++;  
  14.         driver->ttys[idx] = tty;  
  15.         return 0;  
  16.     }  
  17.     return -ENOMEM;  
  18. }  

tty_driver_install_tty>>>tty_init_termios

[cpp] view plain copy
  1. int tty_init_termios(struct tty_struct *tty)  
  2. {  
  3.     struct ktermios *tp;  
  4.     int idx = tty->index;  
  5.   
  6.     tp = tty->driver->termios[idx];   //获取termios  
  7.     if (tp == NULL) {  
  8.         tp = kzalloc(sizeof(struct ktermios[2]), GFP_KERNEL);  
  9.         if (tp == NULL)  
  10.             return -ENOMEM;  
  11.         memcpy(tp, &tty->driver->init_termios,sizeof(struct ktermios));  
  12.         tty->driver->termios[idx] = tp;  
  13.     }  
  14.     tty->termios = tp;  
  15.     tty->termios_locked = tp + 1;  
  16.   
  17.     /* Compatibility until drivers always set this */  
  18.     tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);    //设置接收波特率  
  19.     tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);  //设置波特率  
  20.     return 0;  
  21. }  
  22. EXPORT_SYMBOL_GPL(tty_init_termios);  

tty_ldisc_setup

[cpp] view plain copy
  1. int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)  
  2. {  
  3.     struct tty_ldisc *ld = tty->ldisc;  
  4.     int retval;  
  5.     retval = tty_ldisc_open(tty, ld);   //调用tty_struct的open方法  
  6.     if (retval)  
  7.         return retval;  
  8.     if (o_tty) {  
  9.         retval = tty_ldisc_open(o_tty, o_tty->ldisc);    //调用tty_struct->link的open方法  
  10.         if (retval) {  
  11.             tty_ldisc_close(tty, ld);  
  12.             return retval;  
  13.         }  
  14.         tty_ldisc_enable(o_tty);    //使能tty_struct->kink  
  15.     }  
  16.     tty_ldisc_enable(tty);  //使能tty_struct  
  17.     return 0;  
  18. }  

 

tty_read操作

[cpp] view plain copy
  1. static ssize_t tty_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)  
  2. {  
  3.     int i;  
  4.     struct inode *inode = file->f_path.dentry->d_inode;  
  5.     struct tty_struct *tty = file_tty(file);    //获取tty_strcut  
  6.     struct tty_ldisc *ld;  
  7.   
  8.     if (tty_paranoia_check(tty, inode, "tty_read"))  
  9.         return -EIO;  
  10.     if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))  
  11.         return -EIO;  
  12.   
  13.     ld = tty_ldisc_ref_wait(tty);   //获取线路规程  
  14.     if (ld->ops->read)        //线路规程存在读方法  
  15.         i = (ld->ops->read)(tty, file, buf, count);   //调用其读方法  
  16.     else  
  17.         i = -EIO;  
  18.     tty_ldisc_deref(ld);    //引用计数  
  19.     if (i > 0)  
  20.         inode->i_atime = current_fs_time(inode->i_sb);  
  21.     return i;  
  22. }  

 

tty_write操作

[cpp] view plain copy
  1. static ssize_t tty_write(struct file *file, const char __user *buf,size_t count, loff_t *ppos)  
  2. {  
  3.     struct inode *inode = file->f_path.dentry->d_inode;  
  4.     struct tty_struct *tty = file_tty(file);    //获取tty_struct  
  5.     struct tty_ldisc *ld;  
  6.     ssize_t ret;  
  7.   
  8.     if (tty_paranoia_check(tty, inode, "tty_write"))  
  9.         return -EIO;  
  10.     if (!tty || !tty->ops->write ||(test_bit(TTY_IO_ERROR, &tty->flags)))  
  11.             return -EIO;  
  12.     /* Short term debug to catch buggy drivers */  
  13.     if (tty->ops->write_room == NULL)  
  14.         printk(KERN_ERR "tty driver %s lacks a write_room method.\n",tty->driver->name);  
  15.     ld = tty_ldisc_ref_wait(tty);  
  16.     if (!ld->ops->write)  //线路规程存在写方法  
  17.         ret = -EIO;  
  18.     else  
  19.         ret = do_tty_write(ld->ops->write, tty, file, buf, count);    //调用线路规程写方法  
  20.     tty_ldisc_deref(ld);  
  21.     return ret;  
  22. }  

do_tty_write函数

do_tty_write(ld->ops->write,

                       tty, file, buf, count);

这个函数第一个参数是调用线路规程的写方法,写方法函数的参数是后面四个参数

该写方法将数据写入tty_struct相关的file里

[cpp] view plain copy
  1. static inline ssize_t do_tty_write(ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),  
  2.             struct tty_struct *tty,struct file *file,const char __user *buf,size_t count)  
  3. {  
  4.     ssize_t ret, written = 0;  
  5.     unsigned int chunk;  
  6.   
  7.     ret = tty_write_lock(tty, file->f_flags & O_NDELAY);  
  8.     if (ret < 0)  
  9.         return ret;  
  10.     chunk = 2048;  
  11.     if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))  
  12.         chunk = 65536;  
  13.     if (count < chunk)  
  14.         chunk = count;  
  15.   
  16.     /* write_buf/write_cnt is protected by the atomic_write_lock mutex */  
  17.     if (tty->write_cnt < chunk) {  
  18.         unsigned char *buf_chunk;  
  19.   
  20.         if (chunk < 1024)  
  21.             chunk = 1024;  
  22.   
  23.         buf_chunk = kmalloc(chunk, GFP_KERNEL);  
  24.         if (!buf_chunk) {  
  25.             ret = -ENOMEM;  
  26.             goto out;  
  27.         }  
  28.         kfree(tty->write_buf);  
  29.         tty->write_cnt = chunk;  
  30.         tty->write_buf = buf_chunk;  
  31.     }  
  32.   
  33.     /* Do the write .. */  
  34.     for (;;) {  
  35.         size_t size = count;  
  36.         if (size > chunk)  
  37.             size = chunk;  
  38.         ret = -EFAULT;  
  39.         if (copy_from_user(tty->write_buf, buf, size))  
  40.             break;  
  41.         ret = write(tty, file, tty->write_buf, size);  
  42.         if (ret <= 0)  
  43.             break;  
  44.         written += ret;  
  45.         buf += ret;  
  46.         count -= ret;  
  47.         if (!count)  
  48.             break;  
  49.         ret = -ERESTARTSYS;  
  50.         if (signal_pending(current))  
  51.             break;  
  52.         cond_resched();  
  53.     }  
  54.     if (written) {  
  55.         struct inode *inode = file->f_path.dentry->d_inode;  
  56.         inode->i_mtime = current_fs_time(inode->i_sb);  
  57.         ret = written;  
  58.     }  
  59. out:  
  60.     tty_write_unlock(tty);  
  61.     return ret;  
  62. }  

五.线路规程操作

tty_driver的open,read,write最终都会调用线路规程的对应操作方法

线路规程默认函数集

[cpp] view plain copy
  1. struct tty_ldisc_ops tty_ldisc_N_TTY = {  
  2.     .magic           = TTY_LDISC_MAGIC,  
  3.     .name            = "n_tty",  
  4.     .open            = n_tty_open,  
  5.     .close           = n_tty_close,  
  6.     .flush_buffer    = n_tty_flush_buffer,  
  7.     .chars_in_buffer = n_tty_chars_in_buffer,  
  8.     .read            = n_tty_read,  
  9.     .write           = n_tty_write,  
  10.     .ioctl           = n_tty_ioctl,  
  11.     .set_termios     = n_tty_set_termios,  
  12.     .poll            = n_tty_poll,  
  13.     .receive_buf     = n_tty_receive_buf,  
  14.     .write_wakeup    = n_tty_write_wakeup  
  15. };  

1.open方法

[cpp] view plain copy
  1. static int n_tty_open(struct tty_struct *tty)  
  2. {  
  3.     if (!tty)  
  4.         return -EINVAL;  
  5.   
  6.     if (!tty->read_buf) {  
  7.         tty->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);  
  8.         if (!tty->read_buf)  
  9.             return -ENOMEM;  
  10.     }  
  11.     if (!tty->echo_buf) {  
  12.         tty->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);  
  13.   
  14.         if (!tty->echo_buf)  
  15.             return -ENOMEM;  
  16.     }  
  17.     reset_buffer_flags(tty);  
  18.     tty->column = 0;  
  19.     n_tty_set_termios(tty, NULL);  
  20.     tty->minimum_to_wake = 1;  
  21.     tty->closing = 0;  
  22.     return 0;  
  23. }  

2.写方法

[cpp] view plain copy
  1. static ssize_t n_tty_write(struct tty_struct *tty, struct file *file,const unsigned char *buf, size_t nr)  
  2. {  
  3.     const unsigned char *b = buf;  
  4.     DECLARE_WAITQUEUE(wait, current);  
  5.     int c;  
  6.     ssize_t retval = 0;  
  7.   
  8.     /* Job control check -- must be done at start (POSIX.1 7.1.1.4). */  
  9.     if (L_TOSTOP(tty) && file->f_op->write != redirected_tty_write) {  
  10.         retval = tty_check_change(tty);  
  11.         if (retval)  
  12.             return retval;  
  13.     }  
  14.   
  15.     /* Write out any echoed characters that are still pending */  
  16.     process_echoes(tty);  
  17.   
  18.     add_wait_queue(&tty->write_wait, &wait);  
  19.     while (1) {  
  20.         set_current_state(TASK_INTERRUPTIBLE);  
  21.         if (signal_pending(current)) {  
  22.             retval = -ERESTARTSYS;  
  23.             break;  
  24.         }  
  25.         if (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {  
  26.             retval = -EIO;  
  27.             break;  
  28.         }  
  29.         if (O_OPOST(tty) && !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {  
  30.             while (nr > 0) {  
  31.                 ssize_t num = process_output_block(tty, b, nr);  
  32.                 if (num < 0) {  
  33.                     if (num == -EAGAIN)  
  34.                         break;  
  35.                     retval = num;  
  36.                     goto break_out;  
  37.                 }  
  38.                 b += num;  
  39.                 nr -= num;  
  40.                 if (nr == 0)  
  41.                     break;  
  42.                 c = *b;  
  43.                 if (process_output(c, tty) < 0)  
  44.                     break;  
  45.                 b++; nr--;  
  46.             }  
  47.             if (tty->ops->flush_chars)  
  48.                 tty->ops->flush_chars(tty);   //调用tty_struct操作函数集合的flush_chars方法  
  49.         } else {  
  50.             while (nr > 0) {  
  51.                 c = tty->ops->write(tty, b, nr);  //调用tty_struct操作函数集合的write方法  
  52.                 if (c < 0) {  
  53.                     retval = c;  
  54.                     goto break_out;  
  55.                 }  
  56.                 if (!c)  
  57.                     break;  
  58.                 b += c;  
  59.                 nr -= c;  
  60.             }  
  61.         }  
  62.         if (!nr)  
  63.             break;  
  64.         if (file->f_flags & O_NONBLOCK) {  
  65.             retval = -EAGAIN;  
  66.             break;  
  67.         }  
  68.         schedule();  
  69.     }  
  70. break_out:  
  71.     __set_current_state(TASK_RUNNING);  
  72.     remove_wait_queue(&tty->write_wait, &wait);  
  73.     if (b - buf != nr && tty->fasync)  
  74.         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);  
  75.     return (b - buf) ? b - buf : retval;  
  76. }  

3.读方法

[cpp] view plain copy
  1. static ssize_t n_tty_read(struct tty_struct *tty, struct file *file,unsigned char __user *buf, size_t nr)  
  2. {  
  3.     unsigned char __user *b = buf;  
  4.     DECLARE_WAITQUEUE(wait, current);  
  5.     int c;  
  6.     int minimum, time;  
  7.     ssize_t retval = 0;  
  8.     ssize_t size;  
  9.     long timeout;  
  10.     unsigned long flags;  
  11.     int packet;  
  12.   
  13. do_it_again:  
  14.   
  15.     BUG_ON(!tty->read_buf);  
  16.   
  17.     c = job_control(tty, file);  
  18.     if (c < 0)  
  19.         return c;  
  20.   
  21.     minimum = time = 0;  
  22.     timeout = MAX_SCHEDULE_TIMEOUT;  
  23.     if (!tty->icanon) {  
  24.         time = (HZ / 10) * TIME_CHAR(tty);  
  25.         minimum = MIN_CHAR(tty);  
  26.         if (minimum) {  
  27.             if (time)  
  28.                 tty->minimum_to_wake = 1;  
  29.             else if (!waitqueue_active(&tty->read_wait) ||  
  30.                  (tty->minimum_to_wake > minimum))  
  31.                 tty->minimum_to_wake = minimum;  
  32.         } else {  
  33.             timeout = 0;  
  34.             if (time) {  
  35.                 timeout = time;  
  36.                 time = 0;  
  37.             }  
  38.             tty->minimum_to_wake = minimum = 1;  
  39.         }  
  40.     }  
  41.   
  42.     if (file->f_flags & O_NONBLOCK) {  
  43.         if (!mutex_trylock(&tty->atomic_read_lock))  
  44.             return -EAGAIN;  
  45.     } else {  
  46.         if (mutex_lock_interruptible(&tty->atomic_read_lock))  
  47.             return -ERESTARTSYS;  
  48.     }  
  49.     packet = tty->packet;  
  50.   
  51.     add_wait_queue(&tty->read_wait, &wait);  
  52.     while (nr) {  
  53.         /* First test for status change. */  
  54.         if (packet && tty->link->ctrl_status) {  
  55.             unsigned char cs;  
  56.             if (b != buf)  
  57.                 break;  
  58.             spin_lock_irqsave(&tty->link->ctrl_lock, flags);  
  59.             cs = tty->link->ctrl_status;  
  60.             tty->link->ctrl_status = 0;  
  61.             spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);  
  62.             if (tty_put_user(tty, cs, b++)) {  
  63.                 retval = -EFAULT;  
  64.                 b--;  
  65.                 break;  
  66.             }  
  67.             nr--;  
  68.             break;  
  69.         }  
  70.         set_current_state(TASK_INTERRUPTIBLE);  
  71.   
  72.         if (((minimum - (b - buf)) < tty->minimum_to_wake) &&  
  73.             ((minimum - (b - buf)) >= 1))  
  74.             tty->minimum_to_wake = (minimum - (b - buf));  
  75.   
  76.         if (!input_available_p(tty, 0)) {  
  77.             if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {  
  78.                 retval = -EIO;  
  79.                 break;  
  80.             }  
  81.             if (tty_hung_up_p(file))  
  82.                 break;  
  83.             if (!timeout)  
  84.                 break;  
  85.             if (file->f_flags & O_NONBLOCK) {  
  86.                 retval = -EAGAIN;  
  87.                 break;  
  88.             }  
  89.             if (signal_pending(current)) {  
  90.                 retval = -ERESTARTSYS;  
  91.                 break;  
  92.             }  
  93.             /* FIXME: does n_tty_set_room need locking ? */  
  94.             n_tty_set_room(tty);  
  95.             timeout = schedule_timeout(timeout);  
  96.             continue;  
  97.         }  
  98.         __set_current_state(TASK_RUNNING);  
  99.   
  100.         /* Deal with packet mode. */  
  101.         if (packet && b == buf) {  
  102.             if (tty_put_user(tty, TIOCPKT_DATA, b++)) {  
  103.                 retval = -EFAULT;  
  104.                 b--;  
  105.                 break;  
  106.             }  
  107.             nr--;  
  108.         }  
  109.   
  110.         if (tty->icanon && !L_EXTPROC(tty)) {  
  111.             /* N.B. avoid overrun if nr == 0 */  
  112.             while (nr && tty->read_cnt) {  
  113.                 int eol;  
  114.   
  115.                 eol = test_and_clear_bit(tty->read_tail,tty->read_flags);  
  116.                 c = tty->read_buf[tty->read_tail];  
  117.                 spin_lock_irqsave(&tty->read_lock, flags);  
  118.                 tty->read_tail = ((tty->read_tail+1) &(N_TTY_BUF_SIZE-1));  
  119.                 tty->read_cnt--;  
  120.                 if (eol) {  
  121.                     if (--tty->canon_data < 0)  
  122.                         tty->canon_data = 0;  
  123.                 }  
  124.                 spin_unlock_irqrestore(&tty->read_lock, flags);  
  125.   
  126.                 if (!eol || (c != __DISABLED_CHAR)) {  
  127.                     if (tty_put_user(tty, c, b++)) {  
  128.                         retval = -EFAULT;  
  129.                         b--;  
  130.                         break;  
  131.                     }  
  132.                     nr--;  
  133.                 }  
  134.                 if (eol) {  
  135.                     tty_audit_push(tty);  
  136.                     break;  
  137.                 }  
  138.             }  
  139.             if (retval)  
  140.                 break;  
  141.         } else {  
  142.             int uncopied;  
  143.             uncopied = copy_from_read_buf(tty, &b, &nr);  
  144.             uncopied += copy_from_read_buf(tty, &b, &nr);  
  145.             if (uncopied) {  
  146.                 retval = -EFAULT;  
  147.                 break;  
  148.             }  
  149.         }  
  150.   
  151.         if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {  
  152.             n_tty_set_room(tty);  
  153.             check_unthrottle(tty);  
  154.         }  
  155.   
  156.         if (b - buf >= minimum)  
  157.             break;  
  158.         if (time)  
  159.             timeout = time;  
  160.     }  
  161.     mutex_unlock(&tty->atomic_read_lock);  
  162.     remove_wait_queue(&tty->read_wait, &wait);  
  163.   
  164.     if (!waitqueue_active(&tty->read_wait))  
  165.         tty->minimum_to_wake = minimum;  
  166.   
  167.     __set_current_state(TASK_RUNNING);  
  168.     size = b - buf;  
  169.     if (size) {  
  170.         retval = size;  
  171.         if (nr)  
  172.             clear_bit(TTY_PUSH, &tty->flags);  
  173.     } else if (test_and_clear_bit(TTY_PUSH, &tty->flags))  
  174.          goto do_it_again;  
  175.   
  176.     n_tty_set_room(tty);  
  177.     return retval;  
  178. }  

六.线路规程的操作函数集会调用对应的tty_struct的操作函数集
在initialize_tty_struct中tty->ops = driver->ops也就是说tty_struct的操作函数集就是tty_driver的操作函数集合

tty_driver的操作函数集设置在其register之前,例如串口的注册函数uart_register_driver中调用tty_set_operations(normal, &uart_ops)

将tty_driver->ops设置为uart_ops。

这样我们对/dev/ttyXXX的操作的调用顺序:字符设备的操作函数集tty_fops-->线路规程的操作函数集tty_ldisc_N_TTY-->串口核心或其他类型设备的操作函数集uart_ops
五 linux 串口驱动

你可能感兴趣的:(四 linux tty驱动)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 2022-04-18 Apbenz
    语重心长的和我说，不要老是说不行，人至而立之年危机四伏，内在的，外在的，感觉就是心力憔悴，让人无所适从。面对职场的无情，突然好羡慕干体力劳动的外卖小哥。难道命运是想让我去送外卖了吗？干体力活才能让我活下去？fastadmin打卡成功,淘宝金币任务完成。ㅏㅓㅗㅜㅡㅣㅐㅔㅑㅕㅛㅠㅢㅒㅖY行。야자여자요리우유의사얘기예
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖 陟彼高冈yu 基于Googleearthstudio的旅游规划和预览旅游
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 我的黑历史 袖手围观有来有去
    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 东南林氏之九牧林候选父系 祖缘树TheYtree
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集 高省APP珊珊
    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 百善孝为先 杜友顺
    2018年11月29日天气~晴星期四找点空闲找点时间领着孩子常回家看看带上笑容带上祝福陪同爱人常回家看看家，永远是儿女们幸福温暖的港湾，那里有我们日夜思念的父母，有着彼此的牵挂，无论走到哪里，家永远是避风雨的港湾。今天没事，和媳妇回了趟老家，看看父母，回到家，房间里不算凌乱，可是细心的我发现有的地方已经沾满了灰尘，桌子上父亲不离手的烟灰缸也弹满了烟灰。几个马上就要腐烂掉的水果蔫耷的搭拉着脑袋躺在了
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南） 诚芯微科技 社交电子
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • 想家，想念家乡的四季 三妹杨敏
    不知道，为什么，这次我回自己出生地—老家，反倒有了一种出差走亲戚的感觉。人啊，出来得久了，就生分了。就不再那么心贴着心脸对着脸了。需要时间，需要机缘，需要我们再重新把自己的思维重置一遍，你才能够转得回这个弯儿的。最好的转弯儿，不是说教，也不是余旧，都有些治标不治本。真正管用的东西，只有一样。也简单。一个字：吃。吃一顿家乡的饭，喝一口家乡的水，听一听那浓重得有些陌生的乡音，心就回来了。心回来，人才算
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 《大兴安岭猎人传说》今年最好看的东北鬼怪故事，很优秀 一部电影
    《大兴安岭猎人传说》是最新上映于愚人节的网剧，别看是网剧却远超出我的个人预料。该片由民俗故事改编，这点就很吸引人，因为民俗故事口口相传，比那些编造而成的鬼故事更具有了真实性，网大做的电影还不错哦，如果可以我打四星好评。大兴安岭的故事我们经常听老人提起，那里有原始大森林，物产丰富，更流传着精灵怪物的传说。什么红黄白柳灰，出马仙、人参娃娃的故事层出不穷，以大兴安岭为背景的故事真不少。可很多鬼片看到最后
  • 矩阵求逆（JAVA）初等行变换 qiuwanchi 矩阵求逆（JAVA）
    package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(初等行变换) * @author 邱万迟 *
  • JDK timer antlove javajdkschedulecodetimer
    1.java.util.Timer.schedule(TimerTask task, long delay)：多长时间（毫秒）后执行任务 2.java.util.Timer.schedule(TimerTask task, Date time)：设定某个时间执行任务 3.java.util.Timer.schedule(TimerTask task, long delay,longperiod
  • JVM调优总结 -Xms -Xmx -Xmn -Xss coder_xpf jvm应用服务器
    堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。 典型设置： java -Xmx
  • JDBC连接数据库 Array_06 jdbc
    package Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JDBCUtil { //完
  • Unsupported major.minor version 51.0（jdk版本错误） oloz java
    java.lang.UnsupportedClassVersionError: cn/support/cache/CacheType : Unsupported major.minor version 51.0 (unable to load class cn.support.cache.CacheType) at org.apache.catalina.loader.WebappClassL
  • 用多个线程处理1个List集合 362217990 多线程threadlist集合
      昨天发了一个提问，启动5个线程将一个List中的内容，然后将5个线程的内容拼接起来，由于时间比较急迫，自己就写了一个Demo，希望对菜鸟有参考意义。。 import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public c
  • JSP简单访问数据库 香水浓 sqlmysqljsp
    学习使用javaBean，代码很烂，仅为留个脚印 public class DBHelper { private String driverName; private String url; private String user; private String password; private Connection connection; privat
  • Flex4中使用组件添加柱状图、饼状图等图表 AdyZhang Flex
    1.添加一个最简单的柱状图 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 <?xml version= "1.0"&n
  • Android 5.0 - ProgressBar 进度条无法展示到按钮的前面 aijuans android
    在低于SDK < 21 的版本中，ProgressBar 可以展示到按钮前面，并且为之在按钮的中间，但是切换到android 5.0后进度条ProgressBar 展示顺序变化了，按钮再前面，ProgressBar 在后面了我的xml配置文件如下：   [html]  view plain copy   <RelativeLa
  • 查询汇总的sql baalwolf sql
    select   list.listname, list.createtime,listcount from dream_list as list ,   (select listid,count(listid) as listcount  from dream_list_user  group by listid  order by count(
  • Linux du命令和df命令区别 BigBird2012 linux
            1，两者区别             du，disk usage,是通过搜索文件来计算每个文件的大小然后累加，du能看到的文件只是一些当前存在的，没有被删除的。他计算的大小就是当前他认为存在的所有文件大小的累加和。        
  • AngularJS中的$apply，用还是不用？ bijian1013 JavaScriptAngularJS$apply
            在AngularJS开发中，何时应该调用$scope.$apply()，何时不应该调用。下面我们透彻地解释这个问题。         但是首先，让我们把$apply转换成一种简化的形式。         scope.$apply就像一个懒惰的工人。它需要按照命
  • [Zookeeper学习笔记十]Zookeeper源代码分析之ClientCnxn数据序列化和反序列化 bit1129 zookeeper
    ClientCnxn是Zookeeper客户端和Zookeeper服务器端进行通信和事件通知处理的主要类，它内部包含两个类，1. SendThread 2. EventThread， SendThread负责客户端和服务器端的数据通信，也包括事件信息的传输，EventThread主要在客户端回调注册的Watchers进行通知处理   ClientCnxn构造方法   &
  • 【Java命令一】jmap bit1129 Java命令
    jmap命令的用法：   [hadoop@hadoop sbin]$ jmap Usage: jmap [option] <pid> (to connect to running process) jmap [option] <executable <core> (to connect to a
  • Apache 服务器安全防护及实战 ronin47
    此文转自IBM. Apache 服务简介 Web 服务器也称为 WWW 服务器或 HTTP 服务器 (HTTP Server)，它是 Internet 上最常见也是使用最频繁的服务器之一，Web 服务器能够为用户提供网页浏览、论坛访问等等服务。 由于用户在通过 Web 浏览器访问信息资源的过程中，无须再关心一些技术性的细节，而且界面非常友好，因而 Web 在 Internet 上一推出就得到
  • unity 3d实例化位置出现布置？ brotherlamp unity教程unityunity资料unity视频unity自学
    问：unity 3d实例化位置出现布置？ 答：实例化的同时就可以指定被实例化的物体的位置,即 position  Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object 这样你不需要再用Transform.Position了,   如果你省略了第二个参数(
  • 《重构，改善现有代码的设计》第八章 Duplicate Observed Data bylijinnan java重构
    import java.awt.Color; import java.awt.Container; import java.awt.FlowLayout; import java.awt.Label; import java.awt.TextField; import java.awt.event.FocusAdapter; import java.awt.event.FocusE
  • struts2更改struts.xml配置目录 chiangfai struts.xml
    struts2默认是读取classes目录下的配置文件，要更改配置文件目录，比如放在WEB-INF下，路径应该写成../struts.xml(非/WEB-INF/struts.xml) web.xml文件修改如下：   <filter> <filter-name>struts2</filter-name> <filter-class&g
  • redis做缓存时的一点优化 chenchao051 redishadooppipeline
            最近集群上有个job，其中需要短时间内频繁访问缓存，大概7亿多次。我这边的缓存是使用redis来做的，问题就来了。       首先，redis中存的是普通kv，没有考虑使用hash等解结构，那么以为着这个job需要访问7亿多次redis，导致效率低，且出现很多redi
  • mysql导出数据不输出标题行 daizj mysql数据导出去掉第一行去掉标题
    当想使用数据库中的某些数据，想将其导入到文件中，而想去掉第一行的标题是可以加上-N参数 如通过下面命令导出数据： mysql -uuserName -ppasswd -hhost -Pport -Ddatabase -e " select * from tableName"  > exportResult.txt 结果为： studentid
  • phpexcel导出excel表简单入门示例 dcj3sjt126com PHPExcelphpexcel
    先下载PHPEXCEL类文件，放在class目录下面，然后新建一个index.php文件，内容如下 <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE);   if (PHP_SAPI == 'cli') die('
  • 爱情格言 dcj3sjt126com 格言
     1) I love you not because of who you are, but because of who I am when I am with you. 　　 我爱你，不是因为你是一个怎样的人，而是因为我喜欢与你在一起时的感觉。 　　2) No man or woman is worth your tears, and the one who is, won‘t
  • 转 Activity 详解——Activity文档翻译 e200702084 androidUIsqlite配置管理网络应用
    activity 展现在用户面前的经常是全屏窗口，你也可以将 activity 作为浮动窗口来使用（使用设置了 windowIsFloating 的主题），或者嵌入到其他的 activity （使用 ActivityGroup ）中。 当用户离开 activity 时你可以在 onPause() 进行相应的操作 。更重要的是，用户做的任何改变都应该在该点上提交 ( 经常提交到 ContentPro
  • win7安装MongoDB服务 geeksun mongodb
    1.  下载MongoDB的windows版本：mongodb-win32-x86_64-2008plus-ssl-3.0.4.zip，Linux版本也在这里下载，下载地址： http://www.mongodb.org/downloads   2.  解压MongoDB在D:\server\mongodb, 在D:\server\mongodb下创建d
  • Javascript魔法方法:__defineGetter__,__defineSetter__ hongtoushizi js
    转载自： http://www.blackglory.me/javascript-magic-method-definegetter-definesetter/ 在javascript的类中,可以用defineGetter和defineSetter_控制成员变量的Get和Set行为 例如,在一个图书类中,我们自动为Book加上书名符号: function Book(name){
  • 错误的日期格式可能导致走nginx proxy cache时不能进行304响应 jinnianshilongnian cache
    昨天在整合某些系统的nginx配置时，出现了当使用nginx cache时无法返回304响应的情况，出问题的响应头： Content-Type:text/html; charset=gb2312 Date:Mon, 05 Jan 2015 01:58:05 GMT Expires:Mon , 05 Jan 15 02:03:00 GMT Last-Modified:Mon, 05
  • 数据源架构模式之行数据入口 home198979 PHP架构行数据入口
    注：看不懂的请勿踩，此文章非针对java，java爱好者可直接略过。   一、概念 行数据入口（Row Data Gateway）：充当数据源中单条记录入口的对象，每行一个实例。   二、简单实现行数据入口 为了方便理解，还是先简单实现： <?php /** * 行数据入口类 */ class OrderGateway { /*定义元数
  • Linux各个目录的作用及内容 pda158 linux脚本
    1）根目录“/” 　　根目录位于目录结构的最顶层，用斜线（/）表示，类似于 Windows 操作系统的“C:\“，包含Fedora操作系统中所有的目录和文件。 　　2）/bin 　　/bin 　　目录又称为二进制目录，包含了那些供系统管理员和普通用户使用的重要 linux命令的二进制映像。该目录存放的内容包括各种可执行文件，还有某些可执行文件的符号连接。常用的命令有：cp、d
  • ubuntu12.04上编译openjdk7 ol_beta HotSpotjvmjdkOpenJDK
    获取源码 从openjdk代码仓库获取(比较慢) 安装mercurial Mercurial是一个版本管理工具。 sudo apt-get install mercurial 将以下内容添加到$HOME/.hgrc文件中，如果没有则自己创建一个： [extensions] forest=/home/lichengwu/hgforest-crew/forest.py fe
  • 将数据库字段转换成设计文档所需的字段 vipbooks 设计模式工作正则表达式
            哈哈，出差这么久终于回来了，回家的感觉真好！         PowerDesigner的物理数据库一出来，设计文档中要改的字段就多得不计其数，如果要把PowerDesigner中的字段一个个Copy到设计文档中，那将会是一件非常痛苦的事情。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他