2. 程式人生 > >linux裝置驅動之阻塞與非阻塞I/O

linux裝置驅動之阻塞與非阻塞I/O

阿新 • • 發佈：2019-01-31

先做一下與核心阻塞有關的知識儲備：

1）程序休眠：

    程序休眠，簡單的說就是正在執行的程序讓出CPU。休眠的程序會被核心擱置在在一邊，只有當核心再次把休眠的程序喚醒，程序才會會重新在CPU執行。這是核心中的程序排程。一個CPU在同一時間只能有一個程序在執行，微觀序列巨集觀並行，在巨集觀上，我們覺得是所有程序同時進行的。實際上並不是這樣，核心給每個程序分配了4G的虛擬記憶體，並且讓每個程序傻乎乎的以為自己霸佔著CPU執行。同時，核心暗中的將所有的程序按一定的演算法將CPU輪流的給每個程序使用，而休眠就是程序沒有被執行時的一種形式。在休眠下，程序不佔用CPU，等待被喚醒

2）等待佇列

   等待佇列是一個存放著等待某個特定事件程序連結串列

。用於存放等待喚醒的程序，等待佇列結構

  1.先看一下佇列頭的樣子：

 /*linux/wait.h*/

 struct __wait_queue_head {

                 spinlock_t lock; //這個是自旋鎖，在這裡不需要理會。

                 struct list_head task_list; //這就是佇列頭中的核心，連結串列頭。

 };

 typedef struct __wait_queue_head wait_queue_head_t;

 2.定義並初始化一個連結串列，在這個連結串列新增需要等待的程序    

  1）靜態定義並初始化，一個函式執行完兩個操作

  DECLARE_WAIT_QUEUE_HEAD(name)

  使用：定義並初始化一個叫name的等待佇列。

  2）分開兩步執行。

  2.1）定義

  wait_queue_head_t test_queue;

  2.2）初始化

  init_waitqueue_head(&test_queue);

初始化函式的位置，它必須在cdev新增函式”cdev_add”前。因為”cdev_add”執行成功就意味著裝置可以被操作，裝置被操作前當然需要把所有的事情都幹完，包括等待佇列的初始化。

3）程序休眠

 

  喚醒休眠程序

  void wake_up_interruptible(wait_queue_head_t *queue); //喚醒等待佇列中所有可中斷睡眠的程序

知識點已經介紹完，總結一下上面驅動函式的操作：

1）首先需要定義並初始化一個等待佇列。

2）test_read函式中，如果條件不符合，呼叫該函式的程序就會進入休眠。

3）每當另一個程序呼叫test_write函式喚醒等待佇列，test_read中的函式就會再一次判斷條件是否符合，如果不符合，就會繼續休眠，直到哪次的喚醒時條件符合。

非阻塞實現--只需要加上判定條件

     if(filp->f_flags&O_NONBLOCK)

（下面函式實現了阻塞與非阻塞）

  阻塞

#include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <asm/system.h>
#include <asm/io.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/fcntl.h>

MODULE_LICENSE("Dual BSD/GPL");

#define GLOBALMEM_SIZE 0x1000
#define MEM_CLEAR 0x1
//#define GLOBALMEM_MAJOR 250

static int globalmem_major=0;
static const struct file_operations globalmem_fops;
struct globalmem_dev{
	struct cdev cdev;
	unsigned char mem[GLOBALMEM_SIZE];
	unsigned int cur_size;
	wait_queue_head_t test_queue;
};

static struct globalmem_dev dev;

static ssize_t globalmem_read(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p=*ppos;
	int ret=0;

	if(!wait_event_interruptible(dev.test_queue,dev.cur_size)){
		if(p>=GLOBALMEM_SIZE-p)
			return 0;
			if(count>GLOBALMEM_SIZE-p)
				count=GLOBALMEM_SIZE-p;
			if(copy_to_user(buf,(void*)(dev.mem+p),count))
				return -EFAULT;
			else{
				*ppos+=count;
				ret=count;
				dev.cur_size-=ret;
				printk(KERN_INFO "read %d bytes(s) from %d\n",\
					count,p);
				return count;
				}	
		}else
			return -ERESTARTSYS;

	}
}

