一文搞懂Linux下并制作环形缓冲区

news2024/11/15 11:29:28

1.环形缓冲区log_buf[]又是存在内核的哪个文件呢？

位于/proc/kmsg里,所以除了dmesg命令查看,也可以使用cat /proc/kmsg来查看

2.但是,dmesg命令和cat /proc/kmsg有所不同

2.1 dmesg命令

每次使用,都会打印出环形缓冲区的所有信息

2.2 cat /proc/kmsg

只会打印出每次新的环形缓冲区的信息

比如,第一次使用cat /proc/kmsg,会打印出内核启动的所有信息

第二次使用cat /proc/kmsg,就不会出现之前打印的信息,只打印继上次使用cat /proc/kmsg之后的新的信息,比如下图所示:

【文章福利】小编推荐自己的Linux内核技术交流群:【 865977150】整理了一些个人觉得比较好的学习书籍、视频资料共享在群文件里面，有需要的可以自行添加哦！！！前100名进群领取，额外赠送一份价值 699的内核资料包（含视频教程、电子书、实战项目及代码)

资料直通车：最新Linux内核源码资料文档+视频资料

学习直通车：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈

3.接下来我们便进入内核,找/proc/kmsg文件在哪生成的

搜索"kmsg",找到位于fs\proc\proc_misc.c 文件的proc_misc_init()函数中,

该函数主要用来生成登记的设备文件,具体代码如下所示:

const struct file_operations proc_kmsg_operations = {
       .read              = kmsg_read,               //读函数
       .poll        = kmsg_poll,
       .open             = kmsg_open,
       .release   = kmsg_release,
};
 

void __init proc_misc_init(void)
{
  ... ...
  struct proc_dir_entry *entry;                                   // 用来描述文件的结构体,
         entry = create_proc_entry("kmsg", S_IRUSR, &proc_root); //使用create_proc_entry()创建文件
if (entry)
         entry->proc_fops = &proc_kmsg_operations;    //对创建的文件赋入file_ operations
    ... ...
}

从上面代码得出,/proc/kmsg文件,也是有file_operations结构体的,而cat命令就会一直读/proc/kmsg的file_operations->read(),实现读log_buf[]的数据

且/proc/kmsg文件是通过create_proc_entry()创建出来的,参数如下所示:

"kmsg":文件名

&proc_root:父目录,表示存在/proc根目录下

S_IRUSR: 等于400,表示拥有者(usr)可读,其他任何人不能进行任何操作,如下图所示:

该参数和chmod命令参数一样,除了S_IRUSR还有很多参数,比如:

S_IRWXU: 等于700, 表示拥有者(usr)可读(r)可写(w)可执行(x)

S_IRWXG: 等于070, 表示拥有者和组用户 (group)可读(r)可写(w)可执行(x)

4.为什么使用dmesg命令和cat /proc/kmsg会有这么大的区别？

我们进入proc_kmsg_operations-> kmsg_read()看看,就知道了

static ssize_t kmsg_read(struct file *file, char __user *buf,size_t count, loff_t *ppos)
{
       /*若在非阻塞访问,且没有读的数据,则立刻return*/
       if ((file->f_flags & O_NONBLOCK) && !do_syslog(9, NULL, 0))
              return -EAGAIN;
       return do_syslog(2, buf, count);          //开始读数据,buf:用户层地址,count:要读的数据长度
}

5.proc_kmsg_operations-> kmsg_read()->do_syslog(9, NULL, 0)的内容如下所示:

其中log_start和log_end就是环形缓冲区的两个标志, log_start也可以称为读标志位, log_end也可以称为写标志位,当写标志和读标志一致时,则表示没有读的数据了。

6.proc_kmsg_operations-> kmsg_read()->do_syslog(2, buf, count)的内容如下所示:

