内核内存管理、动态分配及IO访问、LED驱动

最新推荐文章于 2024-10-13 21:29:35 发布
最新推荐文章于 2024-10-13 21:29:35 发布
阅读量137 收藏
点赞数
文章标签： 驱动开发 linux 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36091214/article/details/132661059
版权

一、内核内存管理框架

内核将物理内存等分成N块4KB，称之为一页，每页都用一个struct page来表示，采用伙伴关系算法维护

在这里插入图片描述

内核地址空间划分图：

在这里插入图片描述

3G~3G+896M：低端内存，直接映射 虚拟地址 = 3G + 物理地址

​ 细分为：ZONE_DMA、ZONE_NORMAL

​ 分配方式：

					1. kmalloc:小内存分配，slab算法
					2. get_free_page：整页分配，2的n次方页，n最大为10

大于3G+896M：高端内存

​ 细分为：vmalloc区、持久映射区、固定映射区

​ 分配方式：vmalloc：虚拟地址连续，物理地址不连续

​

二、内核中常用动态分配

2.1 kmalloc

​ 函数原型：

void *kmalloc(size_t size, gfp_t flags);

kmalloc() 申请的内存位于直接映射区域，而且在物理上也是连续的，它们与真实的物理地址只有一个固定的偏移，因为存在较简单的转换关系，所以对申请的内存大小有限制，不能超过128KB。
　　
较常用的 flags（分配内存的方法）：

  • GFP_ATOMIC —— 分配内存的过程是一个原子过程，分配内存的过程不会被（高优先级进程或中断）打断；
  • GFP_KERNEL —— 正常分配内存；
  • GFP_DMA —— 给 DMA 控制器分配内存，需要使用该标志（DMA要求分配虚拟地址和物理地址连续）。

flags 的参考用法：
　|– 进程上下文，可以睡眠　　　　　GFP_KERNEL
　|– 异常上下文，不可以睡眠　　　　GFP_ATOMIC
　|　　|– 中断处理程序　　　　　　　GFP_ATOMIC
　|　　|– 软中断　　　　　　　　　　GFP_ATOMIC
　|　　|– Tasklet　　　　　　　　　GFP_ATOMIC
　|– 用于DMA的内存，可以睡眠　　　GFP_DMA | GFP_KERNEL
　|– 用于DMA的内存，不可以睡眠　　GFP_DMA |GFP_ATOMIC
　　
对应的内存释放函数为：

void kfree(const void *objp);

void *kzalloc(size_t size, gfp_t flags)

2.2 vmalloc

void *vmalloc(unsigned long size);

vmalloc() 函数则会在虚拟内存空间给出一块连续的内存区，但这片连续的虚拟内存在物理内存中并不一定连续。由于 vmalloc() 没有保证申请到的是连续的物理内存，因此对申请的内存大小没有限制，如果需要申请较大的内存空间就需要用此函数了。

对应的内存释放函数为：

void vfree(const void *addr);

注意：vmalloc() 和 vfree() 可以睡眠，因此不能从异常上下文调用。

2.3 kmalloc & vmalloc 的比较

kmalloc()、kzalloc()、vmalloc() 的共同特点是：

  1. 用于申请内核空间的内存；
  2. 内存以字节为单位进行分配；
  3. 所分配的内存虚拟地址上连续；

kmalloc()、kzalloc()、vmalloc() 的区别是：

  1. kzalloc 是强制清零的 kmalloc 操作；（以下描述不区分 kmalloc 和 kzalloc）
  2. kmalloc 分配的内存大小有限制（128KB），而 vmalloc 没有限制；
  3. kmalloc 可以保证分配的内存物理地址是连续的，但是 vmalloc 不能保证；
  4. kmalloc 分配内存的过程可以是原子过程（使用 GFP_ATOMIC），而 vmalloc 分配内存时则可能产生阻塞；
  5. kmalloc 分配内存的开销小，因此 kmalloc 比 vmalloc 要快；

一般情况下，内存只有在要被 DMA 访问的时候才需要物理上连续，但为了性能上的考虑，内核中一般使用 kmalloc()，而只有在需要获得大块内存时才使用 vmalloc()。

