字符设备驱动第八课----信号量

概述

用于同步，犹如红绿灯，信号量为0时则阻塞，信号量大于0则往下走，可对信号量进行加减（PV操作）

1.定义：

<include/linux/semaphore.h>
struct semaphore sem;//定义信号量

2.初始化：

/*
* 功能：设置信号量sem的初始值为val
*/
void sema_init(struct semaphore *sem, int val)

3.加一（V操作）

void up(struct semaphore *sem);

4.减一(P操作)

/*先做减1操作，然后判断是否为0，为0则阻塞，不为0则往下走*/
void down(struct semaphore *sem);

/*先做减1操作，然后判断是否为0，为0则阻塞，不为0则往下走
* 可被中断
*/
down_interruptible(struct semaphore *sem);

/*先做减1操作，然后判断是否为0，不管为0不为0都返回*/
int down_trylock(struct semaphore *sem);

/*先做减1操作，然后判断是否为0，为0则阻塞，不为0则往下走，超时时间到也返回往下走
 * 返回值: 0：减成功且不阻塞    负数:超时
*/
int down_timeout(struct semaphore *sem, long jiffies);

工程实例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/errno.h>

#include <asm/current.h>
#include <linux/sched.h>

#include <linux/uaccess.h>

#include <asm/atomic.h>
#include <linux/semaphore.h>

#include <linux/delay.h>

#include <linux/device.h>
static struct class *cls = NULL;

#include "mycmd.h"

static int major = 0;
static int minor = 0;
const  int count = 6;

#define DEVNAME "demo"

static struct cdev *demop = NULL;

#define KMAX 1024
static int counter = 0;
static char kbuf[KMAX];

static atomic_t tv;
struct semaphore sem;//定义信号量

//打开设备
static int demo_open(struct inode *inode, struct file *filp)
{
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    //get major and minor from inode
    printk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",
        imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);

    if(!atomic_dec_and_test(&tv)){
        atomic_inc(&tv);
        return -EBUSY;
    }

    memset(kbuf, 0, KMAX);
    counter = 0;

    return 0;
}

//关闭设备
static int demo_release(struct inode *inode, struct file *filp)
{
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    //get major and minor from inode
    printk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",
        imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);

    atomic_inc(&tv);
    return 0;
}

//读设备
//ssize_t read(int fd, void *buf, size_t count)
static ssize_t demo_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    struct inode *inode = filp->f_path.dentry->d_inode;
    int ret;
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    //get major and minor from inode
    printk(KERN_INFO "(major=%d, minor=%dspinlock_t), %s : %s : %d\n",
        imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);

    ret = down_interruptible(&sem);//信号量减1(P操作),减1后为0则阻塞
    if(ret){
        return ret;
    }

    if(counter < size){
        size = counter;
    }

    if(copy_to_user(buf, kbuf, size)){
        return -EAGAIN;
    }

    return size;
}

//写设备
static ssize_t demo_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
    struct inode *inode = filp->f_path.dentry->d_inode;
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    //get major and minor from inode
    printk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",
        imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);

    if(size > KMAX){
        return -ENOMEM;
    }

    if(copy_from_user(kbuf, buf, size)){
        return -EAGAIN;
    }

    counter = size;

    up(&sem);   //信号量加1(v操作)

    return counter;
}

/*
 * read/write param
 * read status
 * contrl device
 */
static long demo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    static struct karg karg = {
        .kval = 0,
        .kbuf = {0},
    };
    struct karg *usrarg;

    switch(cmd){
    case CMDON:
        printk(KERN_INFO "CMDON: %s : %s : %d\n", __FILE__, __func__, __LINE__);
        break;

    case CMDOFF:
        printk(KERN_INFO "CMDOFF: %s : %s : %d\n", __FILE__, __func__, __LINE__);
        break;

    case CMDR:
        printk(KERN_INFO "CMDR: %s : %s : %d\n", __FILE__, __func__, __LINE__);
        if(_IOC_SIZE(cmd) != sizeof(karg)){
            return -EINVAL;
        }

        usrarg = (struct karg *)arg;
        if(copy_to_user(usrarg, &karg, sizeof(karg))){
            return -EAGAIN;
        }
        printk(KERN_INFO "CMDR: %s : %s : %d ---done.\n", __FILE__, __func__, __LINE__);
        break;

    case CMDW:
        printk(KERN_INFO "CMDW: %s : %s : %d\n", __FILE__, __func__, __LINE__);
        if(_IOC_SIZE(cmd) != sizeof(karg)){
            return -EINVAL;
        }

        usrarg = (struct karg *)arg;
        if(copy_from_user(&karg, usrarg, sizeof(karg))){
            return -EAGAIN;
        }

        printk(KERN_INFO "CMDW: %d : %s\n", karg.kval, karg.kbuf);
        break;

    default:
        ;
    };


    return 0;
}

static struct file_operations fops = {
    .owner  = THIS_MODULE,
    .open   = demo_open,
    .release= demo_release,
    .read   = demo_read,
    .write  = demo_write,
    .unlocked_ioctl = demo_ioctl,
};

static int __init demo_init(void)
{
    dev_t devnum;
    int ret, i;

    struct device *devp = NULL;

    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);

    //1. alloc cdev obj
    demop = cdev_alloc();
    if(NULL == demop){
        return -ENOMEM;
    }

    //2. init cdev obj
    cdev_init(demop, &fops);

    ret = alloc_chrdev_region(&devnum, minor, count, DEVNAME);
    if(ret){
        goto ERR_STEP;
    }
    major = MAJOR(devnum);

    //3. register cdev obj
    ret = cdev_add(demop, devnum, count);
    if(ret){
        goto ERR_STEP1;
    }

    cls = class_create(THIS_MODULE, DEVNAME);
    if(IS_ERR(cls)){
        ret = PTR_ERR(cls);
        goto ERR_STEP1;
    }

    for(i = minor; i < (count+minor); i++){
        devp = device_create(cls, NULL, MKDEV(major, i), NULL, "%s%d", DEVNAME, i);
        if(IS_ERR(devp)){
            ret = PTR_ERR(devp);
            goto ERR_STEP2;
        }
    }

    // init atomic_t
    atomic_set(&tv, 1);

    // init sem
    sema_init(&sem, 0); //初始化信号量

    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d - ok.\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    return 0;

ERR_STEP2:
    for(--i; i >= minor; i--){
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);

ERR_STEP1:
    unregister_chrdev_region(devnum, count);

ERR_STEP:
    cdev_del(demop);

    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d - fail.\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);
    return ret;
}

static void __exit demo_exit(void)
{
    int i;
    //get command and pid
    printk(KERN_INFO "(%s:pid=%d), %s : %s : %d - leave.\n",
        current->comm, current->pid, __FILE__, __func__, __LINE__);

    for(i=minor; i < (count+minor); i++){
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);

    unregister_chrdev_region(MKDEV(major, minor), count);

    cdev_del(demop);
}

module_init(demo_init);
module_exit(demo_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Farsight");
MODULE_DESCRIPTION("Demo for kernel module");