如何在內核打開設備節點

『壹』 在linux上，如何知道/dev下的設備節點被哪個程序打開如：/dev/ttyS0是被哪個程序所使用。有哪些命令

設備節點代表是每個機算機硬體，那個軟體要用那個硬體，它就會打開那設備節點嘛。。。
/dev/ttyS0這個是串口0 也就是windows 裡面的com1 ，只有要用到串口0的程序才會打開這個設備節點。

個人愚見，僅供參考，望及時採納，祝你愉快。。。

『貳』 ubuntu中如何找到最新增加的設備節點

將自己開發的內核代碼加入到Linux內核中，需要3個步驟：
1、確定把自己開發代碼放入到內核合適的位置
將demo_chardev.c文件拷貝到.../drivers/char/目錄下。
demo_chardev.c
[cpp] view plain
#include <linux/init.h>
#include <linux/mole.h>
#include <linux/kernel.h>
/*結構體file_operations定義的頭文件*/
#include <linux/fs.h>
/*聲明_to/from_user函數的頭文件*/
#include <linux/uaccess.h>
/*聲明class_create 和device_create相關信息*/
#include <linux/device.h>

#define DEMO_DEBUG
#ifdef DEMO_DEBUG
#define dem_dbg(fmt, arg...) printk(KERN_WARNING fmt, ##arg)
#else
#define dem_dbg(fmt, arg...) printk(KERN_DEBUG fmt, ##arg)
#endif

#define DEVICE_COUNT 2

/*記錄當前驅動所佔用的主設備號*/
static int major = 0;

static int demo_open (struct inode *pnode, struct file *filp)
{
dem_dbg("[kern func]: %s major: %d minor: %d\n",
__FUNCTION__, imajor(pnode), iminor(pnode));
return 0;
}
static ssize_t demo_read (struct file *filp, char __user *buf, size_t count, loff_t *offp)
{
unsigned char ary[100] = "you are reading successfully!";
unsigned long len = min(count, sizeof(ary)); //min是個宏，用來獲取兩個數中較小的值
int retval;

dem_dbg("[kern func]: %s major: %d minor: %d\n",
__FUNCTION__, imajor(filp->f_dentry->d_inode),
iminor(filp->f_dentry->d_inode));

//file結構體的f_flags成員可用來判斷是否阻塞讀取，然後進行相應處理

if(_to_user(buf, ary, len) != 0){
retval = -EFAULT;
goto cp_err;
}

return len; //成功返回實際傳輸的位元組數
cp_err:
return retval;
}

static ssize_t demo_write(struct file *filp, const char __user *buf, size_t count, loff_t *offp)
{
unsigned char ary[100] = "";
unsigned long len = min(count, sizeof(ary)); //min是個宏，用來獲取兩個數中較小的值
int retval;

dem_dbg("[kern func]: %s major: %d minor: %d\n",
__FUNCTION__, imajor(filp->f_dentry->d_inode),
iminor(filp->f_dentry->d_inode));

if(_from_user(ary, buf, len) != 0){
retval = -EFAULT;
goto cp_err;
}
printk("[msg]: writing context: %s\n",ary);
return len; //成功返回實際傳輸的位元組數
cp_err:
return retval;
}
static int demo_release (struct inode *pnode, struct file *filp)
{
dem_dbg("[kern func]: %s major: %d minor: %d\n",
__FUNCTION__, imajor(pnode), iminor(pnode));
return 0;
}

/*@定義file_operations結構體變數*/
static struct file_operations fops = {
.owner = THIS_MODULE,
.read = demo_read,
.write = demo_write,
.open = demo_open,
.release = demo_release,
};

static struct class *demo_class;
static int __init drvdemo_init(void)
{
struct device *demo_device;
int i;
int retval;

dem_dbg("[msg]:this is a driver demo, in mole initial function\n");
/*注冊字元驅動函數，成功 返回動態分配好的主設備號，失敗
*返回錯誤碼(負值)*/
major = register_chrdev(0, "demo_chrdev", &fops);
if(major < 0){
retval = major;
goto chrdev_err;
}

/*創建設備類*/
demo_class = class_create(THIS_MODULE,"demo_class");
if(IS_ERR(demo_class)){
retval = PTR_ERR(demo_class);
goto class_err;
}

/*創建設備文件，通知用戶在「/dev/」目錄下創件名字為demoX的設備文件*/
for(i=0; i<DEVICE_COUNT; i++){ //最多可創建255個設備節點(register_chrdev函數會申請0-254范圍的從設備號)
demo_device = device_create(demo_class,NULL, MKDEV(major, i), NULL,"demo%d",i);
if(IS_ERR(demo_device)){
retval = PTR_ERR(demo_device);
goto device_err;
}
}
return 0;
device_err:
while(i--) //設備節點創建的回滾操作 device_destroy(demo_class,MKDEV(major, i));
class_destroy(demo_class); //刪除設備類
class_err:
unregister_chrdev(major, "demo_chrdev");
chrdev_err:
return retval;
}
static void __exit drvdemo_exit(void)
{
int i;

dem_dbg("[msg]:in mole exit function\n");
/*注銷字元驅動函數，無返回值，major為已分配的主設備號*/
unregister_chrdev(major, "demo_chrdev");
/*刪除設備節點和設備類*/
for(i=0; i<DEVICE_COUNT; i++)
device_destroy(demo_class,MKDEV(major, i));
class_destroy(demo_class);
}

mole_init(drvdemo_init);
mole_exit(drvdemo_exit);

MODULE_LICENSE("Dual BSD/GPL"); //BSD/GPL雙重許可證
MODULE_AUTHOR("hanbo"); //模塊作者(可選)
MODULE_DESCRIPTION("used for studing linux drivers"); //模塊兒簡介(可選)
2、把自己開發的功能增加到Linux內核的配置選項中，使用戶能夠選擇此功能
vi drivers/char/Konfig 在文件結尾，endmenu的前面加入一個config選項
[cpp] view plain
config DEMO_CHARDEV

bool "demo_chardev driver for hanbo chardev boards"

default y

help

this is CHARDEV driver for hanbo chardev boards.
3、構建或修改Makefile，根據用戶的選擇，將相應的代碼編譯到最終生成的Linux內核中去
make menuconfig（添加配置選項）（如果提示找不到「ncurses」庫則執行命令： sudo apt-get install libncurses5-dev ）
Device driver -->
character devices ->
[*] demo_chardev driver for hanbo chardev boards
4、vi drivers/char/Makefile 添加內容如下：
..........
obj-$(CONFIG_DEMO_CHARDEV) +=demo_chardev.o （添加）
obj-$(CONFIG_JS_RTC) +=js-rtc.o（自帶）
js-rtc-y = rtc.o （自帶）
5、make （更新內核鏡像到開發板）
6、交叉編譯測試程序，放到開發板運行
arm-linux-gcc-gcc test.c -o demo
test.c
[cpp] view plain
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <fcntl.h>