2.4 分配选择原则：

  1. 小内存（< 128k）用kmalloc,大内存用vmalloc或get_free_page
  2. 如果需要比较大的内存，并且要求使用效率较高时用get_free_page,否则用vmalloc

申请内存示例：


int __init mychar_init(void) 
{
	int ret = 0;
	dev_t devno = MKDEV(major, minor);

	/* 手动申请设备号 */
	ret = register_chrdev_region(devno, char_num, "mychar");
	if (ret) {
		/* 动态申请设备号 */
		ret = alloc_chrdev_region(&devno, minor, char_num, "mychar");
		if(ret){
			printk("get devno failed\n");
			return -1;
		}
		/*申请成功 更新设备号*/
		major = MAJOR(devno);
	}
	
	/* 申请动态内存 kmalloc */
	pgmydev = (struct mychar_dev *)kmalloc(sizeof(struct mychar_dev), GFP_KERNEL);
	if(NULL == pgmydev) {
		unregister_chrdev_region(devno, char_num);
		printk("kmalloc for 'struct mychar_dev' failed\n");
		return -1;
	}
	
	/* 给struct cdev对象指定操作函数集 */
	cdev_init(&pgmydev->mydev, &myops);

	/* 将struct cdev对象添加到内核对应的数据结构中 */
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev, devno, char_num);
	
	return 0;
}

三、IO访问-------访问外设控制器的寄存器

在这里插入图片描述

两种方式：

  1. IO端口：X86上用IO指令访问
  2. IO内存：外设寄存器在SOC芯片手册上都有相应物理地址

IO内存访问接口：

static inline void __iomem *ioremap(unsigned long offset, unsigned long size)
/*
功能：实现IO管脚的映射
参数：offset:该管脚的偏移地址
	 Size:该管脚映射空间的大小
返回值：成功返回映射的虚拟地址,失败NULL
*/

static inline void iounmap(volatile void __iomem *addr)
/*
功能：解除io管脚的映射
参数：addr:io管脚映射的地址
*/

unsigned readb(void *addr);//1字节   或ioread8(void *addr)
unsigned readw(void *addr);//2字节   或ioread16(void *addr)
unsigned readl(void *addr);//4字节   或ioread32(void *addr)
/*
功能：读取寄存器的值
参数：addr  地址
返回值：读到的数据
*/

void writeb(unsigned value, void *addr);//1字节   或iowrite8(u8 value, void *addr)
void writew(unsigned value, void *addr);//2字节  或iowrite16(u16 value, void *addr)
void writel(unsigned value, void *addr);//4字节  或iowrite32(u32 value, void *addr)
/*
 功能：向指定的寄存器中，写入数据。
 参数：value：待写入寄存器中的数据
	  Address：寄存器的虚拟地址
*/

四、led驱动

  1. 读原理图

    在这里插入图片描述

  2. 查阅SOC芯片手册

    在这里插入图片描述

    GPX2_7 led2 GPX2CON----0x11000C40—28~31-----0001 GPX2DAT-----0x11000C44-----7

    GPX1_0 led3 GPX1CON----0x11000C20—0~3-----0001 GPX1DAT----0x11000C24-----0

    GPF3_4 led4 GPF3CON----0x114001E0—16~19-----0001 GPF3DAT----0x114001E4-----4

    GPF3_5 led5 GPF3CON----0x114001E0—20~23-----0001 GPF3DAT----0x114001E4-----5

  3. 编写驱动

    a. 设计设备数据类型

    struct myled_dev
{
	struct cdev mydev;
    
    unsigned long * led2con;
    unsigned long * led2dat;

    unsigned long * led3con;
    unsigned long * led3dat;
    
    unsigned long * led4con;
    unsigned long * led4dat;

    unsigned long * led5con;
    unsigned long * led5dat;
};

    b. 考虑需要支持的函数

    c. 模块入口：ioremap + 设置成输出

    d. 模块出口：iounmap

    e. 编写关灯函数和开灯函数，实现ioctl

示例：
mychar_led.h

#ifndef MYCHAR_LED_H
#define MYCHAR_LED_H


#include <asm/ioctl.h>

#define MYCHAR_LED_MAGIC 'c'

#define MYCHAR_LED_OFF _IO(MYCHAR_LED_MAGIC, 0)
#define MYCHAR_LED_ON _IO(MYCHAR_LED_MAGIC, 1)


