- 论坛徽章:
- 0
|
linux内核分析（转自某位大哥网上的笔记）
#if PAGE_SHIFT mempages >;>;= (13 - PAGE_SHIFT);
#endif
mempages *= sizeof(struct list_head);
for (order = 0; ((1UL
do {
unsigned long tmp;
nr_hash = (1UL sizeof(struct list_head);
d_hash_mask = (nr_hash - 1);
tmp = nr_hash;
d_hash_shift = 0;
while ((tmp >;>;= 1UL) != 0UL)
d_hash_shift++;
dentry_hashtable = (struct list_head *)
__get_free_pages(GFP_ATOMIC, order);
} while (dentry_hashtable == NULL --order >;= 0);
; 如果order太大,超过了__get_free_pages最大可分配尺寸,则减小order的值重试.
printk("Dentry-cache hash table entries: %d (order: %ld, %ld bytes)\n",
nr_hash, order, (PAGE_SIZE
if (!dentry_hashtable)
panic("Failed to allocate dcache hash table\n" ;
d = dentry_hashtable;
i = nr_hash;
do {
INIT_LIST_HEAD(d);
d++;
i--;
} while (i);
}
对opera的注释加点解释，读起来可能会更省力些。
1.为什么要用这个算法
例如要构造一个文件 /usr/local/cross/my_comp
这时要沿着上面这个文件名开始依次找直到cross的数据结构，也就是要找到
/usr/
/usr/local/
/usr/local/cross/
对应的数据结构dentry
假定我们已经找到/usr/对应的dentry, 现在必须能够从local找到它对应的dentry,这时就要从名字---->;dentry的快速映射，在Linux中般用哈希映射。
2. 查找方法
首先，通过d_hash粗分类,找到"local"所在的链表，然后顺序向下一一匹配。
3.一些操作如opera所述
4.初始化
首先通过__get_free_pages获得一些页面，这些页面构成了所有链表头数组。
[目录]
--------------------------------------------------------------------------------
permission(inode,mask)
permission(inode,mask)用来测试对文件(inode)是否有(mask)访问权.
; fs/namei.c
int permission(struct inode * inode,int mask)
{
if (inode->;i_op inode->;i_op->;permission) {
; 如果文件系统定义了自已的授权算法
int retval;
lock_kernel();
retval = inode->;i_op->;permission(inode, mask);
unlock_kernel();
return retval;
}
return vfs_permission(inode, mask); 缺省的授权算法
}
int vfs_permission(struct inode * inode,int mask)
{
int mode = inode->;i_mode;
; 如果对只读文件系统中的普通文件,目录文件,符号链接请求写访问
if ((mask S_IWOTH) IS_RDONLY(inode)
(S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
return -EROFS; /* Nobody gets write access to a read-only fs */
; 如果对免疫文件请求写访问
if ((mask S_IWOTH) IS_IMMUTABLE(inode))
return -EACCES; /* Nobody gets write access to an immutable file */
if (current->;fsuid == inode->;i_uid)
mode >;>;= 6; 如果自已是文件的拥有者,取文件对拥有者的访问权
else if (in_group_p(inode->;i_gid))
mode >;>;= 3; 如果自已是文件所在组的成员,取文件对组成员的访问权
; 如果所请求的权限是实际对文件权限的子集或者被赋予了超越特权,则允许访问
if (((mode mask S_IRWXO) == mask) || capable(CAP_DAC_OVERRIDE))
return 0;
; 虽然自已对文件没有访问权限,但如果自已被赋予了读和检索的特权,
; 则允许读或检索目录.
/* read and search access */
if ((mask == S_IROTH) ||
(S_ISDIR(inode->;i_mode) !(mask ~(S_IROTH | S_IXOTH))))
if (capable(CAP_DAC_READ_SEARCH))
return 0;
return -EACCES;
}
; kernel/sys.c
/*
* Check whether we're fsgid/egid or in the supplemental group..
*/
int in_group_p(gid_t grp)
{
int retval = 1;
if (grp != current->;fsgid)
retval = supplemental_group_member(grp);
return retval;
}
static int supplemental_group_member(gid_t grp)
{
int i = current->;ngroups;
if (i) {
gid_t *groups = current->;groups;
do {
if (*groups == grp)
return 1;
groups++;
i--;
} while (i);
}
return 0;
}
[目录]
--------------------------------------------------------------------------------
IDE硬盘驱动器读写
Linux内核在缺省配置下最多支持10个IDE接口,IDE接口用ide_hwif_t结构来描述,每个IDE接口具有一对主-从驱动器接口,它们用ide_drive_t结构来描述,每个驱动器接口可接不同种类的IDE设备,如IDE硬盘,光驱等,它们用ide_driver_t结构来描述.
每个驱动器接口包含一个命令请求队列,用request_queue_t结构来描述,具体的请求用request结构来描述.
多个IDE驱动器可以共享一个中断,共享同一中断的驱动器形成一个组,用ide_hwgroup_t结构来描述.ide_intr()是所有的ide驱动器所共用的硬件中断入口,对之对应的ide_hwgroup_t指针将作为dev_id传递给ide_intr.
每次在读写某个驱动器之前,需要用ide_set_handler()来设置ide_intr将要调用的中断函数指针.中断产生以后,该函数指针被自动清除.
do_rw_disk(drive,rq,block) 从逻辑扇区号block开始向IDE硬盘驱动器drive写入rq所描述的内容.
以下是硬盘PIO传输模式的有关代码.
; drivers/ide/ide-disk.c
static ide_startstop_t do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
{
if (IDE_CONTROL_REG)
OUT_BYTE(drive->;ctl,IDE_CONTROL_REG);
OUT_BYTE(rq->;nr_sectors,IDE_NSECTOR_REG);
if (drive->;select.b.lba) { 如果是逻辑块寻址模式
OUT_BYTE(block,IDE_SECTOR_REG);
OUT_BYTE(block>;>;=8,IDE_LCYL_REG);
OUT_BYTE(block>;>;=8,IDE_HCYL_REG);
OUT_BYTE(((block>;>;
} else {
unsigned int sect,head,cyl,track;
track = block / drive->;sect;
sect = block % drive->;sect + 1;
OUT_BYTE(sect,IDE_SECTOR_REG);
head = track % drive->;head;
cyl = track / drive->;head;
OUT_BYTE(cyl,IDE_LCYL_REG);
OUT_BYTE(cyl>;>;8,IDE_HCYL_REG);
OUT_BYTE(head|drive->;select.all,IDE_SELECT_REG);
}
if (rq->;cmd == READ) {{
ide_set_handler(drive, WAIT_CMD, NULL); WAIT_CMD为10秒超时
OUT_BYTE(drive->;mult_count ? WIN_MULTREAD : WIN_READ, IDE_COMMAND_REG);
return ide_started;
}
if (rq->;cmd == WRITE) {
ide_startstop_t startstop;
OUT_BYTE(drive->;mult_count ? WIN_MULTWRITE : WIN_WRITE, IDE_COMMAND_REG);
if (ide_wait_stat( drive, DATA_READY, drive->;bad_wstat, WAIT_DRQ)) {
printk(KERN_ERR "%s: no DRQ after issuing %s\n", drive->;name,
drive->;mult_count ? "MULTWRITE" : "WRITE";
return startstop;
}
if (!drive->;unmask)
__cli(); /* local CPU only */
if (drive->;mult_count) { 如果允许多扇区传送
ide_hwgroup_t *hwgroup = HWGROUP(drive);
/*
* Ugh.. this part looks ugly because we MUST set up
* the interrupt handler before outputting the first block
* of data to be written. If we hit an error (corrupted buffer list)
* in ide_multwrite(), then we need to remove the handler/timer
* before returning. Fortunately, this NEVER happens (right?).
*
* Except when you get an error it seems...
*/
hwgroup->;wrq = *rq; /* scratchpad */
ide_set_handler (drive, WAIT_CMD, NULL);
if (ide_multwrite(drive, drive->;mult_count)) {
unsigned long flags;
spin_lock_irqsave( flags);
hwgroup->;handler = NULL;
del_timer(
spin_unlock_irqrestore( flags);
return ide_stopped;
}
} else {
ide_set_handler (drive, WAIT_CMD, NULL);
idedisk_output_data(drive, rq->;buffer, SECTOR_WORDS); 写入一扇区SECTOR_WORDS=512/4
}
return ide_started;
}
printk(KERN_ERR "%s: bad command: %d\n", drive->;name, rq->;cmd);
ide_end_request(0, HWGROUP(drive));
return ide_stopped;
}
void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler,
unsigned int timeout, ide_expiry_t *expiry)
{
unsigned long flags;
ide_hwgroup_t *hwgroup = HWGROUP(drive);
spin_lock_irqsave( flags);
if (hwgroup->;handler != NULL) {
printk("%s: ide_set_handler: handler not null; old=%p, new=%p\n",
drive->;name, hwgroup->;handler, handler);
}
hwgroup->;handler = handler;
hwgroup->;expiry = expiry;
hwgroup->;timer.expires = jiffies + timeout;
add_timer(
spin_unlock_irqrestore( flags);
}
static inline void idedisk_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
{
if (drive->;bswap) {
idedisk_bswap_data(buffer, wcount);
ide_output_data(drive, buffer, wcount);
idedisk_bswap_data(buffer, wcount);
} else
ide_output_data(drive, buffer, wcount);
}
void ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
{
byte io_32bit = drive->;io_32bit;
if (io_32bit) {
#if SUPPORT_VLB_SYNC
if (io_32bit 2) {
unsigned long flags;
__save_flags(flags); /* local CPU only */
__cli(); /* local CPU only */
do_vlb_sync(IDE_NSECTOR_REG);
outsl(IDE_DATA_REG, buffer, wcount);
__restore_flags(flags); /* local CPU only */
} else
#endif /* SUPPORT_VLB_SYNC */
outsl(IDE_DATA_REG, buffer, wcount);
} else {
#if SUPPORT_SLOW_DATA_PORTS
if (drive->;slow) {
unsigned short *ptr = (unsigned short *) buffer;
while (wcount--) {
outw_p(*ptr++, IDE_DATA_REG);
outw_p(*ptr++, IDE_DATA_REG);
}
} else
#endif /* SUPPORT_SLOW_DATA_PORTS */
outsw(IDE_DATA_REG, buffer, wcount }
}
int ide_multwrite (ide_drive_t *drive, unsigned int mcount)
{
ide_hwgroup_t *hwgroup= HWGROUP(drive);
/*
* This may look a bit odd, but remember wrq is a copy of the
* request not the original. The pointers are real however so the
* bh's are not copies. Remember that or bad stuff will happen
*
* At the point we are called the drive has asked us for the
* data, and its our job to feed it, walking across bh boundaries
* if need be.
*/
struct request *rq =
do {
unsigned long flags;
unsigned int nsect = rq->;current_nr_sectors;
if (nsect >; mcount)
nsect = mcount;
mcount -= nsect;
; 这时mcount为剩余的必需传送的扇区数
idedisk_output_data(drive, rq->;buffer, nsect spin_lock_irqsave( flags); /* Is this really necessary? */
#ifdef CONFIG_BLK_DEV_PDC4030
rq->;sector += nsect;
#endif
if (((long)(rq->;nr_sectors -= nsect)) spin_unlock_irqrestore( flags);
break;
}
if ((rq->;current_nr_sectors -= nsect) == 0) {
if ((rq->;bh = rq->;bh->;b_reqnext) != NULL) {{
rq->;current_nr_sectors = rq->;bh->;b_size>;>;9;
rq->;buffer = rq->;bh->;b_data;
} else {
spin_unlock_irqrestore( flags);
printk("%s: buffer list corrupted (%ld, %ld, %d)\n",
drive->;name, rq->;current_nr_sectors,
rq->;nr_sectors, nsect);
ide_end_request(0, hwgroup);
return 1;
}
} else {
/* Fix the pointer.. we ate data */
rq->;buffer += nsect }
spin_unlock_irqrestore( flags);
} while (mcount);
return 0;
}
; IDE接口共用中断入口
void ide_intr (int irq, void *dev_id, struct pt_regs *regs)
{
unsigned long flags;
ide_hwgroup_t *hwgroup = (ide_hwgroup_t *)dev_id;
ide_hwif_t *hwif;
ide_drive_t *drive;
ide_handler_t *handler;
ide_startstop_t startstop;
spin_lock_irqsave( flags);
hwif = hwgroup->;hwif;
if (!ide_ack_intr(hwif)) {
spin_unlock_irqrestore( flags);
return;
}
if ((handler = hwgroup->;handler) == NULL || hwgroup->;poll_timeout != 0) {
/*
* Not expecting an interrupt from this drive.
* That means this could be:
* (1) an interrupt from another PCI device
* sharing the same PCI INT# as us.
* or (2) a drive just entered sleep or standby mode,
* and is interrupting to let us know.
* or (3) a spurious interrupt of unknown origin.
*
* For PCI, we cannot tell the difference,
* so in that case we just ignore it and hope it goes away.
*/
#ifdef CONFIG_BLK_DEV_IDEPCI
if (IDE_PCI_DEVID_EQ(hwif->;pci_devid, IDE_PCI_DEVID_NULL))
#endif /* CONFIG_BLK_DEV_IDEPCI */
{
/*
* Probably not a shared PCI interrupt,
* so we can safely try to do something about it:
*/
unexpected_intr(irq, hwgroup);
#ifdef CONFIG_BLK_DEV_IDEPCI
} else {
/*
* Whack the status register, just in case we have a leftover pending IRQ.
*/
(void) IN_BYTE(hwif->;io_ports[IDE_STATUS_OFFSET]);
#endif /* CONFIG_BLK_DEV_IDEPCI */
}
spin_unlock_irqrestore( flags);
return;
}
drive = hwgroup->;drive;
if (!drive) {
/*
* This should NEVER happen, and there isn't much we could do about it here.
*/
spin_unlock_irqrestore( flags);
return;
}
if (!drive_is_ready(drive)) {
/*
* This happens regularly when we share a PCI IRQ with another device.
* Unfortunately, it can also happen with some buggy drives that trigger
* the IRQ before their status register is up to date. Hopefully we have
* enough advance overhead that the latter isn't a problem.
*/
spin_unlock_irqrestore( flags);
return;
}
if (!hwgroup->;busy) {
hwgroup->;busy = 1; /* paranoia */
printk("%s: ide_intr: hwgroup->;busy was 0 ??\n", drive->;name);
}
hwgroup->;handler = NULL;
del_timer(
spin_unlock(
if (drive->;unmask)
ide__sti(); /* local CPU only */
startstop = handler(drive); /* service this interrupt, may set handler for next interrupt */
spin_lock_irq(
/*
* Note that handler() may have set things up for another
* interrupt to occur soon, but it cannot happen until
* we exit from this routine, because it will be the
* same irq as is currently being serviced here, and Linux
* won't allow another of the same (on any CPU) until we return.
*/
set_recovery_timer(HWIF(drive));
drive->;service_time = jiffies - drive->;service_start;
if (startstop == ide_stopped) {
if (hwgroup->;handler == NULL) { /* paranoia */
hwgroup->;busy = 0;
ide_do_request(hwgroup, hwif->;irq);
} else {
printk("%s: ide_intr: huh? expected NULL handler on exit\n", drive->;name);
}
}
spin_unlock_irqrestore( flags);
}
; 单个扇区写入之后的中断处理
static ide_startstop_t write_intr (ide_drive_t *drive)
{
byte stat;
int i;
ide_hwgroup_t *hwgroup = HWGROUP(drive);
struct request *rq = hwgroup->;rq;
if (!OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->;bad_wstat)) {
printk("%s: write_intr error1: nr_sectors=%ld, stat=0x%02x\n", drive->;name, rq->;nr_sectors, stat);
} else {
if ((rq->;nr_sectors == 1) ^ ((stat DRQ_STAT) != 0)) {
rq->;sector++;
rq->;buffer += 512;
rq->;errors = 0;
i = --rq->;nr_sectors;
--rq->;current_nr_sectors;
if (((long)rq->;current_nr_sectors) ide_end_request(1, hwgroup);
if (i >; 0) {
idedisk_output_data (drive, rq->;buffer, SECTOR_WORDS);
ide_set_handler (drive, WAIT_CMD, NULL);
return ide_started;
}
return ide_stopped;
}
return ide_stopped; /* the original code did this here (?) */
}
return ide_error(drive, "write_intr", stat);
}
; 多重扇区写入后的中断处理
static ide_startstop_t multwrite_intr (ide_drive_t *drive)
{
byte stat;
int i;
ide_hwgroup_t *hwgroup = HWGROUP(drive);
struct request *rq =
if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->;bad_wstat)) {
if (stat DRQ_STAT) {
/*
* The drive wants data. Remember rq is the copy
* of the request
*/
if (rq->;nr_sectors) {
if (ide_multwrite(drive, drive->;mult_count))
return ide_stopped;
ide_set_handler (drive, WAIT_CMD, NULL);
return ide_started;
}
} else {
/*
* If the copy has all the blocks completed then
* we can end the original request.
*/
if (!rq->;nr_sectors) { /* all done? */
rq = hwgroup->;rq;
for (i = rq->;nr_sectors; i >; 0{
i -= rq->;current_nr_sectors;
ide_end_request(1, hwgroup);
}
return ide_stopped;
}
}
return ide_stopped; /* the original code did this here (?) */
}
return ide_error(drive, "multwrite_intr", stat);
}
; 读扇区的中断处理
static ide_startstop_t read_intr (ide_drive_t *drive)
{
byte stat;
int i;
unsigned int msect, nsect;
struct request *rq;
/* new way for dealing with premature shared PCI interrupts */
if (!OK_STAT(stat=GET_STAT(),DATA_READY,BAD_R_STAT)) {
if (stat (ERR_STAT|DRQ_STAT)) {
return ide_error(drive, "read_intr", stat);
}
/* no data yet, so wait for another interrupt */
ide_set_handler(drive, WAIT_CMD, NULL);
return ide_started;
}
msect = drive->;mult_count;
read_next:
rq = HWGROUP(drive)->;rq;
if (msect) {
if ((nsect = rq->;current_nr_sectors) >; msect)
nsect = msect;
msect -= nsect;
} else
nsect = 1;
idedisk_input_data(drive, rq->;buffer, nsect * SECTOR_WORDS);
rq->;sector += nsect;
rq->;buffer += nsect rq->;errors = 0;
i = (rq->;nr_sectors -= nsect);
if (((long)(rq->;current_nr_sectors -= nsect)) ide_end_request(1, HWGROUP(drive));
if (i >; 0) {
if (msect)
goto read_next;
ide_set_handler (drive, WAIT_CMD, NULL);
return ide_started;
}
return ide_stopped;
}
static inline void idedisk_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
{
ide_input_data(drive, buffer, wcount);
if (drive->;bswap)
idedisk_bswap_data(buffer, wcount);
}
void ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
{
byte io_32bit = drive->;io_32bit;
if (io_32bit) {
#if SUPPORT_VLB_SYNC
if (io_32bit 2) {
unsigned long flags;
__save_flags(flags); /* local CPU only */
__cli(); /* local CPU only */
do_vlb_sync(IDE_NSECTOR_REG);
insl(IDE_DATA_REG, buffer, wcount);
__restore_flags(flags); /* local CPU only */
} else
#endif /* SUPPORT_VLB_SYNC */
insl(IDE_DATA_REG, buffer, wcount);
} else {
#if SUPPORT_SLOW_DATA_PORTS
if (drive->;slow) {
unsigned short *ptr = (unsigned short *) buffer;
while (wcount--) {
*ptr++ = inw_p(IDE_DATA_REG);
*ptr++ = inw_p(IDE_DATA_REG);
}
} else
#endif /* SUPPORT_SLOW_DATA_PORTS */
insw(IDE_DATA_REG, buffer, wcount }
}
atomic_t queued_sectors;
#define blk_finished_io(nsects) \
atomic_sub(nsects, \
if (atomic_read( printk("block: queued_sectors atomic_set( 0); \
}
static inline void blkdev_dequeue_request(struct request * req)
{
list_del(
}
void ide_end_request (byte uptodate, ide_hwgroup_t *hwgroup)
{
struct request *rq;
unsigned long flags;
spin_lock_irqsave( flags);
rq = hwgroup->;rq;
if (!end_that_request_first(rq, uptodate, hwgroup->;drive->;name)) {
add_blkdev_randomness(MAJOR(rq->;rq_dev));
blkdev_dequeue_request(rq);
hwgroup->;rq = NULL;
end_that_request_last(rq);
}
spin_unlock_irqrestore( flags);
}
int end_that_request_first (struct request *req, int uptodate, char *name)
{
struct buffer_head * bh;
int nsect;
req->;errors = 0;
if (!uptodate)
printk("end_request: I/O error, dev %s (%s), sector %lu\n",
kdevname(req->;rq_dev), name, req->;sector);
if ((bh = req->;bh) != NULL) {
nsect = bh->;b_size >;>; 9;
blk_finished_io(nsect);
req->;bh = bh->;b_reqnext;
bh->;b_reqnext = NULL;
bh->;b_end_io(bh, uptodate);
if ((bh = req->;bh) != NULL) {
req->;hard_sector += nsect;
req->;hard_nr_sectors -= nsect;
req->;sector = req->;hard_sector;
req->;nr_sectors = req->;hard_nr_sectors;
req->;current_nr_sectors = bh->;b_size >;>; 9;
if (req->;nr_sectors current_nr_sectors) {
req->;nr_sectors = req->;current_nr_sectors;
printk("end_request: buffer-list destroyed\n";
}
req->;buffer = bh->;b_data;
return 1;
}
}
return 0;
}
void end_that_request_last(struct request *req)
{
if (req->;sem != NULL)
up(req->;sem);
blkdev_release_request(req);
}
void inline blkdev_release_request(struct request *req)
{
request_queue_t *q = req->;q;
int rw = req->;cmd;
req->;rq_status = RQ_INACTIVE;
req->;q = NULL;
/*
* Request may not have originated from ll_rw_blk. if not,
* asumme it has free buffers and check waiters
*/
if (q) {
/*
* we've released enough buffers to start I/O again
*/
if (waitqueue_active(
atomic_read( wake_up(
/*
* Add to pending free list and batch wakeups
*/
list_add(
if (++q->;pending_free[rw] >;= batch_requests) {
int wake_up = q->;pending_free[rw];
blk_refill_freelist(q, rw);
wake_up_nr( wake_up);
}
}
}
void inline blk_refill_freelist(request_queue_t *q, int rw)
{
if (q->;pending_free[rw]) {
list_splice(
INIT_LIST_HEAD(
q->;pending_free[rw] = 0;
}
}
[目录]
--------------------------------------------------------------------------------
proc
PROC文件系统是一个伪文件系统，它的文件和目录是由Linux 操作系统核心提供的，以文件系统的方式为访问系统内核数据的操作提供接口，它们不占用磁盘上的任何空间，有了这些文件和目录, 用户可以更容易的了解操作系统核心或各个进程的状态，并能对系统的一些参数进行配置。比如，一个系统内能打开的文件数最大缺省是1024，即系统最多能同时打开1024个文件，这在使用Linux做多用户的服务器时是不够用的，通过对/PROC下文件的修改可以在不修改核心，甚至不启动机器的情况下改变这个缺省值。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取PROC文件时，PROC文件系统是动态从系统内核读出所需信息并提交的。它的目录结构如下：
目录名称 目录内容
apm Advanced power management info
Cmdline Kernel command line
Cpuinfo Info about the CPU
Devices Available devices (block and character)
Dma Used DMS channels
Filesystems Supported filesystems
Interrupts Interrupt usage
Ioports I/O port usage
Kcore Kernel core image
Kmsg Kernel messages
Ksyms Kernel symbol table
Loadavg Load average
Locks Kernel locks
Meminfo Memory info
Misc Miscellaneous
Modules List of loaded modules
Mounts Mounted filesystems
Partitions Table of partitions known to the system
Rtc Real time clock
Slabinfo Slab pool info
Stat Overall statistics
Swaps Swap space utilization
Version Kernel version
Uptime System uptime
并不是所有这些目录在你的系统中都有，这取决于你的内核配置和装载的模块。另外，在/proc下还有三个很重要的目录：net，scsi和sys。Sys目录是可写的，可以通过它来访问或修改内核的参数，而net和scsi则依赖于内核配置。例如，如果系统不支持scsi，则scsi目录不存在。
除了以上介绍的这些，还有的是一些以数字命名的目录，它们是进程目录。系统中当前运行的每一个进程都有对应的一个目录在/PROC下，以进程的PID号为目录名，它们是读取进程信息的接口。而self目录则是读取进程本身的信息接口，是一个link。Proc文件系统的名字就是由之而起。进程目录的结构如下：
目录名称 目录内容
Cmdline Command line arguments
Environ Values of environment variables
Fd Directory, which contains all file descriptors
Mem Memory held by this process
Stat Process status
Status Process status in human readable form
Cwd Link to the current working directory
Exe Link to the executable of this process
Maps Memory maps
Statm Process memory status information
Root Link to the root directory of this process
用户如果要查看系统信息，可以用cat命令。例如：
>; cat /proc/interrupts
CPU0
0: 8728810 XT-PIC timer
1: 895 XT-PIC keyboard
2: 0 XT-PIC cascade
3: 531695 XT-PIC aha152x
4: 2014133 XT-PIC serial
5: 44401 XT-PIC pcnet_cs
8: 2 XT-PIC rtc
11: 8 XT-PIC i82365
12: 182918 XT-PIC PS/2 Mouse
13: 1 XT-PIC fpu
14: 1232265 XT-PIC ide0
15: 7 XT-PIC ide1
NMI: 0
2．修改内核参数
在/proc文件系统中有一个有趣的目录：/proc/sys。它不仅提供了内核信息，而且可以通过它修改内核参数，来优化你的系统。但是你必须很小心，因为可能会造成系统崩溃。最好是先找一台无关紧要的机子，调试成功后再应用到你的系统上。
要改变内核的参数，只要用vi编辑或echo参数重定向到文件中即可。下面有一个例子：
# cat /proc/sys/fs/file-max
4096
# echo 8192 >; /proc/sys/fs/file-max
# cat /proc/sys/fs/file-max
8192
如果你优化了参数，则可以把它们写成脚本文件，使它在系统启动时自动完成修改。
PROC文件系统的初始化过程概述
PROC文件系统总的初始化流程如下图所示，是从INIT/MAIN.C的START_KERNEL()函数中开始的，首先是PROC_ROOT_INIT()，在这个函数中用PROC_DIR_EMTRY注册了/PROC及其目录下的各个文件及目录的基本信息，包括注册INODE NUMBER，文件名长度，文件名，操作权限，连接数，用户标识号，组标识号，允许的INODE OPERATIONS和兄弟、父母、子文件的指针等，并生成文件目录之间的相互关系，即目录树。接下来在SYSCLT_INIT()里把ROOT_TABLE的各项内容挂到/PROC树的PROC_SYS_ROOT下面，PROC_SYS_ROOT是一个特殊的PROC项，即/PROC/SYS目录，在此目录下的部分文件是可写的，可以通过修改这些文件内容来修改系统配置参数。然后是FILESYSTEM_SETUP()，在这里产生一个新的FILE_SYSTEM_TYPE：PROC_FS_TYPE，把这个文件系统类型挂到FILE_SYSTEMS链表的末尾，其中包含了读取PROC文件系统SUPER BLOCK的函数指针，PROC_READ_SUPER，接下来在装载了ROOT文件系统后，如果还要把PROC文件系统MOUNT上来则需通过此函数把PROC文件系统的SUPER BLOCK读进内存里的SUPER_BLOCKS链表。从上面可以看到，PROC文件系统的初始化流程主要分两步，即登记注册和挂载文件系统，其中的核心内容是在登记注册里，下面就具体分析一下这两部分的具体初始化操作。
三、PROC文件系统的登记注册过程
从程序中来看，PROC文件系统的文件可以分为两大类，一类是ROOT部分，另一类是BASE部分，体现在初始化程序中分别叫做PROC_ROOT_INIT()和PROC_BASE_INIT()。ROOT部分主要是针对/PROC目录下的一些名称位置相对固定的常规性文件，如 CPUINFO，MEMINFO，KMESG，MODULES，DEVICES，INTERRUPTS，FILESYSTEMS，PARTITIONS，DMA，IOPORTS，CMDLINE，MOUNTS等；而BASE部分则是针对系统中每个进程的，每个运行中的进程在/PROC下都有一个以自己的进程号为名字的目录，里面记载了关于此进程运行状态的信息，如STATUS，MEM，CWD，ROOT，FD，EXE，CMDLINE，STAT，STATM等。下面将会分别介绍这两部分的初始化过程，首先介绍一下基本的数据结构。
1．基本数据结构
在PROC 文件系统中最重要的数据结构是一个叫PROC_DIR_ENTRY的结构类型(include/linux/proc_fs.h)，所有该文件系中的文件及目录都除了通用文件操作用的INODE，FILE，DENTRY等结构外，都必须首先注册自己的一个PROC_DIR_ENTRY，在其中定义了针对自己的各项属性和操作函数指针。
struct proc_dir_entry {
unsigned short low_ino; /*注册inode号，实际inode的低16位*/
unsigned short namelen; /*名称字符串的长度*/
const char *name; /*文件名称*/
mode_t mode; /*文件权限*/
nlink_t nlink; /*连接到此文件的目录项个数*/
uid_t uid; /*用户标识*/
gid_t gid; /*组标识*/
unsigned long size; /*文件大小，均为0*/
struct inode_operations * ops; /*inode操作的函数指针*/
int (*get_info)(char *, char **, off_t, int, int);
void (*fill_inode)(struct inode *, int); /*填补inode信息的函数指针*/
struct proc_dir_entry *next, *parent, *subdir; /*兄弟，父亲，子文件指针*/
void *data;
int (*read_proc)(char *page, char **start, off_t off, int count,
int *eof, void *data);
int (*write_proc)(struct file *file, const char *buffer,
unsigned long count, void *data);
int (*readlink_proc)(struct proc_dir_entry *de, char *page);
unsigned int count; /*使用数*/
int deleted; /*删除标志*/
};
其次就是针对INODE，FILE和SUPER BLOCK的各种操作函数指针，这些结构与文件系统中使用的完全相同，此处不再赘述。
2．PROC_ROOT_INIT()
PROC_ROOT_INIT()函数的定义如下：
__initfunc(void proc_root_init(void))
{
proc_base_init();
proc_register(&proc_root, &proc_root_loadavg);
proc_register(&proc_root, &proc_root_uptime);
proc_register(&proc_root, &proc_root_meminfo);
proc_register(&proc_root, &proc_root_kmsg);
proc_register(&proc_root, &proc_root_version);
proc_register(&proc_root, &proc_root_cpuinfo);
proc_register(&proc_root, &proc_root_self);
#ifdef CONFIG_SYSCTL
proc_register(&proc_root, &proc_sys_root);
#endif
#ifdef CONFIG_MCA
proc_register(&proc_root, &proc_mca);
#endif
#ifdef CONFIG_DEBUG_MALLOC
proc_register(&proc_root, &proc_root_malloc);
#endif
#ifdef CONFIG_MODULES
proc_register(&proc_root, &proc_root_modules);
proc_register(&proc_root, &proc_root_ksyms);
#endif
proc_register(&proc_root, &proc_root_stat);
proc_register(&proc_root, &proc_root_devices);
proc_register(&proc_root, &proc_root_partitions);
proc_register(&proc_root, &proc_root_interrupts);
proc_register(&proc_root, &proc_root_filesystems);
proc_register(&proc_root, &proc_root_fs);
proc_register(&proc_root, &proc_root_dma);
proc_register(&proc_root, &proc_root_ioports);
proc_register(&proc_root, &proc_root_cmdline);
……
}
__initfunc是在inlucde/linux/init.h中定义的一个宏，表示此函数仅在系统初始化时使用，使用完毕即释放申请的内存资源。
PROC_REGISTER()函数在fs/proc/root.c中定义，程序如下：
int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
{
int i;
if (dp->;low_ino == 0) {
i = make_inode_number();
if (i < 0)
return -EAGAIN;
dp->;low_ino = i;
}
/*如果没有low_ino值，则产生一个新的赋给它*/
dp->;next = dir->;subdir;
dp->;parent = dir;
dir->;subdir = dp;
/*赋给兄弟、父母及子女的指针*/
if (S_ISDIR(dp->;mode)) {
if (dp->;ops == NULL)
dp->;ops = &proc_dir_inode_operations;
dir->;nlink++;
} else if (S_ISLNK(dp->;mode)) {
if (dp->;ops == NULL)
dp->;ops = &proc_link_inode_operations;
} else {
if (dp->;ops == NULL)
dp->;ops = &proc_file_inode_operations;
}
/*对于dp的不同属性调整操作函数指针*/
return 0;
}
初始化时首先要为每个文件或目录创建一个PROC_DIR_ENTRY的实例变量，内容包括注册的INODE号，名称，操作权限，连接数和INODE操作函数指针等，具体方法如下所示：
struct proc_dir_entry proc_root = {
PROC_ROOT_INO, 5, "/proc", S_IFDIR | S_IRUGO | S_IXUGO,
2, 0, 0, 0, &proc_root_inode_operations, NULL, NULL, NULL,
&proc_root, NULL };
struct proc_dir_entry proc_mca = {
PROC_MCA, 3, "mca", S_IFDIR | S_IRUGO | S_IXUGO,
2, 0, 0, 0, &proc_dir_inode_operations, NULL, NULL, NULL,
&proc_root, NULL };
static struct proc_dir_entry proc_root_loadavg = {
PROC_LOADAVG, 7, "loadavg", S_IFREG | S_IRUGO, 1, 0, 0,
0, &proc_array_inode_operations };
static struct proc_dir_entry proc_root_uptime = {
PROC_UPTIME, 6, "uptime", S_IFREG | S_IRUGO, 1, 0, 0,
0, &proc_array_inode_operations };
static struct proc_dir_entry proc_root_meminfo = {
PROC_MEMINFO, 7, "meminfo", S_IFREG | S_IRUGO, 1, 0, 0,
0, &proc_array_inode_operations };
static struct proc_dir_entry proc_root_kmsg = {
PROC_KMSG, 4, "kmsg", S_IFREG | S_IRUSR, 1, 0, 0,
0, &proc_kmsg_inode_operations };
......
PROC_REGISTER()函数首先检查这个新的PROC_DIR_ENTRY是否已有自己的PROC INODE号，如前所述，PROC文件系统是个“伪”文件系统，它并不存在于任何实际的物理设备上，所以它的文件INODE号与普通文件的INODE号的涵义是不同的，它不需要标识此文件的物理存在位置，只要能在本文件系统中唯一地标识这个文件即可。对于ROOT部分的文件在include/proc_fs.h中用一个枚举变量enum root_directory_inos来对其赋值，其中第一个文件即/PROC目录用PROC_ROOT_INO=1来定义。如果此文件在变量初始化时未赋值，LINUX用一个proc_alloc_map来表示INODE的使用情况，proc_alloc_map是一块有4096个bits的内存空间，每一位表示一个INODE的使用情况，如已经被使用则置位，放弃时恢复。分配时找其中第一位未使用的bit，在其位数上加上4096就是这个新登记文件的PROC INODE号。在此之后，PROC_REGISTER()调整父目录与子目录/文件之间的指针关系，及子目录/文件的INODE操作函数指针，最终结果是生成一棵以PROC_DIR_ENTRY为节点，PROC_ROOT为根的目录树,表明其相互之间的关系，在以后对文件或目录做标准操作（即用INODE，FILE，DENTRY等结构）的时候就可以从中获得需要的信息和函数指针。
在解释过PROC_REGISTER()函数后顺便再说明一下它的反向操作函数PROC_UNREGISTER()，即注销一个PROC_DIR_ENTRY项，其定义如下：
int proc_unregister(struct proc_dir_entry * dir, int ino)
{
struct proc_dir_entry **p = &dir->;subdir, *dp;
/*从dir的subdir指针开始进行搜索*/
while ((dp = *p) != NULL) { /*在dp指针尚不为空时*/
if (dp->;low_ino == ino) { /*如果low_ino==ino，说明仅对root部分*/
*p = dp->;next;
dp->;next = NULL;
/*兄弟指针置空*/
if (S_ISDIR(dp->;mode))
dir->;nlink--;
/*如果dp是目录，其父目录的连接数要减去1*/
if (ino >;= PROC_DYNAMIC_FIRST &&
ino < PROC_DYNAMIC_FIRST+PROC_NDYNAMIC)
clear_bit(ino-PROC_DYNAMIC_FIRST,
(void *) proc_alloc_map);
/*如果是在程序中生成的low_ino，则要清除对应的proc_allc_map中的*/
/*位标志*/
proc_kill_inodes(ino);
return 0;
}
p = &dp->;next; /*p指向dp的兄弟指针，继续搜索*/
}
return -EINVAL;
}
在PROC_UNREGISTER()中调用了另一个函数PROC_KILL_INODE()，该函数的功能是把一个已经被注销的PROC文件系统的INODE消灭掉，定义如下：
static void proc_kill_inodes(int ino)
{
struct file *filp;
/* inuse_filps is protected by the single kernel lock */
for (filp = inuse_filps; filp; filp = filp->;f_next) {
/*在正在使用中的文件链表中进行搜索*/
struct dentry * dentry;
struct inode * inode;
dentry = filp->;f_dentry;
if (!dentry)
continue;
if (dentry->;d_op != &proc_dentry_operations)
continue;
/*如果该项不属于PROC文件系统，则继续*/
inode = dentry->;d_inode;
if (!inode)
continue;
if (inode->;i_ino != ino)
continue;
filp->;f_op = NULL;
/*把该文件的操作函数指针置空，以后就无法使用了*/
}
}
3．PROC_BASE_INIT()
PROC_BASE_INIT()函数在PROC_ROOT_INIT()中调用，BASE部分的初始化与ROOT部分基本相同，首先为每个目录和文件初始化一个PROC_DIR_ENTRY结构，然后调用PROC_REGISTER()函数进行注册，并生成BASE部分的关系树，程序如下：
struct proc_dir_entry proc_pid = {
PROC_PID_INO, 5, "<pid>;", S_IFDIR | S_IRUGO | S_IXUGO, 2, 0, 0,
0, &proc_base_inode_operations, NULL, proc_pid_fill_inode,
NULL, &proc_root, NULL
};
static struct proc_dir_entry proc_pid_status = {
PROC_PID_STATUS, 6, "status", S_IFREG | S_IRUGO, 1, 0, 0,
0, &proc_array_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_mem = {
PROC_PID_MEM, 3, "mem", S_IFREG | S_IRUSR | S_IWUSR, 1, 0, 0,
0, &proc_mem_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_cwd = {
PROC_PID_CWD, 3, "cwd", S_IFLNK | S_IRWXU, 1, 0, 0,
0, &proc_link_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_root = {
PROC_PID_ROOT, 4, "root", S_IFLNK | S_IRWXU, 1, 0, 0,
0, &proc_link_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_exe = {
PROC_PID_EXE, 3, "exe", S_IFLNK | S_IRWXU, 1, 0, 0,
0, &proc_link_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_fd = {
PROC_PID_FD, 2, "fd", S_IFDIR | S_IRUSR | S_IXUSR, 2, 0, 0,
0, &proc_fd_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_environ = {
PROC_PID_ENVIRON, 7, "environ", S_IFREG | S_IRUSR, 1, 0, 0,
0, &proc_array_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_cmdline = {
PROC_PID_CMDLINE, 7, "cmdline", S_IFREG | S_IRUGO, 1, 0, 0,
0, &proc_array_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_stat = {
PROC_PID_STAT, 4, "stat", S_IFREG | S_IRUGO, 1, 0, 0,
0, &proc_array_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_statm = {
PROC_PID_STATM, 5, "statm", S_IFREG | S_IRUGO, 1, 0, 0,
0, &proc_array_inode_operations, NULL, proc_pid_fill_inode,
};
static struct proc_dir_entry proc_pid_maps = {
PROC_PID_MAPS, 4, "maps", S_IFIFO | S_IRUGO, 1, 0, 0,
0, &proc_arraylong_inode_operations, NULL, proc_pid_fill_inode, };
__initfunc(void proc_base_init(void))
{
#if CONFIG_AP1000
proc_register(&proc_pid, &proc_pid_ringbuf);
#endif
proc_register(&proc_pid, &proc_pid_status);
proc_register(&proc_pid, &proc_pid_mem);
proc_register(&proc_pid, &proc_pid_cwd);
proc_register(&proc_pid, &proc_pid_root);
proc_register(&proc_pid, &proc_pid_exe);
proc_register(&proc_pid, &proc_pid_fd);
proc_register(&proc_pid, &proc_pid_environ);
proc_register(&proc_pid, &proc_pid_cmdline);
proc_regis
ter(&proc_pid, &proc_pid_stat);
proc_register(&proc_pid, &proc_pid_statm);
proc_register(&proc_pid, &proc_pid_maps);
#ifdef __SMP__
proc_register(&proc_pid, &proc_pid_cpu);
#endif
};
这部分与ROOT部分的不同之处一是BASE部分的文件/目录的PROC INODE 号是用另一个枚举变量enum pid_directory_inos来赋值，其第一项PROC_PID_INO=2，即<pid>;目录。由于ROOT部分的每个文件/目录在/PROC下只有唯一的一个实例，而BASE部分对每个进程均有相同的一份拷贝，所以它的实际INODE号必须对不同的进程予以区分，在LINUX中，这种区分是通过把进程PID做为INODE的高16位，PROC_DIR_ENTRY中的LOW_INO做为INODE的低16位来实现的，这样可以保证每个文件INODE号在文件系统中的唯一性。另一个不同之处是BASE部分的文件在注册其PROC_DIR_ENTRY的时候都增加了FILL_INODE函数指针，指向PROC_PID_FILL_INODE函数，该函数的主要功能是把实际INODE号右移16位，获得对应此目录或文件的进程PID号，再把此进程的用户标识和组标识赋回给INODE结构。还有一点区别就是PROC_BASE_INIT()初始化的这棵PROC_DIR_ENTRY树是相对独立的（如图2），它以<pid>;目录，即PROC_PID项为根，并注册了该目录下各个文件及目录之间的相互关系，但它并不把PROC_PID挂到PROC_ROOT下面去，因为这是要在对PROC_ROOT做READDIR时动态加载的。
4．INODE OPERATIONS
有一点需要强调的是PROC文件系统在初始化时只是为每个目录和文件登记了一个PROC_DIR_ENTRY项，并为这些项生成了关系树，但对于VFS的通用文件操作做使用的数据结构，如INODE，FILE，DENTRY等此时都是不存在的，这些数据结构要等到在对PROC文件系统的文件做OPEN和READ等操作时才会根据PROC_DIR_ENTRY里定义的INODE OPERATION及其中的FILE OPERATIONS函数指针调用对应函数产生，这是PROC文件系统与其他基于设备的文件系统的一大区别之处。所以，在PROC_DIR_ENTRY中定义的INODE OPERATIONS决定了该文件的操作方式以及获取对应系统信息的渠道。举例来说，PROC_ROOT指向的PROC_ROOT_INODE_OPERATIONS中允许的INODE OPERATIONS函数是PROC_ROOT_LOOKUP，FILE OPERATIONS函数是PROC_ROOT_READDIR ；PROC_PID指向的PROC_BASE_INODE_OPERATIONS中允许的INODE OPERATIONS函数是PROC_LOOKUP，FILE OPERATIONS函数是PROC_ READDIR ；PROC_MEM_INFO指向的PROC_ARRAY_INODE_OPERATIONS中允许的INODE OPERATIONS函数均为空，FILE OPERATIONS函数是ARRAY_READ。下面我们来分析一下几个LOOKUP和READDIR函数，ARRAY_READ的功能主要是面向底层如何获取系统信息反馈上来，详见黄军同学的报告，这里就不做详述了。
PROC_LOOKUP、PROC_READDIR与PROC_ROOT_LOOKUP、PROC_ROOT_READDIR的功能基本上是相同的，只不过加上了ROOT后就加上了对< ID>;目录的处理功能。
程序如下所示：
1) proc_lookup()
int proc_lookup(struct inode * dir, struct dentry *dentry)
{
struct inode *inode;
struct proc_dir_entry * de;
int error;
error = -ENOTDIR;
if (!dir || !S_ISDIR(dir->;i_mode))
goto out;
/*如果dir空或dir不是目录，则退出*/
error = -ENOENT;
inode = NULL;
de = (struct proc_dir_entry *) dir->;u.generic_ip;
/*根据dir生成一个proc_dir_entry的指针*/
if (de) {
for (de = de->;subdir; de ; de = de->;next) {
/*在de的子目录和文件中搜索*/
if (!de || !de->;low_ino)
continue;
if (de->;namelen != dentry->;d_name.len)
continue;
if (!memcmp(dentry->;d_name.name, de->;name, de->;namelen)) {
/*如果dentry和由dir指向的proc_dir_entry名字相同*/
int ino = de->;low_ino | (dir->;i_ino & ~(0xffff));
error = -EINVAL;
inode = proc_get_inode(dir->;i_sb, ino, de);
/*申请一个inode节点，对应的proc_dir_entry节点为de，节点号*/
/*为ino。同时把de的数据填入inode */
break;
}
}
}
if (inode) {
dentry->;d_op = &proc_dentry_operations;
d_add(dentry, inode);
/*把dentry放到dentry_hash_table表中然后把inode的I_dentry和dentry的*/
/*d_alias相连*/
error = 0;
}
out:
return error;
}
2) proc_root_lookup()
static int proc_root_lookup(struct inode * dir, struct dentry * dentry)
{
unsigned int pid, c;
struct task_struct *p;
const char *name;
struct inode *inode;
int len;
if (dir->;i_ino == PROC_ROOT_INO) { /* check for safety... */
dir->;i_nlink = proc_root.nlink;
read_lock(&tasklist_lock); /*加读进程列表的锁*/
for_each_task(p) {
if (p->;pid)
dir->;i_nlink++; /*对于每个进程都要把proc_root的link数加１*/
}
read_unlock(&tasklist_lock); /*解读进程列表的锁*/
}
if (!proc_lookup(dir, dentry)) /*如果调用proc_lookup成功则返回*/
return 0;
/*如果调用proc_lookup不成功，说明要找的是pid部分的*/
pid = 0;
name = dentry->;d_name.name;
len = dentry->;d_name.len;
while (len-- >; 0) {
c = *name - '0';
name++;
if (c >; 9) {
pid = 0;
break;
}
pid *= 10;
pid += c;
/*把目录名的字符串转换成整数型的进程号*/
if (pid & 0xffff0000) {
pid = 0;
break;
}
}
read_lock(&tasklist_lock);
p = find_task_by_pid(pid);
read_unlock(&tasklist_lock);
inode = NULL;
if (pid && p) {
unsigned long ino = (pid << 16) + PROC_PID_INO;
inode = proc_get_inode(dir->;i_sb, ino, &proc_pid);
if (!inode)
return -EINVAL;
inode->;i_flags|=S_IMMUTABLE;
}
dentry->;d_op = &proc_dentry_operations;
d_add(dentry, inode);
return 0;
}
3) proc_readdir()
int proc_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
struct proc_dir_entry * de;
unsigned int ino;
int i;
struct inode *inode = filp->;f_dentry->;d_inode;
if (!inode || !S_ISDIR(inode->;i_mode))
return -ENOTDIR;
ino = inode->;i_ino;
de = (struct proc_dir_entry *) inode->;u.generic_ip;
if (!de)
return -EINVAL;
i = filp->;f_pos;
switch (i) {
case 0:
if (filldir(dirent, ".", 1, i, ino) < 0)
return 0;
i++;
filp->;f_pos++;
/* fall through */
case 1:
if (filldir(dirent, "..", 2, i, de->;parent->;low_ino) < 0)
return 0;
i++;
filp->;f_pos++;
/* fall through */
default:
ino &= ~0xffff;
de = de->;subdir;
i -= 2;
for (; {
if (!de)
return 1;
if (!i)
break;
de = de->;next;
i--;
}
do {
if (filldir(dirent, de->;name, de->;namelen, filp->;f_pos, ino | de->;low_ino) < 0)
return 0;
filp->;f_pos++;
de = de->;next;
} while (de);
}
return 1;
}
4) get_pid_list()
static int get_pid_list(int index, unsigned int *pids)
{
struct task_struct *p;
int nr_pids = 0;
index -= FIRST_PROCESS_ENTRY;
read_lock(&tasklist_lock);
for_each_task(p) {
int pid = p->;pid;
if (!pid)
continue;
if (--index >;= 0)
continue;
pids[nr_pids] = pid;
nr_pids++;
if (nr_pids >;= PROC_MAXPIDS)
break;
}
read_unlock(&tasklist_lock);
return nr_pids;
}
5) proc_root_readdir()
static int proc_root_readdir(struct file * filp, void * dirent, filldir_t filldir)
{
unsigned int pid_array[PROC_MAXPIDS];
char buf[PROC_NUMBUF];
unsigned int nr = filp->;f_pos;
unsigned int nr_pids, i;
if (nr < FIRST_PROCESS_ENTRY) {
int error = proc_readdir(filp, dirent, filldir);
if (error <= 0)
return error;
filp->;f_pos = nr = FIRST_PROCESS_ENTRY;
}
nr_pids = get_pid_list(nr, pid_array);
for (i = 0; i < nr_pids; i++) {
int pid = pid_array;
ino_t ino = (pid << 16) + PROC_PID_INO;
unsigned long j = PROC_NUMBUF;
do {
j--;
buf[j] = '0' + (pid % 10);
pid /= 10;
} while (pid);
if (filldir(dirent, buf+j, PROC_NUMBUF-j, filp->;f_pos, ino) < 0)
break;
filp->;f_pos++;
}
return 0;
}
在这里通过inode_operation和file_operation注册的这些函数是在对/PROC下的文件及目录进行open及read操作时才被调用，生成对应的inode，file，dentry等数据结构并取得对应的系统信息反馈
PROC文件系统的挂载过程
FILESYSTEM_SETUP()主要就是调用了一系列的INIT_*_FS()函数（*代表各种不同的文件系统），对PROC文件系统就是INIT_PROC_FS()，在此函数中实例化了一个FILE_SYSTEM_TYPE类型的结构变量PROC_FS_TYPE，其中包括此文件系统的名字和PROC_READ_SUPER函数指针，然后通过REGISTER_FILESYSTEM函数把它挂到FILE_SYSTEMS链表的末尾。
/* fs/filesystems.c */
void __init filesystem_setup(void)
{
#ifdef CONFIG_EXT2_FS
init_ext2_fs(); /* 初始化ext2文件系统 */
#endif
......
#ifdef CONFIG_PROC_FS
init_proc_fs(); /* 初始化proc文件系统 */
#endif
......
} ;
/* fs/proc/procfs_syms.c */
static struct file_system_type proc_fs_type = {
"proc",
0 /* FS_NO_DCACHE doesn't work correctly */,
proc_read_super, /*针对本文件系统读取super_block的函数指针*/
NULL } ;
int init_proc_fs(void)
{
return register_filesystem(&proc_fs_type) == 0;
}
/* fs/super.c */
int register_filesystem(struct file_system_type * fs)
{
struct file_system_type ** tmp;
if (!fs)
return -EINVAL;
if (fs->;next)
return -EBUSY;
tmp = &file_systems;
while (*tmp) {
if (strcmp((*tmp)->;name, fs->;name) == 0)
return -EBUSY;
tmp = &(*tmp)->;next;
} /*遍历file_systems链表*/
*tmp = fs; /*把fs挂到file_systems链表末尾*/
return 0;
}
在系统启动时如果需要把PROC文件系统挂载上来则要根据PROC_FS_TYPE中注册的PROC_READ_SUPER()函数把SUPER BLOCK读入内存，并加入SUPER_BLOCKS链表。对于一般基于硬设备上的文件系统，READ_SUPER函数的操作就是在内存中创建一个新的空SUPER BLOCK，然后从设备上把SUPER BLOCK读入。但对于PROC文件系统，其READ_SUPER操作的内容有所不同，因为PROC文件系统是不存在于任何设备上的，所以PROC_READ_SUPER函数就是在产生一个新的空SUPER_BLOCK之后在内存中锁住该块后直接对其进行修改了。
/* fs/proc/inode.c */
struct super_block *proc_read_super(struct super_block *s,void *data, int silent)
{
struct inode * root_inode;
lock_super(s); /*锁住该super_block*/
s->;s_blocksize = 1024;
s->;s_blocksize_bits = 10;
s->;s_magic = PROC_SUPER_MAGIC;
s->;s_op = &proc_sops;
root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
if (!root_inode)
goto out_no_root;
s->;s_root = d_alloc_root(root_inode, NULL);
if (!s->;s_root)
goto out_no_root;
parse_options(data, &root_inode->;i_uid, &root_inode->;i_gid);
unlock_super(s);
return s;
out_no_root:
printk("proc_read_super: get root inode failed\n";
iput(root_inode);
s->;s_dev = 0;
unlock_super(s);
return NULL;
} |
|
免费注册
楼主: 轩辕砍刀
发表于 2003-04-23 20:27
为了证明网络驱动程序之间有多类似我再简略的trace Intel eepro100 的驱程程序给大家看。不罗唆，马上开始。