#include <string.h>

int main(int argc, char *argv[])
{
int fd1 = 0, fd2 = 0;
unsigned char buf1[100] = "I am a test program!";
unsigned char buf2[100] = {0};
int retval;

//以讀寫、不阻塞方式打開設備文件
fd1 = open("/dev/demo0", O_RDWR | O_NONBLOCK);
if(fd1 < 0){
perror("open /dev/demo1");
goto out;
}
//以只讀、阻塞方式打開設備文件
fd2 = open("/dev/demo1", O_RDONLY);
if(fd2 < 0){
perror("open /dev/demo2");
goto out;
}

//成功返回實際寫入位元組數，失敗返回負值
retval = write(fd1, buf1, strlen(buf1)+1);
if(retval < 0){
perror("writing fd1 failed!");
goto out;
}
printf("<user space>: write bytes: %d write content: %s\n", retval, buf1);

//成功返回實際讀取位元組數，失敗返回負值
retval = read(fd2, buf2, sizeof(buf2));
if(retval < 0){
perror("reading fd2 failed!");
goto out;
}
printf("<user space>: read bytes: %d read content: %s\n", retval, buf2);

return 0;
out:
if(fd1 > 0)
close(fd1);
if(fd2 > 0)
close(fd2);
return -1;
}
二、手動載入驅動 .ko文件
1、上面的demo_chardev.c文件放到內核下編譯生成 .ko文件
Makefile
[cpp] view plain
#如果已定義KERNELRELEASE，說明是由內核構造系統調用的
#可以利用內建語句
ifneq ($(KERNELRELEASE),)
obj-m +=demo_chrdev.o
#此時由內核構造系統調用
else
#定義並記錄內核源碼路徑
KERNELDIR = /home/hanbo/linux-2.6.35.7（自己源碼路徑，2.6.35.7指當前內核版本）
#記錄當前工程目錄
PWD := $(shell pwd)

default:
$(MAKE) -C $(KERNELDIR) M=$(PWD) moles
@rm -rf *.o .t* .m* .*.cmd *.mod.c *.order *.symvers

endif

clean:
rm -rf *.ko *.o .t* .m* .*.cmd *.mod.c *.order *.symvers
2、 然後用命令載入 .ko 驅動
lsmod 列舉當前系統中的所有模塊
lsmod 列舉當前系統中的所有模塊
rmmod xxx 卸載指定模塊(不需要.ko後綴)
3、如果自己編譯的代碼中沒有用
/*創建設備類*/
demo_class = class_create(THIS_MODULE,"demo_class");
/*創建設備文件，通知用戶在「/dev/」目錄下創件名字為demoX的設備文件*/
demo_device = device_create(demo_class,NULL, MKDEV(major, i), NULL,"demo%d",i);
則需要手動添加設備節點
mknod /dev/demo1 c 主設備號 0
mknod /dev/demo2 c 主設備號 1
注意：若卸載時出現提示 rmmod：chdir（2.6.35.7）：No such file or directory
則在開發板根文件系統下創建目錄：/lib/moles/2.6.35.7（跟當前內核版本同名）

『叄』 驅動編入內核我沒有使用mknod，是怎麼生成設備節點的呢

mknod 是創建設備節點命令 insmod 是載入內核模塊的命令 mount 是掛載命令 編譯後的內核模塊xxxxx.ko 使用insmod載入，然後再/dev 下創建設備節點或者叫設備文件（使用的命令就是mknod）。 mount掛載用的和上面2個沒啥聯系、 cat/proc/devices ...

『肆』 Android 5.0 SEAndroid下怎麼獲得對一個內核節點的訪問許可權

第一步：找到需要訪問該內核節點的進程（process），這個節點由system_server進程來訪問
第二步：打開文件AndroidL/android/external/sepolicy/file_contexts.be
仿照這個文件里的寫法，為這個定義一個自己想要的名字：
/dev/tegra.* u:object_r:video_device:s0
/dev/tf_driver u:object_r:tee_device:s0
/dev/tty u:object_r:owntty_device:s0
/dev/tty[0-9]* u:object_r:tty_device:s0
/dev/ttyS[0-9]* u:object_r:serial_device:s0
/dev/wf_bt u:object_r: wf_bt_device:s0
wf_bt_device是自定義，其他左右兩邊的內容都和上面的範例一致。
第三步：打開文件AndroidL/android/external/sepolicy/device.te
仿照這個文件里的寫法，將剛剛第二步寫的wf_bt_device聲明為dev_type：
# Device types
type device, dev_type, fs_type;
type alarm_device, dev_type, mlstrustedobject;
type adb_device, dev_type;
type ashmem_device, dev_type, mlstrustedobject;
type audio_device, dev_type;
type binder_device, dev_type, mlstrustedobject;
type block_device, dev_type;
type camera_device, dev_type;
type wf_bt_device, dev_type;

第四步：
AndroidL/android/external/sepolicy/目錄下很多.te文件都是以進程名來結尾的，比如有針對surfaceflinger進程的surfaceflinger，有針對vold進程的vold.te，
剛剛從第一步得到，這個節點是由system_server進程來訪問，所以，咱們找到system_server.te打開，加入允許這個進程對/dev/wf_bt的讀寫許可權，
# Read/Write to /proc/net/xt_qtaguid/ctrl and and /dev/xt_qtaguid.
allow system_server qtaguid_proc:file rw_file_perms;
allow system_server qtaguid_device:chr_file rw_file_perms;
# chr_file表示字元設備文件，如果是普通文件用file，目錄請用dir
# rw_file_perms代表讀寫許可權
allow system_server wf_bt_device:chr_file rw_file_perms;
這句話的意思是：允許system_server進程擁有對wf_bt_device的這個字元設備的讀寫許可權。
改了這些之後，就可以make installclean;make -j16編譯image來驗證許可權是否獲取成功。
fd =open("/dev/wf_bt",O_RDONLY | O_NOCTTY);

『伍』 什麼是節點在linux內核中如何實現的