case 2:           /* Read from log */
              error = -EINVAL;
              if (!buf || len < 0)           //判断用户层是否为空,以及读数据长度
                     goto out;
              error = 0;
              if (!len)
                     goto out;
              if (!access_ok(VERIFY_WRITE, buf, len)) {      // access_ok:检查用户层地址是否访问OK
                     error = -EFAULT;
                     goto out;
              }

              /*若没有读的数据,则进入等待队列*/
              error = wait_event_interruptible(log_wait, (log_start - log_end));
              if (error)
                    goto out;

              i = 0;
              spin_lock_irq(&logbuf_lock);        
              while (!error && (log_start != log_end) && i < len) {
                     c = LOG_BUF(log_start);         // LOG_BUF:取环形缓冲区log_buf[]里的某个位置的数据
                     log_start++;                        //读地址++
                     spin_unlock_irq(&logbuf_lock);
                     error = __put_user(c,buf);            //和 copy_to_user()函数一样,都是上传用户数据
                     buf++;                                       //用户地址++
                     i++;                                        //读数据长度++
                     cond_resched();
                     spin_lock_irq(&logbuf_lock);
              }
              spin_unlock_irq(&logbuf_lock);
              if (!error)
                     error = i;
              break;}
out:
       return error;
}

显然就是对环形缓冲区的读操作,而环形缓冲区的原理又是什么?

7.接下来便来分析环形缓冲区的原理

和上面函数一样, 环形缓冲区需要一个全局数组,还需要两个标志:读标志R、写标志W

我们以一个全局数组my_buff[7]为例,来分析:

7.1环形缓冲区初始时:

int R=0;             //记录读的位置
int W=0;             //记录写的位置

上面的代码,如下图1所示:

R:从数组[R]开始读数据

W:从数组[W]开始写数据

所以,当R==W时,则表示没有数据可读,通过这个逻辑便能写出读数据了

7.2当我们需要读数据时:

int read_buff(char  *p)              //p:指向要读出的地址
{
if(R==W)            
      return 0;       //读失败
*p=my_buff[R];
R=(R+1)%7;      //R++    
return  1;         //读成功  
}

我们以W=3,R=0,为例,调用3次read_buff()函数,如下图所示:

读数据完成,剩下就是写数据了,很显然每写一个数据,W则++

7.3所以写数据函数为:

void write_buff(char c)              //c:等于要写入的内容
{
  my_buff [W]=c;         
  W=(W+1)%7;    //W++          
if(W==R)
  R=(R+1)%7;      //R++
}

7.3.1 上面的代码,为什么要判断if((W==R)?

比如,当我们写入一个8个数据,而my_buff[]只能存7个数据,必定会有W==R的时候,如果不加该判断,效果图如下所示:

然后我们再多次调用read_buff(),就会发现只读得出第8个数据的值,而前面7个数据都会被遗弃掉

7.3.2 而加入判断后,效果图如下所示:

然后我们再多次调用read_buff(),就可以读出my_buff [2]~ my_buff [0]共6个数据出来

总结:

由于read_buff()后,R都会+1,所以每次 cat /proc/kmsg , 都会清空上次的打印信息。

8.环形缓冲区分析完毕后,我们就可以直接来写一个驱动,模仿/proc/kmsg文件来看看

流程如下:

  • 1)定义全局数组my_buff[1000]环形缓冲区,R标志,W标志,然后提供写函数,读函数
  • 2)自制一个myprintk(),通过传入的数据来放入到my_buff[]环形缓冲区中
  • (PS:需要通过EXPORT_SYMBOL(myprintk)声明该myprintk,否则不能被其它驱动程序调用 )
  • 3)写入口函数
  • ->3.1) 通过create_proc_entry()创建/proc/mykmsg文件
  • ->3.2 )并向mykmsg文件里添加file_operations结构体
  • 4)写出口函数
  • ->4.1) 通过remove_proc_entry()卸载/proc/mykmsg文件
  • 5)写file_operations->read()函数
  • ->5.1) 仿照/proc/kmsg的read()函数,来读my_buff[]环形缓冲区的数据

具体代码如下所示:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/proc_fs.h>

#define my_buff_len   1000          //环形缓冲区长度

static struct proc_dir_entry *my_entry;


/*    声明等待队列类型中断 mybuff_wait      */
static DECLARE_WAIT_QUEUE_HEAD(mybuff_wait);


static char my_buff[my_buff_len]; 
unsigned long R=0;                      //记录读的位置
unsigned long W=0;                    //记录写的位置
 