#endif

mychar_led.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <asm/uaccess.h>
#include <asm/ioctl.h>

#include "mychar_led.h"

#define BUF_LEN 100

#define GPX1CON 0x11000C20
#define GPX1DAT 0x11000C24

#define GPX2CON 0x11000C40
#define GPX2DAT 0x11000C44

#define GPF3CON 0x114001E0
#define GPF3DAT 0x114001E4


int major = 11;					//主设备号
int minor = 0;					//次设备号
int char_num = 1;				//设备号数量

struct myled_dev 
{
	struct cdev mydev;

	/* 存放映射引脚的虚拟地址 */
	volatile unsigned long * pled2_con;
	volatile unsigned long * pled2_dat;

	volatile unsigned long * pled3_con;
	volatile unsigned long * pled3_dat;

	volatile unsigned long * pled4_con;
	volatile unsigned long * pled4_dat;

	volatile unsigned long * pled5_con;
	volatile unsigned long * pled5_dat;

};
struct myled_dev *pgmydev = NULL;

int myled_open (struct inode *pnode, struct file *pfile)//打开设备
{
	pfile->private_data = (void *) (container_of(pnode->i_cdev, struct myled_dev, mydev));
	return 0;
}

int myled_close(struct inode *pnode, struct file *pfile)//关闭设备
{
	return 0;
}

void led_on(struct myled_dev *pmydev, int ledno) {
	switch(ledno) {
		case 2:
			writel(readl(pmydev->pled2_dat) | (0x1 << 7), pmydev->pled2_dat);
			break;
		case 3:
			writel(readl(pmydev->pled3_dat) | (0x1 << 0), pmydev->pled3_dat);
			break;
		case 4:
			writel(readl(pmydev->pled4_dat) | (0x1 << 4), pmydev->pled4_dat);
			break;
		case 5:
			writel(readl(pmydev->pled5_dat) | (0x1 << 5), pmydev->pled5_dat);
			break;
	}
}

void led_off(struct myled_dev *pmydev, int ledno) {
	switch(ledno) {
		case 2:
			writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)), pmydev->pled2_dat);
			break;
		case 3:
			writel(readl(pmydev->pled3_dat) & (~(0x1 << 0)), pmydev->pled3_dat);
			break;
		case 4:
			writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)), pmydev->pled4_dat);
			break;
		case 5:
			writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)), pmydev->pled5_dat);
			break;
	}
}

long myled_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg) 
{
	struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;

	if(arg < 2 || arg > 5) {
		return -1;
	}

	switch(cmd) {
		case MYCHAR_LED_OFF:
			led_off(pmydev, arg); //关灯
			break;
		case MYCHAR_LED_ON:
			led_on(pmydev, arg); //开灯
			break;
		default:
			return -1;
	}

	return 0;
}


struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = myled_open,
	.release = myled_close,
	.unlocked_ioctl = myled_ioctl,
};

void ioremap_ledreg(struct myled_dev *pmydev) {
	
	pmydev->pled2_con = ioremap(GPX2CON, 4);
	pmydev->pled2_dat = ioremap(GPX2DAT, 4);

	pmydev->pled3_con = ioremap(GPX1CON, 4);
	pmydev->pled3_dat = ioremap(GPX1DAT, 4);

	pmydev->pled4_con = ioremap(GPF3CON, 4);
	pmydev->pled4_dat = ioremap(GPF3DAT, 4);

	pmydev->pled5_con = pmydev->pled4_con;
	pmydev->pled5_dat = pmydev->pled4_dat;

}

void set_output_ledconreg(struct myled_dev *pmydev) {

	/* 通过设置（GPX2_CON...）寄存器来将（GPX2_7...）引脚设置成输出功能 */
	writel((readl(pmydev->pled2_con) & (~(0xF << 28))) | (0x1 << 28), pmydev->pled2_con);
	writel((readl(pmydev->pled3_con) & (~(0xF << 0))) | (0x1), pmydev->pled3_con);
	writel((readl(pmydev->pled4_con) & (~(0xF << 16))) | (0x1 << 16), pmydev->pled4_con);
	writel((readl(pmydev->pled5_con) & (~(0xF << 20))) | (0x1 << 20), pmydev->pled5_con);
	
	/* 向（GPX2_DAT...）寄存器写入指定值将LED2 LED3  LED4  LED5 熄灭 */
	writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)), pmydev->pled2_dat);
	writel(readl(pmydev->pled3_dat) & (~(0x1 << 0)), pmydev->pled3_dat);
	writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)), pmydev->pled4_dat);
	writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)), pmydev->pled5_dat);
}