i節點是一個64位元組長的表，存儲著一個文件的元數據，包括文件大小、文件所有者、文件存取許可方式，以及文件類型，磁碟地址表。
struct inode {
struct hlist_node i_hash;
struct list_head i_list; /* backing dev IO list */
struct list_head i_sb_list;
struct list_head i_dentry;
unsigned long i_ino;
atomic_t i_count;
unsigned int i_nlink;
uid_t i_uid;
gid_t i_gid;
dev_t i_rdev;
unsigned int i_blkbits;
u64 i_version;
loff_t i_size;
#ifdef __NEED_I_SIZE_ORDERED
seqcount_t i_size_seqcount;
#endif
struct timespec i_atime;
struct timespec i_mtime;
struct timespec i_ctime;
blkcnt_t i_blocks;
unsigned short i_bytes;
umode_t i_mode;
spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
struct mutex i_mutex;
struct rw_semaphore i_alloc_sem;
const struct inode_operations *i_op;
const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
struct super_block *i_sb;
struct file_lock *i_flock;
struct address_space *i_mapping;
struct address_space i_data;
#ifdef CONFIG_QUOTA
struct dquot *i_dquot[MAXQUOTAS];
#endif
struct list_head i_devices;
union {
struct pipe_inode_info *i_pipe;
struct block_device *i_bdev;
struct cdev *i_cdev;
};

__u32 i_generation;

#ifdef CONFIG_FSNOTIFY
__u32 i_fsnotify_mask; /* all events this inode cares about */
struct hlist_head i_fsnotify_marks;
#endif

unsigned long i_state;
unsigned long dirtied_when; /* jiffies of first dirtying */

unsigned int i_flags;

atomic_t i_writecount;
#ifdef CONFIG_SECURITY
void *i_security;
#endif
#ifdef CONFIG_FS_POSIX_ACL
struct posix_acl *i_acl;
struct posix_acl *i_default_acl;
#endif
void *i_private; /* fs or device private pointer */
};

『陸』 如何查看內核 device tree

你好，查看方法如下：
在內核初始化的時候，dtb被轉換成device_node的樹狀結構，以便後續操作。具體的代碼流程如下：
start_kernel->setup_arch->unflatten_device_tree
void __init unflatten_device_tree(void)
{
__unflatten_device_tree(initial_boot_params, &of_allnodes,
early_init_dt_alloc_memory_arch);

/* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
of_alias_scan(early_init_dt_alloc_memory_arch);
}12345678

將dtb展開，並將其組成成一個樹狀結構，主要功能在__unflatten_device_tree函數中實現，具體代碼如下：
static void __unflatten_device_tree(struct boot_param_header *blob, //dtb在內存中的虛擬地址
struct device_node **mynodes, //一個全局的指針，後續可以通過這個指針變數dtb所有的節點
void * (*dt_alloc)(u64 size, u64 align)) //內存分配回調函數
{
unsigned long size;
void *start, *mem;
struct device_node **allnextp = mynodes;

if (!blob) {
pr_debug("No device tree pointer\n");
return;
}
...
if (be32_to_cpu(blob->magic) != OF_DT_HEADER) {
pr_err("Invalid device tree blob header\n");
return;
}

/* First pass, scan for size */
start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
size = (unsigned long)unflatten_dt_node(blob, 0, &start, NULL, NULL, 0);
size = ALIGN(size, 4);

pr_debug(" size is %lx, allocating...\n", size);

/* Allocate memory for the expanded device tree */
mem = dt_alloc(size + 4, __alignof__(struct device_node));
memset(mem, 0, size);

*(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);

pr_debug(" unflattening %p...\n", mem);

/* Second pass, do actual unflattening */
start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
unflatten_dt_node(blob, mem, &start, NULL, &allnextp, 0); //重點在這里
if (be32_to_cpup(start) != OF_DT_END)
pr_warning("Weird tag at end of tree: %08x\n", be32_to_cpup(start));
if (be32_to_cpup(mem + size) != 0xdeadbeef)
pr_warning("End of tree marker overwritten: %08x\n",
be32_to_cpup(mem + size));
*allnextp = NULL;

pr_debug(" <- unflatten_device_tree()\n");
}
0414243444546

