日志标签 ‘linux’

在内核中新增驱动代码目录(1)

2010年9月8日

Step by Step

如果学习Linux下驱动开发,那么本文所述的“在内核中新增驱动代码目录”应该是一个最基本的知识点了。那么如何将自己写好的驱动程序新增到内核?本文将一步一步的教会你。

1.在正式开始之前,请先切换到root用户:su root。不过可能会会出现问题:不管你输入什么密码,都会提示你错误(很可能是因为之前你根本未设置过密码)。这时候我们来修改root用户的密码:

sudo passwd root

输入两次后,即可修改完毕,这下再su root就可以成功切换到root用户。

2.你可以现在试着在终端输入make menuconfig,终端会提示你:make: *** 没有规则可以创建目标“menuconfig”。这是因为menuconfig涉及到图形界面,所以我们得安装一些依赖包(ubuntu下):sudo apt-get install libncurses5-dev。

3.在一般的教程中,都会提到.config文件,而且这个文件就位于内核代码的根目录下。因此我会输入命令:ls -a来寻找.config。可是找来找去都没有这个文件的踪影。这是为什么?这是因为在这之前,你从来没有进行过内核配置,所以当然就不会生成.config文件了。解决的方法也很简单,有了上面两步的准备工作,那么你应该会成功进入配置用户界面,然后什么也不做,保存退出即可。那么你再ls一下,你可以发现.config已经存在了。

在开始向加入驱动代码之前,我们先了解三项基本步骤:

(1)将编好的源代码复制到Linux内核源代码的相应目录

(2)在目录的Kconfig文件中增加新源代码对应项目的编译配置选项

(3)在目录的Makefile文件中增加对新源代码的编译条目

在完成上述三项工作之前,我们先看一下我们要新增的驱动的树形结构。比如我们写的驱动程序均放在edsionteDriver目录,在此目录中包含Kconfig,Makefile和test.c三个文件,以及Key和led两个目录。我们先提前创建好这些文件,请注意本文只是为了演示说明,如果实际应用,像key,led以及test.c这样的文件都是有实际意义的。那么现在复制到内核源码目录下的driver/目录下即可。

|– edsionteDriver
|    |– Kconfig
|    |– Makefile
|    |– key
|        |– Kconfig
|        |– Makefile
|        |– mykey.c
|    |– mydriver.c
|    |– mydriver_user.c

现在我们完成了第一步工作,你应该注意到,我们现在只是创建了各个目录下的Kconfig和Makefile文件,并没添加相关内容,所以接下来我们就来进行这两个文件的编写。

对于初学者来说,直接学习Makefile以及Kconfig的编写可能会有些眩晕甚至排斥学习,不过我们可以先了解这两个文件在实际的内核分析中有什么作用。一般来说,对于内核这个庞大的网络,想要快速定位你所关心的代码就需要首先分析某个目录下的Makefile以及Kconfig文件,它们可是我们分析内核代码的goole map。

比如我们要分析ext3类型的文件系统,那么我们进入源码目录下fs/ext3/目录中,我们打开此目录的Makefile文件:

  1 #
  2 # Makefile for the linux ext3-filesystem routines.
  3 #
  4
  5 obj-$(CONFIG_EXT3_FS) += ext3.o
  6
  7 ext3-y  := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
  8            ioctl.o namei.o super.o symlink.o hash.o resize.o ext3_jbd.o
  9
 10 ext3-$(CONFIG_EXT3_FS_XATTR)     += xattr.o xattr_user.o xattr_trusted.o
 11 ext3-$(CONFIG_EXT3_FS_POSIX_ACL) += acl.o
 12 ext3-$(CONFIG_EXT3_FS_SECURITY)  += xattr_security.o

我们应该先注意到7,8行,其定义了ext3变量(-y说明是多文件模块的定义,可以先忽略)。这里的定义变量类似于C语言中的宏定义,就是用ext3代替后面的.o文件列表。那么现在我们就可以知道与ext3模块最直接相关的就是后面这些文件对应的.c以及.h文件了,这些文件在源码相应的目录下都可以找到。那么ext3.o是否被编译取决于第的CONFIG_EXT3_FS,这个变量的值一般取y或n(甚至m)。它一般对应的是用户在配置界面时的输入。想要了解配置界面的菜单选项,就得看Kconfig文件。由于我们只关心EXT3_FS这个选项,因此我们相应的找到EXT3_FS这个选项的配置语句即可:

config EXT3_FS
	tristate "Ext3 journalling file system support"
	select JBD
	help
	  This is the journalling version of the Second extended file system
	  (often called ext3), the de facto standard Linux file system
	  (method to organize files on a storage device) for hard disks.
         #Other code was deleted

上述代码中,select说明只有JBD被配置,EXT3_FS这个配置项目才会在配置菜单上出现(事实上两者有更具体的依赖关系,可参考相关语法)。在配置菜单上会显示tristate后面的字符串,当用户选择配置此条目的情况下(有y,m和n三态选项),对应在Makefile文件中的CONFIG_EXT3_FS就对应为y。即obj-y的情况下,ext3.o菜会被编译。

现在将Makefile和Kconfig文件再串通起来想想,你应该会明白它们的作用。

一般来说,Makefile定义了根据该子目录下的源码文件构建目标文件的规则。像我们刚说的那个变量的定义以及根据CONFIG_EXT3_FS选项是否编译ext3.c文件。至于这些规则是否被执行,就取决于用户在配置菜单上是否选择配置这个选项,而这个配置菜单中配置选项就对应Kconfig文件。而且用户输入的配置结果会记录在.config文件当中。

通过上面的简单举例,我们可以先大致了解Makefile、Kconfig以及.config三者之间的关系以及作用。我们刚才分析的是内核中已经写好的代码的配置规则。对于我们上面所说的新增edsionteDriver驱动,应该如何添加?

具体添加过程请参见:在内核中新增驱动代码目录(2)。

IPC under Linux-Semaphore

2010年8月25日

本文将为你说明IPC的另一种方式:信号量。在操作系统原理课程中,我们对信号量机制有所了解,即实现进程对共享资源的互斥访问以及进程间的同步。与其他几种通信方式相比,信号量更突出的是对共享资源的访问控制。接下来,我们一边回忆以前学过的信号量机制,一边学习如何用系统调用函数来实现相关操作。

1.创建信号量集

注意这里使用的是信号量集,而不是创建一个信号量。通常我们用伪代码实现进程间的互斥或同步时,都定义一个整形变量作为信号量,初值一般都为0或1。实际应用时,我们每次都需要创建一个信号量集,即使此集合只包含一个信号量。一般我们通过下面函数去创建或者打开一个信号量集。

int semget(key_t key,int nsems,int semflg);

我们这里需要注意的是,此函数何时创建一个信号量集,何时打开一个信号量集。当semflg=IPC_CREATE时,如果当前系统中不存在此信号量集合(key值不存在),那么semget函数完成一个信号量的创建;否则,semget函数打开这个已存在的信号量集。当semflg=IPC_CREATE|IPC_EXCL时,只会完成创建,如果key值对应的信号量集合以存在,那么直接返回错误,错误代码为EEXIST。这并不难理解,和open文件的情况类似。此函数成功执行返回信号量集的标示符,否则为-1。

另外关于我们所创建的这个信号量集,有结构体struct semid_ds与之对应,这个结构体中存储信号量集中的相关属性。

2.PV操作的实现

对于信号量机制,我们最熟悉的应该便是PV操作了。以前我们在写进程互斥或同步的伪代码时,都是直接来使用P(semaphore)和V(semaphore)。那么我们如何具体实现?

int semop(int semid,struct sembuf *sops,size_t nsops);

现在我要告诉你,P和V操作均通过上述函数来完成。你肯定马上会想,P和V两个截然不同的操作如何使用上述函数来完成?这其实取决于sops参数。请先看这个参数的类型:

struct sembuf
{
	ushort sem_num;/*信号在信号量集中的索引*/
	short  sem_op; /*操作类型,是P还是V*/
	short  sem_flg;/*操作标志*/
}

我们可以发现,通过semid和sem_num两个字段就可以确定信号量集中的指定信号量。sem_op取不同的值就会产生不同的操作。特别的,如果其值为0,则此时semop操作的作用是测试信号量的值是否为0。下面的代码是经典PV操作的实现方法。

int p(int semid,int index)
{
	struct sembuf buf={0,-1,IPC_NOWAIT};

	if(index<0)
	{
		printf("error:index of the semaphore is invalid\n");
		exit(1);
	}
	buf.sem_num=index;
	if(semop(semid,&buf,1)==-1)
	{
		printf("P operation failed\n");
		exit(1);
	}
	return 0;
}