void iounmap_ledreg(struct myled_dev *pmydev) {

	iounmap(pmydev->pled2_con);
	pmydev->pled2_con = NULL;
	iounmap(pmydev->pled2_dat);
	pmydev->pled2_dat = NULL;

	iounmap(pmydev->pled3_con);
	pmydev->pled3_con = NULL;
	iounmap(pmydev->pled3_dat);
	pmydev->pled3_dat = NULL;
	
	iounmap(pmydev->pled4_con);
	pmydev->pled4_con = NULL;
	iounmap(pmydev->pled4_dat);
	pmydev->pled4_dat = NULL;

	pmydev->pled5_con = NULL;
	pmydev->pled5_dat = NULL;
}

int __init myled_init(void) 
{
	int ret = 0;
	dev_t devno = MKDEV(major, minor);

	/* 手动申请设备号 */
	ret = register_chrdev_region(devno, char_num, "myled");
	if (ret) {
		/* 动态申请设备号 */
		ret = alloc_chrdev_region(&devno, minor, char_num, "myled");
		if(ret){
			printk("get devno failed\n");
			return -1;
		}
		/*申请成功 更新设备号*/
		major = MAJOR(devno);
	}

	pgmydev = (struct myled_dev *)kmalloc(sizeof(struct myled_dev), GFP_KERNEL);
	if(NULL == pgmydev) {
		unregister_chrdev_region(devno, char_num);
		printk("kmalloc for 'struct myled_dev' failed\n");
		return -1;
	}

	memset(pgmydev, 0, sizeof(struct myled_dev));
	
	/* 给struct cdev对象指定操作函数集 */
	cdev_init(&pgmydev->mydev, &myops);

	/* 将struct cdev对象添加到内核对应的数据结构中 */
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev, devno, char_num);

	/* ioremap */
	ioremap_ledreg(pgmydev);

	/* con-register set output */
	set_output_ledconreg(pgmydev);

	return 0;
}

void __exit myled_exit(void) 
{

	dev_t devno = MKDEV(major, minor);
	
	/* iounmap */
	iounmap_ledreg(pgmydev);

	/* 从内核中移除一个字符设备 */
	cdev_del(&pgmydev->mydev);

	/* 回收设备号 */
	unregister_chrdev_region(devno, char_num);

	/* 释放内存 */
	kfree(pgmydev);
	pgmydev = NULL;
}

MODULE_LICENSE("GPL");
module_init(myled_init);
module_exit(myled_exit);

testled_app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>

#include "mychar_led.h"