unflatten_dt_node函數真正完成了解析dtb的任務，首先找到dtb的根節點，並創建一個struct device_node ，然後把這個根節點對應的struct device_node 賦值給all_nodes全局變數。再通過遞歸的方法遍歷根節點下面的子節點，最終創建一個樹結構。
unflatten_dt_node具體代碼如下：
static void * unflatten_dt_node(struct boot_param_header *blob,
void *mem,
void **p,
struct device_node *dad,
struct device_node ***allnextpp,
unsigned long fpsize)
{
struct device_node *np;
struct property *pp, **prev_pp = NULL;
char *pathp;
u32 tag;
unsigned int l, allocl;
int has_name = 0;
int new_format = 0;

tag = be32_to_cpup(*p);
if (tag != OF_DT_BEGIN_NODE) {
pr_err("Weird tag at start of node: %x\n", tag);
return mem;
}
*p += 4;
pathp = *p;
l = allocl = strlen(pathp) + 1;
*p = PTR_ALIGN(*p + l, 4);

/* version 0x10 has a more compact unit name here instead of the full
* path. we accumulate the full path size using "fpsize", we'll rebuild
* it later. We detect this because the first character of the name is
* not '/'.
*/
if ((*pathp) != '/') {
new_format = 1;
if (fpsize == 0) {
/* root node: special case. fpsize accounts for path
* plus terminating zero. root node only has '/', so
* fpsize should be 2, but we want to avoid the first
* level nodes to have two '/' so we use fpsize 1 here
*/
fpsize = 1;
allocl = 2;
l = 1;
*pathp = '\0';
} else {
/* account for '/' and path size minus terminal 0
* already in 'l'
*/
fpsize += l;
allocl = fpsize;
}
}

np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
__alignof__(struct device_node));
if (allnextpp) {
char *fn;
np->full_name = fn = ((char *)np) + sizeof(*np);
if (new_format) {
/* rebuild full path for new format */
if (dad && dad->parent) {
strcpy(fn, dad->full_name);
#ifdef DEBUG
if ((strlen(fn) + l + 1) != allocl) {
pr_debug("%s: p: %d, l: %d, a: %d\n",
pathp, (int)strlen(fn),
l, allocl);
}
#endif
fn += strlen(fn);
}
*(fn++) = '/';
}
memcpy(fn, pathp, l);

prev_pp = &np->properties;
**allnextpp = np;
*allnextpp = &np->allnext;
if (dad != NULL) {
np->parent = dad;
/* we temporarily use the next field as `last_child'*/
if (dad->next == NULL)
dad->child = np;
else
dad->next->sibling = np;
dad->next = np;
}
kref_init(&np->kref);
}
/* process properties */
while (1) {
u32 sz, noff;
char *pname;

tag = be32_to_cpup(*p);
if (tag == OF_DT_NOP) {
*p += 4;
continue;
}
if (tag != OF_DT_PROP)
break;
*p += 4;
sz = be32_to_cpup(*p);
noff = be32_to_cpup(*p + 4);
*p += 8;
if (be32_to_cpu(blob->version) < 0x10)
*p = PTR_ALIGN(*p, sz >= 8 ? 8 : 4);

pname = of_fdt_get_string(blob, noff);
if (pname == NULL) {
pr_info("Can't find property name in list !\n");
break;
}
if (strcmp(pname, "name") == 0)
has_name = 1;
l = strlen(pname) + 1;
pp = unflatten_dt_alloc(&mem, sizeof(struct property),
__alignof__(struct property));
if (allnextpp) {
/* We accept flattened tree phandles either in
* ePAPR-style "phandle" properties, or the
* legacy "linux,phandle" properties. If both
* appear and have different values, things
* will get weird. Don't do that. */
if ((strcmp(pname, "phandle") == 0) ||
(strcmp(pname, "linux,phandle") == 0)) {
if (np->phandle == 0)
np->phandle = be32_to_cpup((__be32*)*p);
}
/* And we process the "ibm,phandle" property
* used in pSeries dynamic device tree
* stuff */
if (strcmp(pname, "ibm,phandle") == 0)
np->phandle = be32_to_cpup((__be32 *)*p);
pp->name = pname;
pp->length = sz;
pp->value = *p;
*prev_pp = pp;
prev_pp = &pp->next;
}
*p = PTR_ALIGN((*p) + sz, 4);
}
/* with version 0x10 we may not have the name property, recreate
* it here from the unit name if absent
*/
if (!has_name) {
char *p1 = pathp, *ps = pathp, *pa = NULL;
int sz;

while (*p1) {
if ((*p1) == '@')
pa = p1;
if ((*p1) == '/')
ps = p1 + 1;
p1++;
}
if (pa < ps)
pa = p1;
sz = (pa - ps) + 1;
pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
__alignof__(struct property));
if (allnextpp) {
pp->name = "name";
pp->length = sz;
pp->value = pp + 1;
*prev_pp = pp;
prev_pp = &pp->next;
memcpy(pp->value, ps, sz - 1);
((char *)pp->value)[sz - 1] = 0;
pr_debug("fixed up name for %s -> %s\n", pathp,
(char *)pp->value);
}
}
if (allnextpp) {
*prev_pp = NULL;
np->name = of_get_property(np, "name", NULL);
np->type = of_get_property(np, "device_type", NULL);

if (!np->name)
np->name = "<NULL>";
if (!np->type)
np->type = "<NULL>";
}
while (tag == OF_DT_BEGIN_NODE || tag == OF_DT_NOP) {
if (tag == OF_DT_NOP)
*p += 4;
else
mem = unflatten_dt_node(blob, mem, p, np, allnextpp,
fpsize);
tag = be32_to_cpup(*p);
}
if (tag != OF_DT_END_NODE) {
pr_err("Weird tag at end of node: %x\n", tag);
return mem;
}
*p += 4;
return mem;
}

『柒』 如何在udev自動創建設備節點

創建設備文件的方法：
第一種是使用mknod手工創建：mknod filename type major minor
第二種是自動創建設備節點：利用udev（mdev）來實現設備文件的自動創建，首先應保證支持udev（嵌入式系統用mdev），由busybox配置。
udev介紹
udev 運行在用戶模式，而非內核中。udev 的初始化腳本在系統啟動時創建設備節點，並且當插入新設備——加入驅動模塊——在sysfs上注冊新的數據後，udev會創新新的設備節點。
udev 是一個工作在用戶空間的工具，它能根據系統中硬體設備的狀態動態的更新設備文件，包括設備文件的創建，刪除，許可權等。這些文件通常都定義在/dev 目錄下，但也可以在配置文件中指定。udev 必須內核中的sysfs和tmpfs支持，sysfs 為udev 提供設備入口和uevent 通道，tmpfs 為udev 設備文件提供存放空間。
注意，udev 是通過對內核產生的設備文件修改，或增加別名的方式來達到自定義設備文件的目的。但是，udev 是用戶模式程序，其不會更改內核行為。也就是說，內核仍然會創建sda，sdb等設備文件，而udev可根據設備的唯一信息來區分不同的設備，並產生新的設備文件（或鏈接）。而在用戶的應用中，只要使用新產生的設備文件

『捌』 在linux中是不是能看到設備節點就說明設備可以被訪問了解決思路

Linux 中的設備有2種類型：字元設備(無緩沖且只能順序存取)、塊設備(有緩沖且可以隨機存取)。每個字元設備和塊設備都必須有主、次設備號，主設備號相同的設備是同類設備(使用同一個驅動程序)。這些設備中，有些設備是對實際存在的物理硬體的抽象，而有些設備則是內核自身提供的功能(不依賴於特定的物理硬體，又稱為"虛擬設備")。每個設備在 /dev 目錄下都有一個對應的文件(節點)。可以通過 cat /proc/devices 命令查看當前已經載入的設備驅動程序的主設備號。內核能夠識別的所有設備都記錄在原碼樹下的 Documentation/devices.txt 文件中。在 /dev 目錄下除了字元設備和塊設備節點之外還通常還會存在：FIFO管道、Socket、軟/硬連接、目錄。這些東西沒有主/次設備號。
了解這些設備的最基本要求就是對 每個設備文件的含義了如指掌，下面就醫列表的形式列出常見的設備文件以及相應的含義(比較偏僻的就省略了)：
----------------------------------------------------------------------
主設備號 設備類型
次設備號=文件名 簡要說明
----------------------------------------------------------------------
0 未命名設備(例如：掛載的非設備)
0 = 未空設備號保留
1 char 內存設備
1 = /dev/mem 直接存取物理內存
2 = /dev/kmem 存取經過內核虛擬之後的內存
3 = /dev/null 空設備。任何寫入都將被直接丟棄，任何讀取都將得到EOF。
4 = /dev/port 存取 I/O 埠
5 = /dev/zero 零位元組源，只能讀取到無限多的零位元組。
7 = /dev/full 滿設備。任何寫入都將失敗，並把errno設為ENOSPC以表示沒有剩餘空間。
8 = /dev/random 隨機數發生器。完全由用戶的輸入來產生隨機數。
如果用戶停止所有動作，則停止產生新的隨機數。
9 = /dev/urandom 更快，但是不夠安全的隨機數發生器。盡可能由用戶的輸入來產生隨機數，
如果用戶停止所有動作，則把已經產生的隨機數做為種子來產生新的隨機數。
10 = /dev/aio 非同步 I/O 通知介面
11 = /dev/kmsg 任何對該文件的寫入都將作為 printk 的輸出