int read_buff(char  *p)         //p:指向要读出的地址
{
   if(R==W)          
             return 0;               //读失败
        *p=my_buff[R]; 
         R=(R+1)%my_buff_len;       //R++
        return  1;                   //读成功   
}

void write_buff(char c)          //c:等于要写入的内容
{    
        my_buff [W]=c;       
        W=(W+1)%my_buff_len;     //W++
        if(W==R)
            R=(R+1)%my_buff_len;     //R++
       wake_up_interruptible(&mybuff_wait);     //唤醒队列,因为R != W 
}

/*打印到my_buff[]环形缓冲区中*/
int myprintk(const char *fmt, ...)
{
       va_list args;
       int i,len;
       static char temporary_buff[my_buff_len];        //临时缓冲区
       va_start(args, fmt);
       len=vsnprintf(temporary_buff, INT_MAX, fmt, args);
       va_end(args);

        /*将临时缓冲区放入环形缓冲区中*/
       for(i=0;i<len;i++)       
       {
            write_buff(temporary_buff[i]);
       }
       return len;
}

static int mykmsg_open(struct inode *inode, struct file *file)
{
        return 0;
}  

static int mykmsg_read(struct file *file, char __user *buf,size_t count, loff_t *ppos)
{
      int error = 0,i=0;
      char c;

        if((file->f_flags&O_NONBLOCK)&&(R==W))      //非阻塞情况下,且没有数据可读
            return  -EAGAIN;
             error = -EINVAL;
              if (!buf || !count )
                     goto out;
             error = wait_event_interruptible(mybuff_wait,(W!=R));
              if (error)
                     goto out;
       while (!error && (read_buff(&c)) && i < count) 
      {
        error = __put_user(c,buf);      //上传用户数据
        buf ++;
        i++;
      }

      if (!error)
               error = i;
out:
       return error;
}  

const struct file_operations mykmsg_ops = {
       .read              = mykmsg_read,
       .open         = mykmsg_open,
};
static int  mykmsg_init(void)
{
    my_entry = create_proc_entry("mykmsg", S_IRUSR, &proc_root);
   if (my_entry)
         my_entry->proc_fops = &mykmsg_ops;
    return 0;
}
static void mykmsg_exit(void)
{
        remove_proc_entry("mykmsg", &proc_root);  
}

module_init(mykmsg_init);
module_exit(mykmsg_exit); 
EXPORT_SYMBOL(myprintk);
MODULE_LICENSE("GPL");

PS:当其它驱动向使用myprintk()打印函数,还需要在文件中声明,才行:

extern int myprintk(const char *fmt, ...);

且还需要先装载mykmsg驱动,再来装载要使用myprintk()的驱动,否则无法找到myprintk()函数

9.测试运行

如下图所示,挂载了mykmsg驱动,可以看到生成了一个/proc/mykmsg文件

挂载/proc/mykmsg期间,其它驱动使用myprintk()函数,就会将信息打印在/proc/mykmsg文件中,如下图所示:

和cat /proc/kmsg一样,每次cat 都会清上一次的打印数据

10.若我们不想每次清,和dmesg命令一样, 每次都能打印出环形缓冲区的所有信息,该如何改mykmsg驱动?

上次我们分析过了,每次调用read_buff()后,R都会+1。

要想不清空上次的信息打印,还需要定义一个R_ current标志来代替R标志,这样每次cat结束后,R的位置保持不变。

每次cat时,系统除了进入file_operations-> read(),还会进入file_operations-> open(),所以在open()里,使R_ current=R,然后在修改部分代码即可,

10.1我们还是以一个全局数组my_buff[7]为例, 如下图所示:

10.2所以,修改的代码如下所示:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/proc_fs.h>
#define my_buff_len   1000          //环形缓冲区长度
 
static struct proc_dir_entry *my_entry;
 
/*    声明等待队列类型中断 mybuff_wait      */
static DECLARE_WAIT_QUEUE_HEAD(mybuff_wait);

static char my_buff[my_buff_len];

unsigned long R=0;                      //记录读的位置
unsigned long R_current=0;             //记录cat期间 读的位置
unsigned long W=0;                    //记录写的位置