int v(int semid,int index)
{
	struct sembuf buf={0,+1,IPC_NOWAIT};

	if(index<0)
	{
		printf("error:index of the semaphore is invalid\n");
		exit(1);
	}
	buf.sem_num=index;
	if(semop(semid,&buf,1)==-1)
	{
		printf("V operation failed\n");
		exit(1);
	}
	return 0;
}

我们这里特别要说明的是struct sembuf结构中的sem_flg字段,如果其值为IPC_NOWAIT,根据sem_op的不同意义也不同。当sem_op为0时,如果设置IPC_NOWAIT,那么调用进程直接返回;否则调用进程进入睡眠状态直至信号量为0。当sem_op<0时,表示申请资源,如果没有设置IPC_NOWAIT,那么调用进程阻塞至此资源被释放;否则进程直接返回。

3.信号量的控制

上述两部分内容——如何创建信号量集,如何PV操作——似乎已经可以诠释信号量了,但是这毕竟不是我们写伪代码,我们必须对信号量进行相关控制,比如如何对信号量设置初值,如何得到信号量当前的值等等。因此掌握好控制函数semctl尤为重要。

int semctl(int semid,int semnum,int cmd,union semun);

注意第四个参数类型是不确定的,由cmd的类型来确定。第四个参数所有可能会用到的变量都被定义在一个共用体中。

union semun
{
	int val;
	struct semid_ds *buf;
	ushort *array;
	void *pad;
}

下面我们对几种常用的cmd进行说明。

如果我们想打印某个已存在信号量集的各个属性信息时,那么可以参考下面代码。

union semun semop;
struct semid_ds seminfo;
semop.buf=&seminfo;
if(semctl(semid,0,IPC_STAT,semop)==-1)
{
	printf("error:get the info of semaphroe failed\n");
	exit(1);
}

因为此时候cmd为IPC_STAT,那么semctl会自动从semop中取走buf字段。此操作成功完成后,信号量集的信息便存储在seminfo中。注意,在使用此操作前,一定要将buf指向一个struct semid_ds类型的变量,否则buf将是一个”野指针”。

如果想为某个指定的信号量设置初值,那么下面代码就是实现将标示符为semid的信号量集中索引为index的信号量赋值为5。

union semnu semop;
semop.val=5;
semctl(semid,index,SETVAL,semop);

想得到某个信号量当前的值时,就可以参考下面代码,注意第四个参数为0,因为cmd为GETVAL,所以semctl函数会忽略第四个参数的取值。

int semval;
semval=semctl(semid,index,GETVAL,0);

关于信号量的基本知识就是这些,下篇文章将用上述内容来实现一个进程互斥的例子。

shell管道重定向实现

2010年8月24日

如果你实现过my_shell.c,那么对管道重定向应该有印象。但是本文中所述的管道重定向,将采用最近我们学习的管道相关系统调用函数来实现。随后,也将和大家一起再去回顾当初my_shell.c中是如何实现管道重定向的

对于管道符号,这里只做简单的说明:管道符前命令的输出作为管道符后命令的输入。对于一般命令而言,输入均来自标准输入,而输出则至标准输出。但是为了实现管道重定向,我们先创建管道,然后将管道写端重定向到标准输出,将管道读端重定向到标准输入。当然这两次重定向分别在不同的进程中完成。具体代码实现可参考下面的代码片段。

	if(pipe(fd)==-1)
	{
		printf("my_pipe:can't create a pipe\n");
		exit(1);
	}

	pid=fork();
	if(pid==0)
	{
		close(fd[0]);
		dup2(fd[1],STDOUT_FILENO);
		close(fd[1]);

		if(execlp(argv[1],argv[1],NULL)==0)
		{
			printf("my_pipe:can't execute the first command in the child process\n");
			exit(1);
		}
	}
	else if(pid>\0)
	{
		close(fd[1]);
		dup2(fd[0],STDIN_FILENO);
		close(fd[0]);

		if(execlp(argv[2],argv[2],NULL)==0)
		{
			printf("my_pipe:can't execute the second command in the parent process\n");
			exit(1);
		}
	}
	else
	{
		printf("my_pipe:can't create a new process\n");
		exit(1);
	}

上述代码所实现的管道重定向只支持没有参数的命令,比如./my_pipe ls wc(相当于命令ls | wc)。如果想要使用命令参数,可以在次基础上继续完善。