1 block RAM disk
0 = /dev/ram0 第1個 RAM disk (initrd只能使用ram0)
1 = /dev/ram1 第2個 RAM disk
...
200 = /dev/ram200 第200個 RAM disk

4 char TTY(終端)設備
0 = /dev/tty0 當前虛擬控制台
1 = /dev/tty1 第1個虛擬控制台
...
63 = /dev/tty63 第63個虛擬控制台

4 block 如果根文件系統以是以只讀方式掛載的，那麼就不可能創建真正的設備節點，
此時就使用該設備作為動態分配的主(major)設備的別名
0 = /dev/root

5 char 其他 TTY 設備
0 = /dev/tty 當前 TTY 設備
1 = /dev/console 系統控制台
2 = /dev/ptmx 所有 PTY master 的復用器

7 char 虛擬控制台捕捉設備(這些設備既允許讀也允許寫)
0 = /dev/vcs 當前虛擬控制台(vc)的文本內容
1 = /dev/vcs1 tty1 的文本內容
...
63 = /dev/vcs63 tty63 的文本內容
128 = /dev/vcsa 當前虛擬控制台(vc)的文本/屬性內容
129 = /dev/vcsa1 tty1 的文本/屬性內容
...
191 = /dev/vcsa63 tty63 的文本/屬性內容
7 block 回環設備(用一個普通的磁碟文件來模擬一個塊設備)
對回環設備的綁定由 mount(8) 或 losetup(8) 處理
0 = /dev/loop0 第1個回環設備
1 = /dev/loop1 第2個回環設備
...

8 block SCSI 磁碟(0-15)
0 = /dev/sda 第1個 SCSI 磁碟(整個磁碟)
16 = /dev/sdb 第2個 SCSI 磁碟(整個磁碟)
32 = /dev/sdc 第3個 SCSI 磁碟(整個磁碟)
...
240 = /dev/sdp 第16個 SCSI 磁碟(整個磁碟)
分區表示方法如下(以第3個 SCSI 磁碟為例)
33 = /dev/sdc1 第1個分區
34 = /dev/sdc2 第2個分區
...
47 = /dev/sdc15 第15個分區
對於Linux/i386來說，分區1-4是主分區，5-15是邏輯分區。

9 block Metadisk(RAID)設備
0 = /dev/md0 第1組 metadisk
1 = /dev/md1 第2組 metadisk
...
metadisk 驅動用於將同一個文件系統分割到多個物理磁碟上。

10 char 非串口滑鼠，各種雜項設備和特性
1 = /dev/psaux PS/2滑鼠
131 = /dev/temperature 機器內部溫度
134 = /dev/apm_bios APM(高級電源管理) BIOS
135 = /dev/rtc 實時時鍾(Real Time Clock)
144 = /dev/nvram 非易失配置 RAM
162 = /dev/smbus 系統管理匯流排(System Management Bus)
164 = /dev/ipmo Intel的智能平台管理(Intelligent Platform Management)介面
173 = /dev/ipmikcs 智能平台管理(Intelligent Platform Management)介面
175 = /dev/agpgart AGP圖形地址重映射表(Graphics Address Remapping Table)
182 = /dev/perfctr 性能監視計數器
183 = /dev/hwrng 通用硬體隨機數發生器
184 = /dev/cpu/microcode CPU微代碼更新介面
186 = /dev/atomicps 進程狀態數據的原子快照
188 = /dev/smbusbios SMBus(系統管理匯流排) BIOS
200 = /dev/net/tun TAP/TUN 網路設備(TAP/TUN以軟體的方式實現了網路設備)
TAP模擬了乙太網幀(第二層)，TUN模擬了IP包(第三層)。
202 = /dev/emd/ctl 增強型 Metadisk RAID (EMD) 控制器
220 = /dev/mptctl Message passing technology (MPT) control
223 = /dev/input/uinput 用戶層輸入設備驅動支持
227 = /dev/mcelog X86_64 Machine Check Exception driver
228 = /dev/hpet HPET driver
229 = /dev/fuse Fuse(用戶空間的虛擬文件系統)
231 = /dev/snapshot 系統內存快照
232 = /dev/kvm 基於內核的虛構機(基於AMD SVM和Intel VT硬體虛擬技術)

11 block SCSI CD-ROM 設備
0 = /dev/scd0 第1個 SCSI CD-ROM
1 = /dev/scd1 第2個 SCSI CD-ROM
...
13 char 核心輸入設備
32 = /dev/input/mouse0 第1個滑鼠
33 = /dev/input/mouse1 第2個滑鼠
...
62 = /dev/input/mouse30 第31個滑鼠
63 = /dev/input/mice 所有滑鼠的統一
64 = /dev/input/event0 第1個事件隊列
65 = /dev/input/event1 第2個事件隊列
...
95 = /dev/input/event1 第32個事件隊列

21 char 通用 SCSI 設備(通常是SCSI光碟機)
0 = /dev/sg0 第1個通用 SCSI 設備
1 = /dev/sg1 第2個通用 SCSI 設備
...

29 char 通用幀緩沖(frame buffer)設備
0 = /dev/fb0 第1個幀緩沖設備
1 = /dev/fb1 第2個幀緩沖設備
...
31 = /dev/fb31 第32個幀緩沖設備

30 char iBCS-2 兼容設備
0 = /dev/socksys 套接字訪問介面
1 = /dev/spx SVR3 本地 X 介面
32 = /dev/inet/ip 網路訪問介面
33 = /dev/inet/icmp
34 = /dev/inet/ggp
35 = /dev/inet/ipip
36 = /dev/inet/tcp
37 = /dev/inet/egp
38 = /dev/inet/pup
39 = /dev/inet/udp
40 = /dev/inet/idp
41 = /dev/inet/rawip
此外，iBCS-2 還需要下面的連接必須存在
/dev/ip -> /dev/inet/ip
/dev/icmp -> /dev/inet/icmp
/dev/ggp -> /dev/inet/ggp
/dev/ipip -> /dev/inet/ipip
/dev/tcp -> /dev/inet/tcp
/dev/egp -> /dev/inet/egp
/dev/pup -> /dev/inet/pup
/dev/udp -> /dev/inet/udp
/dev/idp -> /dev/inet/idp
/dev/rawip -> /dev/inet/rawip
/dev/inet/arp -> /dev/inet/udp
/dev/inet/rip -> /dev/inet/udp
/dev/nfsd -> /dev/socksys
/dev/X0R -> /dev/null
36 char Netlink 支持
0 = /dev/route 路由, 設備更新, kernel to user
3 = /dev/fwmonitor Firewall packet 復制