static ssize_t globalmem_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p=*ppos;
	int ret=0;

	if(p>=GLOBALMEM_SIZE-p)
		return 0;
	if(count>GLOBALMEM_SIZE-p)
		count=GLOBALMEM_SIZE-p;
	if(copy_from_user(dev.mem+p,buf,count))
		ret=-EFAULT;
	else{
		*ppos+=count;
		ret=count;
		printk(KERN_INFO "written %d bytes(s) from %d\n",count,p);
	}
	
	dev.cur_size+=ret;
	wake_up_interruptible(&dev.test_queue);
	return ret;	
}
static void globalmem_setup_cdev()
{
	int err;
	dev_t devno=MKDEV(globalmem_major,0);

	cdev_init(&dev.cdev,&globalmem_fops);
	dev.cdev.owner=THIS_MODULE;
	
	init_waitqueue_head(&dev.test_queue);

	err=cdev_add(&dev.cdev,devno,1);
	if(err){
		printk(KERN_NOTICE "Error %d adding globalmem",err);
	}
}

static const struct file_operations globalmem_fops={
	.owner=THIS_MODULE,
	.write=globalmem_write,
	.read=globalmem_read,
};

int globalmem_init(void)
{
	int result;
	dev_t devno=MKDEV(globalmem_major,0);

	if(globalmem_major){
		result=register_chrdev_region(devno,1,"my_globalmem");
	}else{
		result=alloc_chrdev_region(&devno,0,1,"my_globalmem");
		globalmem_major=MAJOR(devno);
	}
	if(result<0){
		return result;
	}
	
	globalmem_setup_cdev();
	return 0;
}

void globalmem_exit(void)
{
	cdev_del(&dev.cdev);
	unregister_chrdev_region(MKDEV(globalmem_major,0),1);
	printk("leavel kernel\n");
	return;
}

module_init(globalmem_init);
module_exit(globalmem_exit);
MODULE_AUTHOR("nw");

非阻塞

#include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <asm/system.h>
#include <asm/io.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/fcntl.h>

MODULE_LICENSE("Dual BSD/GPL");

#define GLOBALMEM_SIZE 0x1000
#define MEM_CLEAR 0x1
//#define GLOBALMEM_MAJOR 250

static int globalmem_major=0;
static const struct file_operations globalmem_fops;
struct globalmem_dev{
	struct cdev cdev;
	unsigned char mem[GLOBALMEM_SIZE];
	unsigned int cur_size;
	wait_queue_head_t test_queue;
};

static struct globalmem_dev dev;

static ssize_t globalmem_read(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p=*ppos;
	int ret=0;
	if(filp->f_flags&O_NONBLOCK){
		if(dev.cur_size>0){
			if(!wait_event_interruptible(dev.test_queue,dev.cur_size)){
				if(p>=GLOBALMEM_SIZE-p)
					return 0;
				if(count>GLOBALMEM_SIZE-p)
					count=GLOBALMEM_SIZE-p;
				if(copy_to_user(buf,(void*)(dev.mem+p),count))
					return -EFAULT;
				else{
					*ppos+=count;
					ret=count;
					dev.cur_size-=ret;
					printk(KERN_INFO "read %d bytes(s) from %d\n",\
						count,p);
					return count;
					}	
			}else
				return -ERESTARTSYS;
		}else
			return -EAGAIN;
	}
}

static ssize_t globalmem_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)
{
	unsigned long p=*ppos;
	int ret=0;

	if(p>=GLOBALMEM_SIZE-p)
		return 0;
	if(count>GLOBALMEM_SIZE-p)
		count=GLOBALMEM_SIZE-p;
	if(copy_from_user(dev.mem+p,buf,count))
		ret=-EFAULT;
	else{
		*ppos+=count;
		ret=count;
		printk(KERN_INFO "written %d bytes(s) from %d\n",count,p);
	}
	
	dev.cur_size+=ret;
	wake_up_interruptible(&dev.test_queue);
	return ret;	
}
static void globalmem_setup_cdev()
{
	int err;
	dev_t devno=MKDEV(globalmem_major,0);

	cdev_init(&dev.cdev,&globalmem_fops);
	dev.cdev.owner=THIS_MODULE;
	
	init_waitqueue_head(&dev.test_queue);

	err=cdev_add(&dev.cdev,devno,1);
	if(err){
		printk(KERN_NOTICE "Error %d adding globalmem",err);
	}
}

static const struct file_operations globalmem_fops={
	.owner=THIS_MODULE,
	.write=globalmem_write,
	.read=globalmem_read,
};

