Docker容器内访问宿主机硬件资源——树莓派编译GPIO驱动，通过容器控制GPIO

对边缘设备而言，在支持容器化运行的条件下，需要在容器内获取宿主机的硬件资源，完成与宿主机硬件资源的交互。通常在宿主机提供驱动的情况下，容器内需要通过SPI、I2C、UART、USB等协议完成数据的交互。

参照stackoverflow上的回答，Docker提供了三种访问硬件设备的方式：

• 使用"–privileged"选项，比如

  $ docker run --privileged -d whatever

  使用"–privileged=true"会拥有宿主机上root的权限，这对容器的权限管理而言是极度不安全的，在调试过程中使用并无问题，但在生产环境中却不太合适，所以默认情况下–privileged=false；

• 使用"–device"选项，比如

  $ docker run --device /dev/gpiomem -d whatever

  使用"–device"可以在不打开–privileged选项的情况下访问宿主机的设备，默认情况下容器拥有读，写，创建设备文件的权限，可以使用“r”，“w”，"m"来管理权限。使用这种方式可以很好地配合自己编写的设备驱动，并在容器内灵活的访问设备节点。

• 使用"–volume"选项，比如

  $ docker run -v /sys:/sys -d whatever

  挂载数据卷的方式是实现数据持久化最常用的一种方式，它可以通过“rw”，“ro”管理文件的读写权限，因为linux内核文件系统的思想，它同样可以用来访问设备节点，但在实践中访问设备时，有时可能存在访问权限或者其他问题无法在宿主机内直接控制设备节点。

下面在树莓派上编译GPIO驱动，通过–device选项来实现容器内对GPIO的控制。

1. 首先在树莓派上编译GPIO驱动

参照网上的例子，首先编写GPIO驱动代码，这里控制GPIO 18，即下图中的12引脚，可外接一个LED用于测试，LED的电源与地分别接入12与9引脚。

1.1 编写驱动代码：gpio_led.c

#include <linux/errno.h>  
#include <linux/kernel.h>  
#include <linux/module.h>  
#include <linux/slab.h>  
#include <linux/input.h>  
#include <linux/init.h>  
#include <linux/serio.h>  
#include <linux/delay.h>  
#include <linux/clk.h>  
#include <linux/miscdevice.h>  
#include <linux/gpio.h>  
#include <asm/io.h>  
#include <asm/irq.h>  
#include <asm/uaccess.h>  
#include <linux/cdev.h> 
 
#define PIN 18
#define BCM2835_GPIO_BASE           0x3f200000  
//32 32   4Bit function register
#define BCM2835_GPIOReg_GPFSEL1     0x00000004
//gpio set 1 output register 
#define BCM2835_GPIOReg_GPSET0      0x0000001c  
//gpio set 0 output register
#define BCM2835_GPIOReg_GPCLR0      0x00000028 
 
#define DEVICE_NAME     "led"  
#define LED_MAJOR       231   

#define IOCTL_LED_ON    1
#define IOCTL_LED_OFF   0

static volatile unsigned long *gpcon;
static volatile unsigned long *gpset;
static volatile unsigned long *gpclr;
 
static int pi_leds_open(struct inode *inode, struct file *file)
{
	//config your led pin function mode
	gpcon = (volatile unsigned long *)ioremap(0x3f200004,4);
	gpset = (volatile unsigned long *)ioremap(0x3f20001C,4);
	gpclr = (volatile unsigned long *)ioremap(0x3f200028,4);        

    return 0;
}

static long pi_leds_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    if (arg > 3) {
        return -EINVAL;
    }

    switch(cmd) {
    case IOCTL_LED_ON:
        // set your led 1
        *gpcon = *gpcon | (1<<24); //set pin18 to output function mode
        *gpset = *gpset | (1<<18); //set pin18 output high 
        return 0;
 
    case IOCTL_LED_OFF:
        // set your led 0
        *gpcon = *gpcon | (1<<24); //set pin18 to output function mode
        *gpclr = *gpclr | (1<<18); //set pin18 output low
        return 0;

    default:
        return -EINVAL;
    }
} 

static struct file_operations pi_leds_fops = {
    .owner  =   THIS_MODULE,    
    .open   =   pi_leds_open,     
    .unlocked_ioctl     =   pi_leds_ioctl,
};
  