59 char sf 防火牆模塊
0 = /dev/firewall 與 sf 內核模塊通信

65 block SCSI 磁碟(16-31)
0 = /dev/sdq 第17個 SCSI 磁碟(整個磁碟)
16 = /dev/sdr 第18個 SCSI 磁碟(整個磁碟)
32 = /dev/sds 第19個 SCSI 磁碟(整個磁碟)
...
240 = /dev/sdaf 第32個 SCSI 磁碟(整個磁碟)

66 block SCSI 磁碟(32-47)
0 = /dev/sdag 第33個 SCSI 磁碟(整個磁碟)
16 = /dev/sdah 第34個 SCSI 磁碟(整個磁碟)
32 = /dev/sdai 第35個 SCSI 磁碟(整個磁碟)
...
240 = /dev/sdav 第48個 SCSI 磁碟(整個磁碟)

89 char I2C 匯流排介面
0 = /dev/i2c-0 第1個 I2C 適配器
1 = /dev/i2c-1 第2個 I2C 適配器
...

98 block 用戶模式下的虛擬塊設備(分區處理方式與 SCSI 磁碟相同)
0 = /dev/ubda 第1個用戶模式塊設備
16 = /dev/udbb 第2個用戶模式塊設備
...

103 block 審計(Audit)設備
0 = /dev/audit 審計(Audit)設備

128-135 char Unix98 PTY master
這些設備不應當存在設備節點，而應當通過 /dev/ptmx 介面訪問。

136-143 char Unix98 PTY slave
這些設備節點是自動生成的(伴有適當的許可權和模式)，不能手動創建。
方法是通過使用適當的 mount 選項(通常是：mode=0620,gid=<"tty"組的gid>)
將 devpts 文件系統掛載到 /dev/pts 目錄即可。
0 = /dev/pts/0 第1個 Unix98 PTY slave
1 = /dev/pts/1 第2個 Unix98 PTY slave
...
153 block Enhanced Metadisk RAID (EMD) 存儲單元(分區處理方式與 SCSI 磁碟相同)
0 = /dev/emd/0 第1個存儲單元
1 = /dev/emd/0p1 第1個存儲單元的第1個分區
2 = /dev/emd/0p2 第1個存儲單元的第2個分區
...
15 = /dev/emd/0p15 第1個存儲單元的第15個分區
16 = /dev/emd/1 第2個存儲單元
32 = /dev/emd/2 第3個存儲單元
...
240 = /dev/emd/15 第16個存儲單元

180 char USB 字元設備
96 = /dev/usb/hiddev0 第1個USB人機界面設備(滑鼠/鍵盤/游戲桿/手寫版等人操作計算機的設備)
...
111 = /dev/usb/hiddev15 第16個USB人機界面設備

180 block USB 塊設備(U盤之類)
0 = /dev/uba 第1個USB 塊設備
8 = /dev/ubb 第2個USB 塊設備
16 = /dev/ubc 第3個USB 塊設備
...

192 char 內核 profiling 介面
0 = /dev/profile Profiling 控制設備
1 = /dev/profile0 CPU 0 的 Profiling 設備
2 = /dev/profile1 CPU 1 的 Profiling 設備
...

193 char 內核事件跟蹤介面
0 = /dev/trace 跟蹤控制設備
1 = /dev/trace0 CPU 0 的跟蹤設備
2 = /dev/trace1 CPU 1 的跟蹤設備
...

195 char Nvidia 圖形設備(比如顯卡)
0 = /dev/nvidia0 第1個 Nvidia 卡
1 = /dev/nvidia1 第2個 Nvidia 卡
...
255 = /dev/nvidiactl Nvidia 卡控制設備