int globalmem_init(void)
{
	int result;
	dev_t devno=MKDEV(globalmem_major,0);

	if(globalmem_major){
		result=register_chrdev_region(devno,1,"my_globalmem");
	}else{
		result=alloc_chrdev_region(&devno,0,1,"my_globalmem");
		globalmem_major=MAJOR(devno);
	}
	if(result<0){
		return result;
	}
	
	globalmem_setup_cdev();
	return 0;
}

void globalmem_exit(void)
{
	cdev_del(&dev.cdev);
	unregister_chrdev_region(MKDEV(globalmem_major,0),1);
	printk("leavel kernel\n");
	return;
}

module_init(globalmem_init);
module_exit(globalmem_exit);
MODULE_AUTHOR("nw");

除錯app函式略

相關推薦

linux裝置驅動之阻塞與非阻塞I/O

先做一下與核心阻塞有關的知識儲備： 1）程序休眠：     程序休眠，簡單的說就是正在執行的程序讓出CPU。休眠的程序會被核心擱置在在一邊，只有當核心再次把休眠的程序喚醒，程序才會會重新在CPU執行。這是核心中的程序排程。一個CPU在同一時間只能有一個程序在執行，微觀序列巨

Linux裝置驅動中的阻塞與非阻塞I/O

阻塞和非阻塞I/O是裝置訪問的兩種不同模式，驅動程式可以靈活的支援使用者空間對裝置的這兩種訪問方式 本例子講述了這兩者的區別 並實現I/O的等待佇列機制， 並進行了使用者空間的驗證 基本概念： 1> 阻塞操作      是指 在執行裝置操作時，若不能獲得資源，則掛起程

linux裝置驅動中的阻塞與非阻塞（一）

以上是驅動中的讀取和寫入操作，當寫程序發現數據已滿，不能寫入時，且上層應用是以阻塞的方式開啟裝置檔案時，所以必須要寫入資料才能返回，否則不能返回，那麼就有兩種實現機制，要不就是不停地忙等待，等待裝置可以寫入時，便寫入，然後返回，可是這樣做的話，非常影響CPU的執行效率，大大降低了CPU的效能，所以linux核

Linux 裝置驅動中的阻塞與非阻塞I/O