int read_buff(char  *p)         //p:指向要读出的地址
{
        if(R_current==W)             
             return 0;               //读失败
        *p=my_buff[R_current]; 
         R_current=(R_current+1)%my_buff_len;     //R_current++
        return  1;                   //读成功   
}

void write_buff(char c)          //c:等于要写入的内容
{    
        my_buff [W]=c;       
        W=(W+1)%my_buff_len;     //W++
        if(W==R)
          R=(R+1)%my_buff_len;     //R++
        if(W==R_current)
          R=(R+1)%my_buff_len;     //R_current++
       wake_up_interruptible(&mybuff_wait);     //唤醒队列,因为R !=W 
}

/*打印到my_buff[]环形缓冲区中*/
int myprintk(const char *fmt, ...)
{
  va_list args;
  int i,len;
  static char temporary_buff[my_buff_len];        //临时缓冲区
  va_start(args, fmt);
  len=vsnprintf(temporary_buff, INT_MAX, fmt, args);
  va_end(args);
     /*将临时缓冲区放入环形缓冲区中*/
       for(i=0;i<len;i++)       
       {
            write_buff(temporary_buff[i]);
       }
  return len;
}

static int mykmsg_open(struct inode *inode, struct file *file)
{
        R_current=R;       
        return 0;
}  

static int mykmsg_read(struct file *file, char __user *buf,size_t count, loff_t *ppos)
{
      int error = 0,i=0;
      char c;     
        if((file->f_flags&O_NONBLOCK)&&(R_current==W))      //非阻塞情况下,且没有数据可读
            return  -EAGAIN;
        error = -EINVAL;
       if (!buf || !count )
              goto out;

       error = wait_event_interruptible(mybuff_wait,(W!=R_current));
       if (error)
              goto out;
    
      while (!error && (read_buff(&c)) && i < count) 
      {
        error = __put_user(c,buf);      //上传用户数据
        buf ++;
        i++;
      }

      if (!error)
        error = i;

out:
  return error;
}  

const struct file_operations mykmsg_ops = {
  .read         = mykmsg_read,
  .open         = mykmsg_open,

};

static int  mykmsg_init(void)
{
    my_entry = create_proc_entry("mykmsg", S_IRUSR, &proc_root);
   if (my_entry)
    my_entry->proc_fops = &mykmsg_ops;
    return 0;
}
static void mykmsg_exit(void)
{
   remove_proc_entry("mykmsg", &proc_root);
}

module_init(mykmsg_init);
module_exit(mykmsg_exit); 
EXPORT_SYMBOL(myprintk); 
MODULE_LICENSE("GPL");

11.测试运行

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/108382.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

项目管理中，进度计划是摆设吗？

项目管理中，进度计划是摆设吗？

1、忽视进度计划 项目管理中&#xff0c;有的人认为进度计划是摆设&#xff0c;不重视计划&#xff0c;只是为了满足合同工期&#xff0c;做给客户看&#xff0c;因此草率的编制进度计划。 在通过客户要求后&#xff0c;就将计划搁置在一边&#xff0c;这就导致后期在执行任务…
阅读更多...
科班演员陶奕菱亮相海南电影节：人生没有白走的路，每一步都算数

科班演员陶奕菱亮相海南电影节：人生没有白走的路，每一步都算数

今天的记忆是带着海水的味道………”12月18日&#xff0c;在年末岁尾之际&#xff0c;徽风皖韵熏陶下成长的新生代演员陶奕菱再次来到海南三亚&#xff0c;受邀参加第四届海南岛国际电影节&#xff0c;迫不及待地跑向沙滩面朝大海&#xff0c;感受多姿多彩的魅力三亚。 优雅端…
阅读更多...
Java对象内存布局和对象头

Java对象内存布局和对象头

对象的内存布局 在HotSpot虚拟机里&#xff0c;对象在堆内存中的存储布局可以划分为三个部分&#xff1a;对象头&#xff08;Header&#xff09;、实例数据&#xff08;Instance Data&#xff09;和对齐填充&#xff08;Padding&#xff09;。 对象头 对象头由对象标记Mark W…
阅读更多...
进程间通信

进程间通信