202 char 特定於CPU模式的寄存器(model-specific register,MSR)
0 = /dev/cpu/0/msr CPU 0 的 MSRs
1 = /dev/cpu/1/msr CPU 1 的 MSRs
...
203 char CPU CPUID 信息
0 = /dev/cpu/0/cpuid CPU 0 的 CPUID
1 = /dev/cpu/1/cpuid CPU 1 的 CPUID
...
===================================================================
這部分詳細說明一些應該或可能存在於 /dev 目錄之外的文件。
鏈接最好使用與這里完全相同的格式(絕對路徑或相對路徑)。
究竟是使用硬鏈接(hard)還是軟連接(symbolic)取決於不同的設備。
必須的鏈接
必須在所有的系統上都存在這些連接：
鏈接 目標 鏈接類型 簡要說明
/dev/fd /proc/self/fd symbolic 文件描述府
/dev/stdin fd/0 symbolic 標准輸入文件描述府
/dev/stdout fd/1 symbolic 標准輸出文件描述符
/dev/stderr fd/2 symbolic 標准錯誤文件描述符
/dev/nfsd socksys symbolic 僅為 iBCS-2 所必須
/dev/X0R null symbolic 僅為 iBCS-2 所必須
[注意] /dev/X0R 是 <字母 X>-<數字 0>-<字母 R>
推薦的鏈接
推薦在所有的系統上都存在這些連接：
鏈接 目標 鏈接類型 簡要說明
/dev/core /proc/kcore symbolic 為了向後兼容
/dev/ramdisk ram0 symbolic 為了向後兼容
/dev/ftape qft0 symbolic 為了向後兼容
/dev/bttv0 video0 symbolic 為了向後兼容
/dev/radio radio0 symbolic 為了向後兼容
/dev/i2o* /dev/i2o/* symbolic 為了向後兼容
/dev/scd? sr? hard 代替 SCSI CD-ROM 的名字
本地定義的鏈接
下面的鏈接很可能需要根據機器的實際硬體配置創建其中的一部分甚至全部。
這些鏈接僅僅是為了迎合習慣用法，它們既非必須也非推薦。
鏈接 目標 鏈接類型 簡要說明
/dev/mouse mouse port symbolic 當前滑鼠
/dev/tape tape device symbolic 當前磁帶
/dev/cdrom CD-ROM device symbolic 當前CD-ROM
/dev/cdwriter CD-writer symbolic 當前CD-writer
/dev/scanner scanner symbolic 當前掃描儀
/dev/modem modem port symbolic 當前數據機
/dev/root root device symbolic 當前根文件系統所在設備
/dev/swap swap device symbolic 當前swap所在設備
/dev/modem 不應當用於能夠同時支持呼入和呼出的modem，因為往往會導致鎖文件問題。
如果存在 /dev/modem ，那麼它應當指向一個恰當的主 TTY 設備。
對於SCSI設備，
/dev/tape 和 /dev/cdrom 應該分別指向"cooked"設備 /dev/st* 和 /dev/sr* ；
而 /dev/cdwriter 和 /dev/scanner 應當分別指向恰當的 /dev/sg* 。
/dev/mouse 可以指向一個主串列 TTY 設備、一個硬體滑鼠、
或者一個對應滑鼠驅動程序的套接字(例如 /dev/gpmdata)。

套接字和管道
持久套接字和命名管道可以存在於 /dev 中。常見的有：
/dev/printer socket lpd 本地套接字
/dev/log socket syslog 本地套接字
/dev/gpmdata socket gpm 滑鼠多路復用器(multiplexer)
/dev/gpmctl socket (LFS-LiveCD中出現)
/dev/initctl fifo pipe init 監聽它並從中獲取信息(用戶與 init 進程交互的通道)

掛載點
以下名稱被保留用於掛載特殊的文件系統。
這些特殊的文件系統只提供內核界面而不提供標準的設備節點。
/dev/pts devpts PTY slave 文件系統
/dev/shm tmpfs 提供對 POSIX 共享內存的直接訪問
===================================================================
終端(或TTY)設備是一種特殊的字元設備。終端設備是可以在會話中扮演控制終端角色的任何設備，
包括：虛擬控制台、串列介面(已廢棄)、偽終端(PTY)。
所有的終端設備共享一個通用的功能集合：line discipline，
它既包含通用的終端 line discipline 也包含SLIP和PPP模式。
所有的終端設備的命名都很相似。這部分內容將解釋命名規則和各種類型的TTY(終端)的使用。
需要注意的是這些命名習慣包含了幾個歷史遺留包袱。
其中的一些是Linux所特有的，另一些則是繼承自其他系統，
還有一些反映了Linux在成長過程中拋棄了原來借用自其它系統的一些習慣。
井號(#)在設備名里表示一個無前導零的十進制數。

虛擬控制台(Virtual console)和控制台設備(console device)
虛擬控制台是在系統視頻監視器上全屏顯示的終端。
虛擬控制台被命名為編號從 /dev/tty1 開始的 /dev/tty# 。
/dev/tty0 是當前虛擬控制台。
/dev/tty0 用於在不能使用幀緩沖設備(/dev/fb*)的機器上存取系統視頻卡，
注意，不要將 /dev/console 用於此目的。
/dev/console 由內核管理，系統消息將被發送到這里。
單用戶模式下必須允許 login 使用 /dev/console 。

串列介面(已廢棄)
這里所說的"串列介面"是指 RS-232 串列介面和任何模擬這種介面的設備，
不管是在硬體(例如數據機)還是在軟體(例如ISDN驅動)中模擬。
在linux中的每一個串列介面都有兩個設備名：
主設備或呼入(callin)設備、交替設備或呼出(callout)設備。
設備類型之間使用字母的大小寫進行區分。
比如，對於任意字母X，"tty"設備名為 /dev/ttyX# ，而"cu"設備名則為 /dev/cux# 。
由於歷史原因，/dev/ttyS# 和 /dev/ttyC# 分別等價於 /dev/cua# 和 /dev/cub# 。
名稱 /dev/ttyQ# 和 /dev/cuq# 被保留為本地使用。

偽終端(PTY)
偽終端用於創建登陸會話或提供其它功能，
比如通過 TTY line discipline (包括SLIP或者PPP功能)來處理任意的數據生成。
每一個 PTY 都有一個master端和一個slave端。按照 System V/Unix98 的 PTY 命名方案，
所有master端共享同一個 /dev/ptmx 設備節點(打開它內核將自動給出一個未分配的PTY)，
所有slave端都位於 /dev/pts 目錄下，名為 /dev/pts/# (內核會根據需要自動生成和刪除它們)。
一旦master端被打開，相應的slave設備就可以按照與 TTY 設備完全相同的方式使用。
master設備與slave設備之間通過內核進行連接，等價於擁有 TTY 功能的雙向管道(pipe)。
===============================
你可能會很奇怪，為什麼沒有 /dev/hda 這樣的設備，難道不常用么？
原因在於從 2.6.19 開始，內核引入了新的ATA驅動，將SATA/IDE硬碟同意使用 /dev/sd? 來表示了，所以 /dev/hd? 就沒有存在的必要了

『玖』 如何手動創建一個設備節點，寫出主要命令及參數

Linux下生成驅動設備節點文件的方法有3個：1、手動mknod；2、利用devfs；3、利用udev
在剛開始寫Linux設備驅動程序的時候，很多時候都是利用mknod命令手動創建設備節點，實際上Linux內核為我們提供了一組函數，可以用來在模塊載入的時候自動在/dev目錄下創建相應設備節點，並在卸載模塊時刪除該節點。
在2.6.17以前，在/dev目錄下生成設備文件很容易，
devfs_mk_bdev
devfs_mk_cdev
devfs_mk_symlink
devfs_mk_dir
devfs_remove
這幾個是純devfs的api，2.6.17以前可用，但後來devfs被sysfs+udev的形式取代，同時期sysfs文件系統可以用的api：
class_device_create_file，在2.6.26以後也不行了，現在，使用的是device_create ，從2.6.18開始可用
struct device *device_create(struct class *class, struct device *parent,
dev_t devt, const char *fmt, ...)
從2.6.26起又多了一個參數drvdata： the data to be added to the device for callbacks
不會用可以給此參數賦NULL
struct device *device_create(struct class *class, struct device *parent,
dev_t devt, void *drvdata, const char *fmt, ...)

下面著重講解第三種方法udev
在驅動用加入對udev的支持主要做的就是：在驅動初始化的代碼里調用class_create(...)為該設備創建一個class，再為每個設備調用device_create(...)( 在2.6較早的內核中用class_device_create)創建對應的設備。
內核中定義的struct class結構體，顧名思義，一個struct class結構體類型變數對應一個類，內核同時提供了class_create(…)函數，可以用它來創建一個類，這個類存放於sysfs下面，一旦創建好了這個類，再調用 device_create(…)函數來在/dev目錄下創建相應的設備節點。這樣，載入模塊的時候，用戶空間中的udev會自動響應 device_create(…)函數，去/sysfs下尋找對應的類從而創建設備節點。
struct class和class_create(…) 以及device_create(…)都包含在在/include/linux/device.h中，使用的時候一定要包含這個頭文件，否則編譯器會報錯。
struct class定義在頭文件include/linux/device.h中
class_create(…)在/drivers/base/class.c中實現
device_create(…)函數在/drivers/base/core.c中實現
class_destroy(...),device_destroy(...)也在/drivers/base/core.c中實現調用過程類似如下：
static struct class *spidev_class;

/*-------------------------------------------------------------------------*/