可以发现,管道是作为前后两个命令的数据缓冲区,各命令的相关输入或输出只是“私下”操作。既然理解了上述代码,那么my_shell.c中的管道的实现代码也就一目了然了。

首先,创建一个子进程,然后在子进程中创建子子进程(pid2=fork())。其实无非是让这两个子进程去分别执行管道符前后的命令。这里应该注意的是此段代码是如何“模拟”管道的。我们可以发现,其实并没有真正的pipe一个管道,而是创建了一个实实在在tempfile文件而已,最后使用完毕再悄悄删除次文件。

再看具体是如何重定向的,在子子进程中,以写方式打开”管道”,将tempfile定向到标准输出。在子进程中,以读方式打开”管道”,将tempfile定向到标准输入。

看到这里,你应该已经发现,这里所用到的原理其实和一开始我们所述的方法是一致的。

			if(pid==0)//child_process
			{
				int pid2;
				int status2;
				int fd2;

				if((pid2=fork())<\0)
				{
					printf("fork2 error\n");
					return;
				}
				else if(pid2==0)//child_child_process
				{
					if(!(find_command(arg[0])))
					{
						printf("%s: command not found\n",arg[0]);
						exit(0);
					}
					fd2=open("/tmp/tempfile",O_WRONLY|O_CREAT|O_TRUNC,0644);
					dup2(fd2,1);
					execvp(arg[0],arg);
					exit(0);
				}

				if(waitpid(pid2,&status2,0)==-1)//waiting for child_child_process
				{
					printf("wait for child_child process error\n");
				}

				if(!(find_command(argnext[0])))
				{
					printf("%s:command not found\n",argnext[0]);
					exit(0);
				}

				fd2=open("/tmp/tempfile",O_RDONLY);
				dup2(fd2,0);
				execvp(argnext[0],argnext);

				if(remove("/tmp/tempfile"))
				{
					printf("remove error\n");
				}
				exit(0);
			}

			

IPC under Linux-FIFO(2)

2010年8月23日

下面我们来详细说明有名管道的读写规则。

3.有名管道读取规则

(1)如果进程A事先写打开FIFO,但却不进行写操作(FIFO中为空),那么进程B对其进行读操作时候将会阻塞,或者直接返回-1(当设置了非阻塞标志时)。
我们继续以《LinuxC编程实战》一书中的例子(P252)为原型,对procwrite.c函数稍作改动即可,具体代码如下。

	printf("Now the writer will sleep 5s..\n");
	sleep(5);
	printf("Now the writer wake up and will write to FIFO..\n");
	write(fd,buf,strlen(buf)+1);
	printf("writer will leave!\n");
	close(fd);

我们可以发现,procwrite进程运行后,发生了阻塞,这一点可用上文的打开规则来解释。当在另一个终端运行procread进程后,此时的procwrite正常运行。由于我们让procwrite进程睡眠5s,所以当前管道缓冲区是空的,我们可以在另一终端发现procread进程发生了阻塞。但当procwrite睡眠结束,继续运行时,procread进程可正确读出管道内数据。

如果你理解了规则1,那么我们继续来了解两种读操作阻塞的情况。

(2)当FIFO中有数据时,但是正在被进程A所读取,如果B进程此时也欲读FIFO,B进程将阻塞;如果FIFO中无数据,那么读进程也将阻塞(规则1所述)。想要解除阻塞只要在管道内写入数据即可,不管写入多少数据,也不管读进程请求读多少数据。

我们继续以上述例子为原型,但是需要两个读进程。首先procwrite进程先进行第一次写,然后睡眠20s,接着进行第二次写操作,这是为了解除因读操作而阻塞的进程。

        //procwrite.c部分代码
	printf("Now the writer will write data to FIFO..\n");
	write(fd,buf,strlen(buf)+1);
	printf("writer will leave!\n");
	sleep(20);
	strcpy(buf,"The write write another data now");
	write(fd,buf,strlen(buf)+1);
	close(fd);
	exit(0);

在procread.c程序中,我们让此进程一次性只读取一个字符。

int n=20;
while(n--)
{
read(fd,buf,1);
buf[strlen(buf)]='\0';
printf("Read content:%s\n",buf);
sleep(2);
}
close(fd);
unlink(FIFO_NAME);
exit(0);

在procread2.c程序中,我们让此进程一次性读完管道内所有数据。

printf("I will read data from FIFO..\n");
read(fd,buf,BUF_SIZE);
printf("Read content:%s\n",buf);
close(fd);
exit(0);