进程间通信 进程间通信是不同进程之间的信息传输或交换。在不同的过程中&#xff0c;双方可以访问哪些媒体&#xff1f;进程的用户空间相互独立。一般来说&#xff0c;他们不能互相接触。唯一的例外是共享内存区域。此外&#xff0c;系统空间是一个“公共场所”&#xff0c;所…
阅读更多...
【OFDM系列8】对知乎“正交频分复用(OFDM)原理灵魂9问”的理解与通俗易懂回答(慎入，含大量重要公式详细推导的万字长文)

【OFDM系列8】对知乎“正交频分复用(OFDM)原理灵魂9问”的理解与通俗易懂回答(慎入，含大量重要公式详细推导的万字长文)

前段时间，在知乎上看到一篇文章： 正交频分复用（OFDM）原理 文中博主提出了关于OFDM的九个问题，看了之后感觉这些问题的确深入OFDM本质，仔细思考可以很好地加深对OFDM这种较为复杂的调制方式的理解，下面谈一谈本人粗浅的一些理解和粗浅的认识，如有不准确或不恰当之处，欢…
阅读更多...
电脑里一辈子都不想删的神仙软件

电脑里一辈子都不想删的神仙软件

&#x1f4c2;目录&#x1f388;前言一、浏览器&#xff1a;Chrome新版Edge二、motrix-全能下载器三、压缩软件&#xff1a;WinRAR四、Quicker(更快)五、视频播放器&#xff1a;Potplayer六、listary七、清理工具&#xff1a;Dism八、199it九、PPT排版&#xff1a;iSlide十、 S…
阅读更多...
jQuery 动画

jQuery 动画

文章目录jQuery 动画概述显示和隐藏动画show() 和 hide()toggle()淡入和淡出动画fadeIn() 和 fadeOut()fadeToggle()fadeTo()滑上和滑下动画slideUp()和slideDown()slideToggle()自定义动画简单动画jquery.color.js累积动画回调函数队列动画取消动画延迟动画jQuery 动画 概述 …
阅读更多...
程序设计中的耦合类型

程序设计中的耦合类型

一个庞大的系统中&#xff0c;分布着许多子系统&#xff0c;子系统中包含许多包&#xff0c;包中又有数不清的类。自类往上&#xff0c;有数不清的调用关系&#xff0c;一旦两个或多个对象&#xff08;包括类、包、模块、系统等&#xff09;之间发生关系&#xff08;这里我们可…
阅读更多...
提升 5-7 倍速，使用 Mac M1 芯片加速 Pytorch 完全指南

提升 5-7 倍速，使用 Mac M1 芯片加速 Pytorch 完全指南

2022年5月&#xff0c;PyTorch官方宣布已正式支持在M1芯片版本的Mac上进行模型加速。官方对比数据显示&#xff0c;和CPU相比&#xff0c;M1上炼丹速度平均可加速7倍。 哇哦&#xff0c;不用单独配个GPU也能加速这么多&#xff0c;我迫不及待地搞到一个M1芯片的MacBook后试水了…
阅读更多...
CISCO 服务器配置 RAID 指南及安装操作系统

CISCO 服务器配置 RAID 指南及安装操作系统

开机后看屏幕出现下图后按 Ctrlm 进入 RAID 配置主页 下图为 RAID 主页. 首先创建一个新的配置. 按SPACE选择要加入的硬盘&#xff0c;然后按F10确定 选择 SPAN-1 选择RAID级别&#xff0c;读写策略... 完成以上步骤后按YES保存配置 选择 Initialize 初始化硬盘 选择YES确定&a…
阅读更多...
zabbix添加一个ubuntu受监控主机

zabbix添加一个ubuntu受监控主机

ubuntu版本18.04 LTS 安装一个zabbix-agent，命令如下： sudo apt install zabbix-agent 安装成功后编辑zabbix-agent配置文件 vim /etc/zabbix/zabbix_agentd.conf Server: 被动模式访问的zabbix-server的ip ServerActive: 主动模式访问的zabbix-server的ip StartAgent…
阅读更多...
实验三 多层神经网络

实验三 多层神经网络