static int __devinit spidev_probe(struct spi_device *spi)
{
....

dev =device_create(spidev_class, &spi->dev, spidev->devt,
spidev, "spidev%d.%d",
spi->master->bus_num, spi->chip_select);
...
}

static int __devexit spidev_remove(struct spi_device *spi)
{
......
device_destroy(spidev_class, spidev->devt);
.....

return 0;
}

static struct spi_driver spidev_spi = {
.driver = {
.name = "spidev",
.owner = THIS_MODULE,
},
.probe = spidev_probe,
.remove = __devexit_p(spidev_remove),

};

/*-------------------------------------------------------------------------*/

static int __init spidev_init(void)
{
....

spidev_class =class_create(THIS_MODULE, "spidev");
if (IS_ERR(spidev_class)) {
unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
return PTR_ERR(spidev_class);
}
....
}
mole_init(spidev_init);

static void __exit spidev_exit(void)
{
......
class_destroy(spidev_class);
......
}
mole_exit(spidev_exit);

MODULE_DESCRIPTION("User mode SPI device interface");
MODULE_LICENSE("GPL");

下面以一個簡單字元設備驅動來展示如何使用這幾個函數
#include <linux/mole.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>

int HELLO_MAJOR = 0;
int HELLO_MINOR = 0;
int NUMBER_OF_DEVICES = 2;

struct class *my_class;
//struct cdev cdev;
//dev_t devno;

struct hello_dev {
struct device *dev;
dev_t chrdev;
struct cdev cdev;
};
static struct hello_dev *my_hello_dev = NULL;
struct file_operations hello_fops = {
.owner = THIS_MODULE
};

static int __init hello_init (void)
{
int err = 0;
struct device *dev;
my_hello_dev = kzalloc(sizeof(struct hello_dev), GFP_KERNEL);
if (NULL == my_hello_dev) {
printk("%s kzalloc failed!\n",__func__);
return -ENOMEM;
}
devno = MKDEV(HELLO_MAJOR, HELLO_MINOR);
if (HELLO_MAJOR)
err= register_chrdev_region(my_hello_dev->chrdev, 2, "memdev");
else
{
err = alloc_chrdev_region(&my_hello_dev->chrdev, 0, 2, "memdev");
HELLO_MAJOR = MAJOR(devno);
}
if (err) {
printk("%s alloc_chrdev_region failed!\n",__func__);
goto alloc_chrdev_err;
}
printk("MAJOR IS %d\n",HELLO_MAJOR);
cdev_init(&(my_hello_dev->cdev), &hello_fops);
my_hello_dev->cdev.owner = THIS_MODULE;
err = cdev_add(&(my_hello_dev->cdev), my_hello_dev->chrdev, 1);
if (err) {
printk("%s cdev_add failed!\n",__func__);
goto cdev_add_err;
}
printk (KERN_INFO "Character driver Registered\n");
my_class =class_create(THIS_MODULE,"hello_char_class"); //類名為hello_char_class
if(IS_ERR(my_class))
{
err = PTR_ERR(my_class);
printk("%s class_create failed!\n",__func__);
goto class_err;
}
dev = device_create(my_class,NULL,my_hello_dev->chrdev,NULL,"memdev%d",0); //設備名為memdev
if (IS_ERR(dev)) {
err = PTR_ERR(dev);
gyro_err("%s device_create failed!\n",__func__);
goto device_err;
}
printk("hello mole initialization\n");
return 0;

device_err:
device_destroy(my_class, my_hello_dev->chrdev);
class_err:
cdev_del(my_hello_dev->chrdev);
cdev_add_err:
unregister_chrdev_region(my_hello_dev->chrdev, 1);
alloc_chrdev_err:
kfree(my_hello_dev);
return err;
}

static void __exit hello_exit (void)
{
cdev_del (&(my_hello_dev->cdev));
unregister_chrdev_region (my_hello_dev->chrdev,1);
device_destroy(my_class, devno); //delete device node under /dev//必須先刪除設備，再刪除class類
class_destroy(my_class); //delete class created by us
printk (KERN_INFO "char driver cleaned up\n");
}

mole_init (hello_init);
mole_exit (hello_exit);

MODULE_LICENSE ("GPL");
這樣，模塊載入後，就能在/dev目錄下找到memdev這個設備節點了。
例2:內核中的drivers/i2c/i2c-dev.c
在i2cdev_attach_adapter中調用device_create(i2c_dev_class, &adap->dev,
MKDEV(I2C_MAJOR, adap->nr), NULL,
"i2c-%d", adap->nr);
這樣在dev目錄就產生i2c-0 或i2c-1節點

接下來就是udev應用，udev是應用層的東西，udev需要內核sysfs和tmpfs的支持，sysfs為udev提供設備入口和uevent通道，tmpfs為udev設備文件提供存放空間
udev的源碼可以在去相關網站下載，然後就是對其在運行環境下的移植，指定交叉編譯環境，修改Makefile下的CROSS_COMPILE，如為mipsel-linux-，DESTDIR=xxx，或直接make CROSS_COMPILE=mipsel-linux-,DESTDIR=xxx 並install
把主要生成的udevd、udevstart拷貝rootfs下的/sbin/目錄內，udev的配置文件udev.conf和rules.d下的rules文件拷貝到rootfs下的/etc/目錄內
並在rootfs/etc/init.d/rcS中添加以下幾行：
echo 「Starting udevd...」
/sbin/udevd --daemon
/sbin/udevstart
（原rcS內容如下：
# mount filesystems
/bin/mount -t proc /proc /proc
/bin/mount -t sysfs sysfs /sys
/bin/mount -t tmpfs tmpfs /dev
# create necessary devices
/bin/mknod /dev/null c 1 3
/bin/mkdir /dev/pts
/bin/mount -t devpts devpts /dev/pts
/bin/mknod /dev/audio c 14 4
/bin/mknod /dev/ts c 10 16
）
這樣當系統啟動後，udevd和udevstart就會解析配置文件，並自動在/dev下創建設備節點文件

『拾』 linux內核怎麼訪問設備節點

設備節復點代表是每個機算機硬體，制那個軟體要用那個硬體，它就會打開那設備節點嘛。。。 /dev/ttyS0這個是串口0 也就是windows 裡面的com1 ，只有要用到串口0的程序才會打開這個設備節點。 個人愚見，僅供參考，望及時採納