int main(int argc, char *argv[])
{
	int fd = -1;
	int onoff = 0; 	//1 -- 开灯   0 -- 关灯
	int no = 0; 	//2 -- LED2	 3 -- LED3 ……

	if(argc < 4) {
		printf("The argument is too failed\n");
		return 1;
	}

	sscanf(argv[2], "%d", &onoff);
	sscanf(argv[3], "%d", &no);

	if(no < 2 || no > 5) {
		printf("led-no is invlide\n");
		return 2;
	}

	fd = open(argv[1], O_RDONLY);
	if(fd < 0) {
		printf("open is failed\n");
		return 3;
	}

	if(onoff) {
		ioctl(fd, MYCHAR_LED_ON, no);
	} else {
		ioctl(fd, MYCHAR_LED_OFF, no);
	}

	return 0;
}
一条飞的鱼儿
关注
Linux常用内核态内存分配方式总结
gxfan的专栏
07-28 8004
  Linux常用内核态内存分配方式总结一、             alloc_pages类此类函数主要包括：struct page * alloc_page(unsigned int gfp_mask)——分配一页物理内存并返回该页物理内存的page结构指针。struct page * alloc_pages(unsigned int gfp_mask, unsigned
香橙派LED灯内核驱动源码，包括驱动文件，makefile和上层测试app
10-03
本内容主要是基于orangepi_3_lts开发板写的一个LED灯内核驱动程序，该驱动程序主要通过写寄存器的方式来实现，暂时没有添加设备树，添加设备树的分享可以看我的下一篇分享。本次分享的内容主要包括LED灯的内部驱动...
Linux内核动态内存分配
EtherCAT
09-23 2460
在Linux中内核获取动态内存的方式相对进程是相当直接了当的。作为操作系统中优先级最高的成分，其内存请求不会被推迟，也不会插入任何针对编程错误的保护措施。其内存分配按其对象大致可分为三类：1. 连续页框；2. 专用或通用对象；3. 非连续的内存区。如果所请求的内存区得以满足，将返回一个页描述符地址或线性地址；否则，返回NULL。 第一类：连续页框【Buddy Allocator】 Buddy算
【内核内存管理、动态分配及IO访问、LED驱动】
m0_46112340的博客
03-20 797
内核将物理内存等分成N块4KB，称之为一页，每页都用一个struct page来表示，采用伙伴关系算法维护内核地址空间划分图：3G~3G+896M：低端内存，直接映射 虚拟地址 = 3G + 物理地址​ 细分为：ZONE_DMA、ZONE_NORMAL大于3G+896M：高端内存​ 细分为：vmalloc区、持久映射区、固定映射区。
lv14 内核内存管理、动态分频及IO访问 12
m0_60718520的博客
01-27 992
内核将物理内存等分成N块4KB，称之为一页，每页都用一个struct page来表示，采用伙伴关系算法维护Linux内存管理采用了虚拟内存机制，这个机制可以在内存有限的情况下提供更多可用的内存空间。当应用程序需要访问某些数据时，它会使用虚拟地址来引用这些数据。实际上，这些虚拟地址并不是直接映射到物理内存，而是由操作系统进行转换。操作系统将虚拟地址映射到物理内存中的一些页框（Page Frame），这个过程称为页表映射（Page Table Mapping）。
【嵌入式环境下linux内核及驱动学习笔记-（10-内核内存管理）】
weixin_45499326的博客
05-08 1716
对于包含MMU（内存管理单元）的处理器而言，linux系统以虚拟内存的方式为每个进程分配最大4GB的内存。这真的4GB的内存空间被分为两个部分–用户空间 与 内核空间。用户空间地地址分布为0~3GB，剩下的3 ~ 4GB 为内核空间。如下图。用户进程通常只能访问用户空间的虚拟地址，不能访问内核空间的虚拟地址。用户进程只有通过系统调用（代表用户进程在内核态执行）等方式才可以访问到内核空间。每个进程的用户空间都是独立的，互不相干，用户进程各自有不同的页表。
嵌入式（驱动开发）（内核内存管理）
afddasfa的博客
11-19 1079
内核内存管理
Linux内核内存分配方法
爱锻炼的程序员
02-09 1458
linux内核内存分配的方法 用户变量：用户空间定义的变量，地址为前3G 内核变量：内核空间定义的变量，地址为后1G1.1 kmalloc / kfree void *kmalloc(size_t size, gfp_t flags) 函数功能： 1.内核空间分配内存； 2.从内核1G的直接内存映射区中分配内存 3.物理地址和虚拟地址都是连续的(...
浅析Linux设备驱动：IO端口和IO内存
Aspiresky的专栏
02-18 1085
在计算机系统中，外部设备通常会提供一组寄存器或内存用于处理器配置和访问设备功能。这些寄存器或内存可能位于IO空间，或者内存空间。当寄存器或内存位于IO空间时，称为IO端口；当寄存器或内存位于内存空间时，称为IO内存。
Linux内核驱动—内存管理与DMA
Half-up的博客
06-06 944
Linux内核驱动—内存管理与DMA
Linux内核的GPIO子系统驱动框架详解以及基于pinctrl和gpio子系统的LED驱动程序
cumtchw
09-06 2905
上图就是gpio子系统的层次结构图，在其他的驱动程序里面，我们可以直接用gpiod_set_value这种函数来设置引脚的值，这个函数是在gpio库里面定义的，gpio库起到一个承上启下的作用，然后这个gpiod_set_value函数最终调用的是chip->set(chip, gpio_chip_hwgpio(desc), value)函数，这里的chip就是在gpio驱动程序里面注册的结构体，这个结构体体里面就包含了一些对gpio的操作函数。base // 这个GPIO控制器的GPIO编号。
LED驱动(STM32).rar_ledcode_led驱动_stm32 驱动 led_stm32 驱动led_stm32的io
09-24
LED驱动是STM32基础且重要的功能，通过微控制器的GPIO（通用输入/输出）端口控制LED亮灭，实现设备的指示或显示功能。本文将深入探讨STM32如何通过寄存器级编程来驱动LED。 首先，STM32的GPIO端口由多个引脚组成，...
基于设备树的香橙派LED灯内核驱动源码，包括驱动文件，Makefile和上层测试App
10-04
本内容主要是基于orangepi_3_lts开发板写的一个LED灯内核驱动程序，本次驱动添加了设备树修改，该驱动程序同样的，主要通过写寄存器的方式来实现。本次分享的内容主要包括LED灯的内部驱动源码，用于编译ko文件的...
led驱动&ioport&iomem
12-03
本篇将深入探讨LED驱动的三种实现方式：ioport、iomem以及内核提供的系统接口函数。 1. **ioport（I/O端口）** I/O端口是一种硬件通信机制，用于CPU与外部设备间的数据传输。在Linux内核中，ioport API提供了对I/O...
树莓派双色LED驱动
04-03
对于LED驱动，我们通常将引脚设置为高电平来点亮LED，设置为低电平使其熄灭。 双色LED通常包含两个独立的二极管，分别对应不同的颜色，如红色和绿色。在树莓派上，我们需要选择两个未使用的GPIO引脚来分别连接这两...
Linux驱动开发——设备树
一切皆是定数的博客
10-13 1337
设备树(Device Tree)，将这个词分开就是“设备”和“树”，描述设备树的文件叫做 DTS(Device Tree Source)，这个 DTS 文件采用树形结构描述板级设备，也就是开发板上的设备信息，比如CPU 数量、 内存基地址、IIC 接口上接了哪些设备、SPI 接口上接了哪些设备等等，如下图所示： 在以前的内核中，还没有采用设备树，内核源码中有大量的arch/arm/mach-xxx和arch/arm/plat-xxx文件夹，用于存储不同平台的板级信息，但随着芯片产业的发展，加入内核中的板级
Linux 命令：每日一学，一文说尽打包压缩工具实践
WeiyiGeek 唯一极客IT知识分享
10-12 701
[知识是人生的灯塔，只有不断学习，才能照亮前行的道路]文章目录：0x00 前言简述前面，我们介绍了Linux中文件查找find命令以及与之联用最勤的xargs命令，作者以一个个简单的实例给各位看友展示了在运维中两个命令的使用技巧，今天我们再来介绍一些打包、压缩解压等相关命令。在 Linux 系统中，我们经常需要使用到压缩和解压文件，使用压缩文件可以减少文件大小，从而减少存储空间，以及在网络传输...
Linux 命令：每日一学，参数传递之xargs命令实践
WeiyiGeek 唯一极客IT知识分享
10-11 879
描述：上一章，我们学习了Linux中查找搜寻文件或目录的相关命令，此章我们学习常常与find命令联合使用，以及在Shell脚本中常用的参数替换 xargs 命令进行实践学习，从而实现更加强大的参数传递和多进程并行执行Linux命令或脚本等Linux 命令：每日一学，参数传递之xargs命令实践此Linux 命令 | 系列文章将作为《#运维从业必学。
linux逻辑卷扩容增加空间
最新发布
放荡不羁爱自由
10-13 279
背景是使用vmware虚拟机安装的centos系统，在上面安装了mysql数据库为了测试千万级表模拟数据然后磁盘不够用了需要扩容。
Linux 2.6.26.6 内核LED驱动测试教程
在给出的`gpio_driver.c`部分代码中，我们可以看到包含了一系列与Linux内核交互的头文件，如`<linux/fs.h>`、`<linux/major.h>`等，这些头文件提供了访问文件系统、主设备号管理、内存分配以及与硬件交互等基本功能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值