一、实验目的 &#xff08;1&#xff09;学习并掌握常见的机器学习方法&#xff1b; &#xff08;2&#xff09;能够结合所学的python知识实现机器学习算法&#xff1b; &#xff08;3&#xff09;能够用所学的机器学习算法解决实际问题。 二、实验内容与要求 &#xff08…
阅读更多...
Android | Activity 启动流程分析

Android | Activity 启动流程分析

前言 Activity 类是 android 应用的关键组件&#xff0c;在日常开发中&#xff0c;绝对少不了组件。既然用了这么久&#xff0c;你知道他的启动流程&#x1f434;&#xff1f;作为一个应用层开发者&#xff0c;大多数人可能觉得学习这些对日常开发可能没有太大帮助。但是多了解…
阅读更多...
P3386 【模板】二分图最大匹配——匈牙利算法

P3386 【模板】二分图最大匹配——匈牙利算法

【模板】二分图最大匹配 题目描述 给定一个二分图&#xff0c;其左部点的个数为 nnn&#xff0c;右部点的个数为 mmm&#xff0c;边数为 eee&#xff0c;求其最大匹配的边数。 左部点从 111 至 nnn 编号&#xff0c;右部点从 111 至 mmm 编号。 输入格式 输入的第一行是三…
阅读更多...
文件描述符表、文件结构表和文件节点（SylixOS 学习笔记-更新中）

文件描述符表、文件结构表和文件节点（SylixOS 学习笔记-更新中）

文件描述符表、文件结构表和文件节点 文件描述符表&#xff1a;每个进程都维护着自己的一个文件描述符表&#xff0c;每个文件描述符占其中一。该表记录进程打开的文件相关信息&#xff0c;因文件描述符为进程所有&#xff0c;文件描述符表也为进程内共享&#xff1b;文件表结构…
阅读更多...
CDGA|把握三个“着眼点”，实现数据要素治理市场高质量发展

CDGA|把握三个“着眼点”，实现数据要素治理市场高质量发展

12月19日&#xff0c;国家发改委发文解读《意见》时指出&#xff0c;数据要素安全治理作为数据基础制度的四大组成部分之一&#xff0c;贯穿数据流通交易的各个环节&#xff0c;涉及数据要素市场培育的方方面面&#xff0c;发挥着不可替代的重要作用既有利于保障国家数据安全&a…
阅读更多...
视频网站节约 30% 成本的秘密在这里

视频网站节约 30% 成本的秘密在这里

今年&#xff0c;爱奇艺宣布2022年第一季度首次实现季度盈利&#xff0c;这是爱奇艺在过去三个季度中&#xff0c;毛利率持续增长&#xff0c;且运营费用持续下降带来的结果。长视频行业发展十几年来&#xff0c;一直深陷亏损旋涡。爱奇艺的首次实现季度盈利&#xff0c;也意味…
阅读更多...
多重背包问题（详解二进制优化原理）

多重背包问题（详解二进制优化原理）

多重背包问题及优化&#xff08;详解优化原理&#xff09;一、问题描述二、思路分析1、状态转移方程&#xff08;1&#xff09;状态表示&#xff1a;&#xff08;2&#xff09;状态转移&#xff1a;2、循环设计三、代码模板1、朴素版2、优化版一、问题描述 二、思路分析 这道题…
阅读更多...
JVM垃圾回收机制

JVM垃圾回收机制

目录 目录 前言 一. GC (垃圾回收机制) STW问题 二. GC 回收哪部分内存 三. 具体怎么回收 1. 先找出垃圾 a.引用计数 b. 可达性分析 2. 回收垃圾 a. 标记清除 b. 复制算法 c. 标记整理 d. 分代回收 前言 我们都知道 Java 运行时内存的各个区域. 对于程序计数器 …
阅读更多...
数据库与身份认证：在项目中操作 MySQL

数据库与身份认证：在项目中操作 MySQL

在项目中操作数据库的步骤 ①安装操作 MySQL 数据库的第三方模块&#xff08;mysql&#xff09; ②通过 mysql 模块连接到 MySQL 数据库 ③通过 mysql 模块执行 SQL 语句 安装与配置 mysql 模块 1. 安装 mysql 模块 mysql 模块是托管于 npm 上的第三方模块。它提供了在 Nod…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023