struct file
{
union
{
struct list_head fu_list ;
struct rcu_head fu_rcuhead ;
}f_u ;
struct dentry *f_dentry ; /*与文件关联的目录入口（dentry）结构*/
struct vfsmount *f_vfsmnt ;
struct file_operations *f_op ; /*和文件关联的操作*/
atomic_t f_count ;
unsigned int f_flags ; /*文件标志，如O_RDONLY,O_NONBLOCK,O_SYNC*/
mode_t f_mode ; /*文件读/写模式，FMODE_READ和FMODE_WRITE*/
loff_t f_pos ; /*当前读写位置*/
struct fown_struct f_owner ;
unsigned int f_uid,f_gid ;
struct file_ra_state f_ra ;
unsigned long f_version ;
void *f_security ;
/* tty 驱动需要,其他的驱动可能需要*/
void *private_data ; /*文件私有数据*/
#ifdef CONFIG_EPOLL
/*被fs/eventpoll.c使用以便连接所有这个文件的钩子（hooks）*/
struct list_head f_ep_links ;
spinlock_t f_ep_lock ;
#endif
struct address_space *f_mapping ;
};
======================================================================
inode结构体
struct inode
{
...
umode_t i_mode ;/*inode的权限*/
uid_t i_uid ; /*inode拥有者的id*/
gid_t i_gid ; /*inode所属的群组id*/
dev_t i_rdev ; /*如是设备文件，此字段将记录设备的设备号*/
loff_t i_size ; /*inode所代表的文件大小*/
struct timespec i_atime ; /*inode最近一次的存取时间*/
struct timespec i_mtime ; /*inode最近一次的修改时间*/
struct timespec i_ctime ; /*inode的产生时间*/
unsigned long i_blksize ; /*inode 在做I/O时的区块大小 */
unsigned long i_blocks ; /*inode所使用的block数，一个block为512 byte */
struct block_device *i_bdev ;
/*若是块设备，为其对应的block_device结构体指针*/
struct cdev *i_cdev ;
/*若是字符设备，为其对应的cdev结构体指针*/
...
};
========================================================
kobject结构体
struct kobject
{
char *k_name ;
char name[KOBJ_NAME_LEN] ; //对象名称
struct kref kref ; //对象引用计数
struct list_head entry ; //用于挂接该kobject对象到kset链表
struct kobject *parent ; //指向父对象的指针
struct kset *kset ; //所属kset的指针
struct kobj_type *ktype ; //指向对象类型描述符的指针
struct dentry *dentry ; //sysfs文件系统中与该对象对应的文件节点入口
} ;
======================================================
kobj_type结构体
struct kobj_type
{
void (*release)(struct kobject *) ;//release 函数
struct sysfs_ops *sysfs_ops ; //属性操作
struct attribute **default_attrs ; //默认属性
};
=======================================================
sysfs_ops结构体
struct sysfs_ops
{
ssize_t (*show)(struct kobject *,struct attribute *,char *) ;
ssize_t (*store)(struct kobject *,struct attribute *,const char *,size_t) ;
};
=======================================================
kset结构体
struct kset
{
struct subsystem *subsys ; //所在的subsystem的指针
struct kobj_type *ktype ; //指向该kset对象类型描述符的指针
struct list_head list ; //用于连接该kset中所有kobject的链表头
spinlock_t list_lock ;
struct kobject kobj ; //嵌入的kobject
struct kset_uevent_ops *uevent_ops ; //事件操作集
};
=======================================================
kset_uevent_ops结构体
struct kset_uevent_ops
{
int (*filter)(struct kset *kset,struct kobject *kobj); //事件过滤
const char *(*name)(struct kset *kset,struct kobject *kobj) ;
int (*uevent)(struct kset *kset,struct kobject *kobj,char **envp,
int num_envp,char *buffer,int buffer_size) ; //环境变量设置
};
=======================================================
subsystem结构体
struct subsystem
{
struct kset kset ; //内嵌的kset对象
struct rw_semaphore rwsem ;//互斥访问信号量
};
=======================================================
device结构体
struct device
{
struct klist *klist_children ; //设备列表中的孩子列表
struct klist_node knode_parent ; //兄弟节点
struct klist_node knode_driver ; //驱动结点
struct klist_node knode_bus ; //总线结点
struct device *parent ; //指向父设备
struct kobject kobj ; //内嵌一个kobject对象
char bus_id[BUS_ID_SIZE] ; //总线上的位置
struct device_attribute uevent_attr ;
struct semaphore sem ;
struct bus_type *bus ; //总线
struct device_driver *driver ; //使用的驱动s
void *driver_data ; //驱动私有数据
void *platform_data ;//平台特定的数据
void *firmware_data ;//固件特定的数据（如ACPI,BIOS数据）
struct dev_pm_info power ;
u64 *dma_mask ; //dma掩码
u64 coherent_dma_mask ;
struct list_head dma_pools ; //DMA缓冲池
struct dma_coherent_mem *dma_mem;
void (*release)(struct device *dev) ;//释放设备方法
};
===================================================
device_driver结构体
struct device_driver
{
const char *name ; //设备驱动程序的名称
struct bus_type *bus ; //总线
struct completion unloaded ;
struct kobject kobj ; //内嵌的kobject对象
struct klist klist_devices ;
struct klist_node knode_bus ;
struct module *owner ;
int (*probe)(struct device *dev) ; //指向设备探测函数
int (*remove)(struct device *dev) ; //指向设备移除函数
void (*shutdown)(struct device *dev) ;
int (*suspend)(struct device *dev,pm_message_t state) ;
int (*resume)(struct device *dev) ;
};
====================================================
bus_type结构体
struct bus_type
{
const char *name ; //总线类型的名称
struct subsystem subsys ; //与该总线相关的subsystem
struct kset drivers ; //所有与该总线相关的驱动程序集合
struct kset devices ; //所有挂接在该总线上的设备集合
struct klist klist_devices ;
struct klist klist_drivers ;
struct bus_attribute *bus_attrs ;//总线属性
struct device_attribute *dev_attrs ;//设备属性
struct driver_attribute *drv_attrs ;//驱动程序属性
int (*match)(struct device *dev,struct device_driver *drv) ;
int (*uevent)(struct device *dev,char **envp,
int num_envp,char *buffer,int buffer_size) ; //事件
int (*probe)(struct device *dev) ;
int (*remove)(struct device *dev) ;
void (*shutdown)(struct device *dev) ;
int (*suspend)(struct device *dev,pm_message_t state) ;
int (*resume)(struct device *dev) ;
};
===================================================
class结构体
struct class
{
const char *name ; //类名
struct module *owner ;
struct subsystem subsys ; //对应的subsystem
struct list_head children ; //class_device链表
struct list_head interfaces ;//class_interface链表
struct semaphore sem ; //children和interfaces链表锁
struct class_attribute *class_attrs ; //类属性
struct class_device_attribute *class_dev_attrs ; //类设备属性
int (*uevent)(struct class_device *dev,char **envp,
int num_envp,char *buffer,int buffer_size) ; //事件
void (*release)(struct class_device *dev) ;
void (*class_release)(struct class *class) ;
};
============================================
class_device结构体
struct class_device
{
struct list_head node ;
struct kobject kobj ; //内嵌的kobject
struct class *class ; //所属的类
dev_t devt ; //dev_t
struct class_device_attribute *devt_attr ;
struct class_device_attribute uevent_attr ;
struct device *dev ; //如果存在，创建到 /sys/devices相应入口的符号链接
void (*release)(struct class_device *dev) ;
int (*uevent)(struct class_device *dev,char **envp,
int num_envp,char *buffer,int buffer_size) ;
char class_id[BUS_ID_LEN] ; //类标识
};
===============================================
class_interface结构体
struct class_interface
{
struct list_head node ;
struct class *class ; //对应的class
int (*add)(struct class_device *,struct class_interface *) ; //设备加入时触发
void (*remove)(struct class_device *,struct class_interface *) ;//设备移出时触发
};
================================================
总线属性
struct bus_attribute
{
struct attribute attr ;
ssize_t (*show)(struct bus_type *,char *buf) ;
ssize_t (*store)(struct bus_type *,const char *buf,size_t count) ;
};
=================================================
驱动属性
struct driver_attribute
{
struct attribute attr ;
ssize_t (*show)(struct device_driver *,char *buf) ;
ssize_t (*store)(struct device_driver *,const char *buf,size_t count) ;
};
==================================================
类属性
struct class_attribute
{
struct attribute attr ;
ssize_t (*show)(struct class *,char *buf) ;
ssize_t (*store)(struct class *,const char *buf,size_t count) ;
};
===================================================
类设备属性
struct class_device_attribute
{
struct attribute attr ;
ssize_t (*show)(struct class_device *,char *buf) ;
ssize_t (*store)(struct clas_device *,const char *buf,size_t count) ;
};
===================================================
file_operations结构体
struct file_operations
{
struct module *owner ;
//拥有该结构的模块的指针，一般为THIS_MODULES
loff_t (*llseek)(struct file *,loff_t,int) ;
//用来修改文件当前的读写位置
ssize_t (*read)(struct file *,char __user *,size_t,loff_t *) ;
//从设备中同步读取数据
ssize_t (*aio_read)(struct kiocb *,char __user *,size_t,loff_t) ;
//初始化一个异步的读取数据
ssize_t (*write)(struct file *,const char __user *,size_t,loff_t) ;
//向设备发送数据
ssize_t (*aio_write)(struct kiocb *,const char __user*,size_t,loff_t) ;
//初始化一个异步的写入操作
int (*readdir)(struct file *,void *,filldir_t) ;
//仅用于读取目录，对于设备文件，该字段为NULL
unsigned int (*poll)(struct file *,struct poll_table_struct*) ;
//轮询函数，判断当前是否可以进行非阻塞的读取或写入
int (*ioctl)(struct inode *,struct file *,unsigned int,unsigned long) ;
//执行设备IO控制命令
long (*unlocked_ioctl)(struct file *,unsigned int,unsigned long) ;
//不使用BLK文件系统，将使用此种函数指针替代ioctl
long (*compat_ioctl)(struct file *,unsigned int,unsigned long) ;
//在64位系统上，32位的ioctl调用将使用此函数指针替代
int (*mmap)(struct file *,unsigned int,unsigned long) ;
//用于请求将设备内存映射到进程地址空间
int (*open)(struct inode *,struct file *) ;
//打开
int (*flush)(struct file *) ;
int (*release)(struct inode *,struct file *) ;
//关闭
int (*sync)(struct file *,struct dentry *,int datasync);
//刷新待处理的数据
int (*aio_fsync)(struct kiocb *,int datasync) ;
//异步fsync
int (*fasync)(int,struct file *,int) ;
//通知设备FASYNC标志发生变化
int (*lock)(struct file *,int,struct file_lock *) ;
ssize_t (*readv)(struct file *,const struct iovec*,unsigned long,loff_t *) ;
ssize_t (*writev)(struct file *,const struct iovec *,unsigned long,loff_t *) ;
//readv和writev:分散或聚集型的读写操作
ssize_t (*sendfile)(struct file *,lof_t *,size_t,read_actor_t,void*) ;
//通常为NULL
unsigned long (*get_unmapped_area)(struct file *,unsigned long,unsigned long,
unsigned long,unsigned long);
//在进程地址空间找到一个将底层设备中的内存段映射的位置
int (*check_flags)(int) ;
//允许模块检查传递给fcntl(F_SETEL...)通用的标志
int (*dir_notify)(struct file *filp,unsigned long arg) ;
//仅对文件系统有效，驱动程序不必实现
int (*flock)(struct file *,int ,struct file_lock *) ;
};
struct task_struct {
volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
struct thread_info *thread_info;
atomic_t usage;
unsigned long flags; /* per process flags, defined below */
unsigned long ptrace;
int lock_depth; /* BKL lock depth */
#if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
int oncpu;
#endif
int prio, static_prio;
struct list_head run_list;
prio_array_t *array;
unsigned short ioprio;
unsigned long sleep_avg;
unsigned long long timestamp, last_ran;
unsigned long long sched_time; /* sched_clock time spent running */
int activated;
unsigned long policy;
cpumask_t cpus_allowed;
unsigned int time_slice, first_time_slice;
#ifdef CONFIG_SCHEDSTATS
struct sched_info sched_info;
#endif
struct list_head tasks;
/*
* ptrace_list/ptrace_children forms the list of my children
* that were stolen by a ptracer.
*/
struct list_head ptrace_children;
struct list_head ptrace_list;
struct mm_struct *mm, *active_mm;
/* task state */
struct linux_binfmt *binfmt;
long exit_state;
int exit_code, exit_signal;
int pdeath_signal; /* The signal sent when the parent dies */
/* ??? */
unsigned long personality;
unsigned did_exec:1;
pid_t pid;
pid_t tgid;
/*
* pointers to (original) parent process, youngest child, younger sibling,
* older sibling, respectively. (p->father can be replaced with
* p->parent->pid)
*/
struct task_struct *real_parent; /* real parent process (when being debugged) */
struct task_struct *parent; /* parent process */
/*
* children/sibling forms the list of my children plus the
* tasks I'm ptracing.
*/
struct list_head children; /* list of my children */
struct list_head sibling; /* linkage in my parent's children list */
struct task_struct *group_leader; /* threadgroup leader */
/* PID/PID hash table linkage. */
struct pid pids[PIDTYPE_MAX];
struct completion *vfork_done; /* for vfork() */
int __user *set_child_tid; /* CLONE_CHILD_SETTID */
int __user *clear_child_tid; /* CLONE_CHILD_CLEARTID */
unsigned long rt_priority;
cputime_t utime, stime;
unsigned long nvcsw, nivcsw; /* context switch counts */
struct timespec start_time;
/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
unsigned long min_flt, maj_flt;
cputime_t it_prof_expires, it_virt_expires;
unsigned long long it_sched_expires;
struct list_head cpu_timers[3];
/* process credentials */
uid_t uid,euid,suid,fsuid;
gid_t gid,egid,sgid,fsgid;
struct group_info *group_info;
kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
unsigned keep_capabilities:1;
struct user_struct *user;
#ifdef CONFIG_KEYS
struct key *thread_keyring; /* keyring private to this thread */
unsigned char jit_keyring; /* default keyring to attach requested keys to */
#endif
int oomkilladj; /* OOM kill score adjustment (bit shift). */
char comm[TASK_COMM_LEN]; /* executable name excluding path
- access with [gs]et_task_comm (which lock
it with task_lock())
- initialized normally by flush_old_exec */
/* file system info */
int link_count, total_link_count;
/* ipc stuff */
struct sysv_sem sysvsem;
/* CPU-specific state of this task */
struct thread_struct thread;
/* filesystem information */
struct fs_struct *fs;
/* open file information */
struct files_struct *files;
/* namespace */
struct namespace *namespace;
/* signal handlers */
struct signal_struct *signal;
struct sighand_struct *sighand;
sigset_t blocked, real_blocked;
struct sigpending pending;
unsigned long sas_ss_sp;
size_t sas_ss_size;
int (*notifier)(void *priv);
void *notifier_data;
sigset_t *notifier_mask;
void *security;
struct audit_context *audit_context;
seccomp_t seccomp;
/* Thread group tracking */
u32 parent_exec_id;
u32 self_exec_id;
/* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
spinlock_t alloc_lock;
/* Protection of proc_dentry: nesting proc_lock, dcache_lock, write_lock_irq(&tasklist_lock); */
spinlock_t proc_lock;
/* journalling filesystem info */
void *journal_info;
/* VM state */
struct reclaim_state *reclaim_state;
struct dentry *proc_dentry;
struct backing_dev_info *backing_dev_info;
struct io_context *io_context;
unsigned long ptrace_message;
siginfo_t *last_siginfo; /* For ptrace use. */
/*
* current io wait handle: wait queue entry to use for io waits
* If this thread is processing aio, this points at the waitqueue
* inside the currently handled kiocb. It may be NULL (i.e. default
* to a stack based synchronous wait) if its doing sync IO.
*/
wait_queue_t *io_wait;
/* i/o counters(bytes read/written, #syscalls */
u64 rchar, wchar, syscr, syscw;
#if defined(CONFIG_BSD_PROCESS_ACCT)
u64 acct_rss_mem1; /* accumulated rss usage */
u64 acct_vm_mem1; /* accumulated virtual memory usage */
clock_t acct_stimexpd; /* clock_t-converted stime since last update */
#endif
#ifdef CONFIG_NUMA
struct mempolicy *mempolicy;
short il_next;
#endif
#ifdef CONFIG_CPUSETS
struct cpuset *cpuset;
nodemask_t mems_allowed;
int cpuset_mems_generation;
#endif
atomic_t fs_excl; /* holding fs exclusive resources */
};