static int __init pi_leds_init(void)
{
    int ret;

    ret = register_chrdev(LED_MAJOR, "led", &pi_leds_fops); 

    if (ret < 0) {
      printk("led  can't register major number\n");
      return ret;
    }

    printk("led  is  initialized  \n");
    printk("led device number is : %d  \n",ret);
    return 0;
}
  
static void __exit pi_leds_exit(void)
{    
    unregister_chrdev(LED_MAJOR, DEVICE_NAME);
    printk("led  is  goodbye\n");
}

module_init(pi_leds_init);
module_exit(pi_leds_exit);  
MODULE_LICENSE("GPL"); 

1.2 编写Makefile

KERN_DIR = /lib/modules/$(shell uname -r)/build
 
all:
	make -C $(KERN_DIR) M=`pwd` modules
 
clean:
	make -C $(KERN_DIR) M=$(shell pwd) modules clean
	rm -rf modules.order
 
obj-m := gpio_led.o

如果树莓派上没有/lib/modules/$(shell uname -r)/build目录，则需要手动下载依赖文件：

$ sudo apt-get install raspberrypi-kernel-headers

1.3 执行make，生成.ko文件

pi@raspberrypi:~ $ make
make -C /lib/modules/4.9.35-v7+/build M=`pwd` modules
make[1]: Entering directory '/usr/src/linux-headers-4.9.35-v7+'
  CC [M]  /home/pi/gpio_led.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/pi/gpio_led.mod.o
  LD [M]  /home/pi/gpio_led.ko
make[1]: Leaving directory '/usr/src/linux-headers-4.9.35-v7+'

pi@raspberrypi:~ $ ls
gpio_led.c  gpio_led.ko  gpio_led.mod.c  gpio_led.mod.o  gpio_led.o  Makefile  modules.order  Module.symvers

1.4 插入驱动模块

pi@raspberrypi:~ $ sudo insmod pi_leds.ko

1.5 创建设备节点

pi@raspberrypi:~ $ sudo mknod /dev/led c 231 0

1.6 更改权限

pi@raspberrypi:~$ sudo chmod 777 /dev/led 

2. 编写用户态代码

2.1 编写test_gpio_led.c

#include<stdio.h>  
#include<stdlib.h>  
#include<unistd.h>  
#include<fcntl.h>  
#include<sys/ioctl.h>  
  
int main(int argc, char **argv)  
{  
    int dev_fd;  
	int on;

    if (argc != 2 || sscanf(argv[1],"%d", &on) != 1 ||on < 0 || on > 1 ) {  
        fprintf(stderr, "Usage:%s 0|1\n",argv[0]);  
        exit(1);  
    }  
    
    dev_fd = open("/dev/led",O_RDWR);  
    if( dev_fd == -1){  
        printf("Cann't open file \n");  
	return 1;
    }  
     /*通过ioctl来控制灯的亮、灭*/  
    if(on){  
        printf("turn on leds!\n");  
        ioctl(dev_fd, 1);  
    }  
    else {  
        printf("turn off leds!\n");  
        ioctl(dev_fd, 0);  
    }  

    close(dev_fd);  

    return 0;  
}  

2.2 宿主机本地编译验证

pi@raspberrypi:~ $ gcc test_gpio_led.c -o test_gpio_led

GPIO高电平，控制LED灯亮：

pi@raspberrypi:~ $ ./test_gpio_led 1
turn on leds!

GPIO低电平，控制LED灯灭：

pi@raspberrypi:~ $ ./test_gpio_led 0
turn off leds!

真实设备可见LED的亮灭情况

3.容器内控制GPIO

使用–device选项，进入容器内，新建一个test_gpio_led.c并使用gcc编译并运行

pi@raspberrypi:~ $ sudo docker run -it --name test_gpio_led --device /dev/led ubuntu /bin/bash        
root@7d5f5340ecd0:/# gcc test_gpio_led.c -o test_gpio_led 
root@7d5f5340ecd0:/# ./test_gpio_led 1
turn on leds!
root@7d5f5340ecd0:/# ./test_gpio_led 0
turn off leds!

真实设备可见LED的亮灭情况