何謂阻塞與非阻塞I/O？簡單來說就是對I/O操作的兩種不同的方式。 阻塞：當操作I/O裝置時，如果不能得到相應的資源，則該程序進入休眠狀態，被從排程器的佇列中移走，直到等待的條件滿足。 阻塞的讀取一個字元： char buf; fd = open("/dev/ttyS

linux裝置中的阻塞與非阻塞io

1：阻塞與非阻塞io 阻塞操作：執行裝置操作時若不能獲得資源則掛起程序（程序進入休眠狀態，將cpu資源讓給其他程序），知道滿足條件後在執行！喚醒睡眠的程序的地方最大可能發生在中斷中，因為硬體資源的獲得一般伴隨著一箇中斷。 非阻塞：程序不能進行裝置操作時並不掛起，它或者放棄，

Linux下阻塞與非阻塞，同步與非同步的關係及IO模型

一、阻塞與非阻塞，同步與非同步的關係 1、同步   同步，就是在發出一個功能呼叫時，在沒有得到結果之前，該呼叫就不返回。也就是說事情必須一件一件地做，等前一件做完了才能做下一件事。 2、非同步   非同步，就是在發出一個功能呼叫時，呼叫者不會立刻得到結果。實際處理這個呼叫的部

Linux read 阻塞與非阻塞讀取

read函式非阻塞讀取會立即返回。 阻塞讀取通過設定也可在沒有資料時立即返回 #include <termios.h> struct termios tio; tio.c_cc[VTIME] = 0; // timeout in deciseconds for noncanonical rea

簡述linux同步與非同步、阻塞與非阻塞概念以及五種IO模型

1、概念剖析 相信很多從事linux後臺開發工作的都接觸過同步&非同步、阻塞&非阻塞這樣的概念，也相信都曾經產生過誤解，比如認為同步就是阻塞、非同步就是非阻塞，下面我們先剖析下這幾個概念分別是什麼含義。 同步：所謂同步，就是在發出一個功能呼叫時，在沒有得到結果之前，該呼叫就不返回。也就是必

java NIO(三)之阻塞與非阻塞

                                                      阻塞與非阻塞阻塞   傳統的 IO 流都是阻塞式的。也就是說，當一個執行緒呼叫 read() 或 write()時，該執行緒被阻塞，直到有一些資料被讀取或寫入，該執行緒

Linux裝置驅動之button按鍵驅動學習與小結

button按鍵驅動，相對於前面的LED驅動來說。增加了中斷處理以及阻塞與非阻塞方式等新知識點。 先上學習的驅動程式碼。 核心：linux3.0 板子：fl2440 /***************************************************

iphone開發之輕鬆搞定原生socket 程式設計，阻塞與非阻塞，收發自如

iphone socket 開發 在iphone的平臺下，要進行socket開發其實有很多種的方法，開源的庫Asyncsocket，官方的CFSocket，還有BSD的socket。 這裡要做一個簡單的socket普及，這裡包含在socket的設定非阻塞喝超時的控制邏輯，

Linux下檔案的阻塞與非阻塞對部分系統呼叫的影響

1.基本概念 所謂的阻塞，即核心在對檔案操作I/O系統呼叫時，如果條件不滿足(可能需要產生I/O)，則核心會將該程序掛起。非阻塞則是發現條件不滿足就會立即返回。此外需要注意的是非阻塞並不是輪詢，不然就和阻塞沒多大區別了，它只是呼叫不成功就直接返回了，不會在去看

[Linux]阻塞與非阻塞（等待佇列、輪詢）機制

基本概念 阻塞指執行裝置操作時，不能獲得資源則掛起程序，被掛起的程序進入休眠，從排程器的進行佇列中移走。 非阻塞指在不能獲得資源的情況下，要麼放棄，要麼不停地查詢，直到可以操作。 等待佇列（Wait Queue） Linux 中採用等待佇列來實

芯靈思Sinlinx A64開發板 Linux內核等待隊列poll ---阻塞與非阻塞

打開 inux 平臺 讀取數據 判斷 函數 方式 動作 lock 開發平臺 芯靈思Sinlinx A64內存： 1GB 存儲： 4GB開發板詳細參數 https://m.tb.cn/h.3wMaSKm開發板交流群 641395230 阻塞：阻塞調用是指調用結果返回之前

Socket編程中，阻塞與非阻塞的區別

軟件 復用 優點 調用 服務器 運用 需要 默認 con 　　阻塞：一般的I/O操作可以在新建的流中運用.在服務器回應前它等待客戶端發送一個空白的行.當會話結束時,服務器關閉流和客戶端socket.如果在隊列中沒有請示將會出現什麽情況呢?那個方法將會等待一個的到來.這個行為

同步與異步、阻塞與非阻塞

阻塞與非阻塞 就會 結束 檢查 通信機制 得到 node 分布 好書 “阻塞”與"非阻塞"與"同步"與“異步"不能簡單的從字面理解，提供一個從分布式系統角度的回答。1.同步與異步同步和異步關註的是消息通信機制 (synchronous communication/ a

阻塞與非阻塞，同步與異步

通過 部件 一個 socket 沒有 事件觸發 sel syn 就會 在進行網絡編程時，我們常常見到同步(Sync)/異步(Async)，阻塞(Block)/非阻塞(Unblock)四種調用方式：同步： 所謂同步，就是在發出一個功能調用時，在沒有得到結果之前，

同步與異步，阻塞與非阻塞

消息 阻塞 結果 阻塞與非阻塞 過程調用 函數 異步 非阻塞 完成 異步的概念和同步相對。當一個同步調用發出後，調用者要一直等待返回消息（結果）通知後，才能進行後續的執行；當一個異步過程調用發出後，調用者不能立刻得到返回消息（結果）。實際處理這個調用的部件在完成後，通過狀態

關於veriolg中阻塞與非阻塞賦值問題

觸發 改變 希望 到來 決定 工作 執行 為什麽 個人 在一開始學到阻塞和非阻塞的時候，所被告知的兩者的區別就在於阻塞是串行的，非阻塞是並行的。但是雖然知道這個不同點，有些時候還是很難真正區分用兩者電路的區別，在這就通過幾個例子來解釋一下。 以一個簡單的串行流水線寄存器為例

轉：聊聊同步、異步、阻塞與非阻塞

AI strong 什麽 商業 同步與異步 好的 等待 不難 兩個 轉載：https://www.jianshu.com/p/aed6067eeac9 近來遇到了一些常見的概念，尤其是網絡編程方面的概念，如：阻塞、非阻塞、異步I/O等等，對於這些概念自己也沒有太清晰的認