我们首先运行procwrite,然后立马运行procread,可以看到其每次只输出一个字符;接着我们运行procread2,可以看到这个进程一次性读完了管道内剩余的所有数据,而此时再看运行procread的那个终端,可知procread进程发生了阻塞,不过再稍等片刻,可发现它有接着输出字符,这是因为procwrite进程第二次的写操作解除了procread进程的阻塞。

这里只是为大家做一个简单的演示,我们可以在理解上述规则的基础上编写其他程序去验证。

4.有名管道的写规则

如果打开FIFO时,没有加非阻塞标志,那么写操作遵循以下的规则:

(1)如果写入数据的字节数不大于PIPE_BUF(注意,从内核2.6.11开始,其值为65536),Linux将保证写操作的原子性。当管道内的剩余缓冲区大于要写入的数据字节数时,那么将一次性写完数据;否则,进程进入睡眠状态,直至管道内的缓冲区可以容纳要写入的数据为止。

(2)如果写入的数据字节数不大于PIPE_BUF,那么Linux将不保证写操作的原子性。管道内一有空闲的缓冲区,写进程就去写数据,直至所有数据都被写完为止。

如果打开FIFO的时候加入了阻塞标志,那么写操作遵循一下规则:

(1)如果要写入数据的字节数大于PIPE_BUF,那么linux将不会保证写入的原子性。在写满所有FIFO空闲缓冲区后,写操作返回。

(2)如果要写入的数据的字节数不大于PIPE_BUF,那么linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数,写完后成功返回;如果当前FIFO空闲缓冲不能够容纳请求写入的字节数,则返回EAGAIN错误,提醒以后再写。

list.h的简单应用

2010年8月18日

既然我们分析了list.h,那么就要学以致用,因为通过具体的例子我们才能真实感受到双链表的用法。本文首先为你呈现一个最基本的双链表使用方法,然后在引用另外两个例子,大家可以去亲自试试。

1.简单的学生管理系统

这里学生管理系统只是个基本模型:用户输入数据,然后通过输出重定向到stuInfo.txt文件当中。先看学生信息数据结构:

struct postinfo
{
	char id[20];
	char name[20];
	char sex[10];
	char addr[50];
	char email[20];
	struct list_head list;
};

正如我们前面所说的那样,整个双链表是通过struct list_head结构链接起来的,这样我们每次对某个结点的操作,都是先获得list字段的地址,进而通过list_entry宏获得当前结点的地址。

首先,创建头指针。注意我这里说的是头指针,并不是头结点,因此你应该可以理解为什么下面会首先创建一个struct list_head类型的变量,而不是struct postinfo类型的变量。

	struct list_head head;
	INIT_LIST_HEAD(&head);

创建好头指针,我们接下来就去增加学生信息。每次都先生成一个struct postinfo类型的变量tmp,再将每次要增加的信息都暂时保存在此变量中,接着就利用上次我们所说的增加函数:

list_add_tail(&(tmp->list),head);

注意这里我们使用的是&(tmp->list),正如我们一开始所说的每次对结点的操作实际上都是通过list字段去完成的。

添加完毕后,如何去打印数据?使用我们的遍历宏。pos只是一个struct list_head类型的指针,这个宏会首先使得pos指向head->next,即list链表的第一个结点(而非第一个学生信息结点)。每次移动链表后,通过pos获得当前结点的地址,那么就可以获得其他数据字段的地址了。

	list_for_each(pos,head)
	{
		pinfo=list_entry(pos,struct postinfo,list);
		printf("%s %s %s %s %s\n",pinfo->id,pinfo->name,pinfo->sex,pinfo->addr,pinfo->email);
        }

这个演示程序关键部分就是这样,其他地方只要你有C语言基础,就可以完成的。

2.遍历进程

具体过程请点击这里

windows 7 ultimate product key

windows 7 ultimate product key

winrar download free

winrar download free

winzip registration code

winzip registration code

winzip free download

winzip free download

winzip activation code

winzip activation code

windows 7 key generator

windows 7 key generator

winzip freeware

winzip freeware

winzip free download full version

winzip free download full version

free winrar download

free winrar download

free winrar

free winrar

windows 7 crack

windows 7 crack

windows xp product key

windows xp product key

windows 7 activation crack

windows7 activation crack

free winzip

free winzip

winrar free download

winrar free download

winrar free

winrar free

download winrar free

download winrar free

windows 7 product key

windows 7 product key