第一题
操作系统文件的内部表示有文件索引节点表（inode）、文件表(file)、用户文件描述符表(files)，请你基于Linux4.19.X源代码，找出其中对应的数据结构定义，并描述一下这三者之间的关系，举例说明。
什么是文件索引节点表
- 文件索引节点表（inode）源码如下
/include/linux/fs.h
struct inode {
umode_t i_mode; /*文件类型和属性，ls查看的结果，比如drwx------*/
unsigned short i_opflags;
kuid_t i_uid; /*文件宿主id*/
kgid_t i_gid; /*groupid：宿主所在的组id*/
unsigned int i_flags; /* 文件系统标志 */
#ifdef CONFIG_FS_POSIX_ACL
struct posix_acl *i_acl;
struct posix_acl *i_default_acl;
#endif
const struct inode_operations *i_op; /* 索引节点操作函数 */
struct super_block *i_sb; /* 相关的超级块 */
struct address_space *i_mapping; /* 相关的地址映射 */
#ifdef CONFIG_SECURITY
void *i_security;
#endif
unsigned long i_ino; /* 节点号 */
union {
const unsigned int i_nlink; /*链接数：有多少个其他的文件夹链接到这里*/
unsigned int __i_nlink;
};
dev_t i_rdev;
loff_t i_size;
struct timespec64 i_atime; /*文件上一次打开的时间*/
struct timespec64 i_mtime; /* 最后修改时间 */
struct timespec64 i_ctime; /*文件的inode上一次变动的时间*/
spinlock_t i_lock; /* 互斥锁 */
unsigned short i_bytes; /* 使用的字节数 */
u8 i_blkbits; /* 以位为单位的块大小 */
u8 i_write_hint;
blkcnt_t i_blocks; /* 文件的块数 */
#ifdef __NEED_I_SIZE_ORDERED
seqcount_t i_size_seqcount;
#endif
/* Misc */
unsigned long i_state;
struct rw_semaphore i_rwsem;
unsigned long dirtied_when; /* 第一次修改 */
unsigned long dirtied_time_when;
struct hlist_node i_hash; /* 散列表，用于快速查找inode */
struct list_head i_io_list; /* 支持设备IO列表 */
#ifdef CONFIG_CGROUP_WRITEBACK
struct bdi_writeback *i_wb; /* the associated cgroup wb */
/* foreign inode detection, see wbc_detach_inode() */
int i_wb_frn_winner;
u16 i_wb_frn_avg_time;
u16 i_wb_frn_history;
#endif
struct list_head i_lru; /* inode LRU list */
struct list_head i_sb_list;
struct list_head i_wb_list; /* backing dev writeback list */
union {
struct hlist_head i_dentry;
struct rcu_head i_rcu;
};
atomic64_t i_version;
atomic64_t i_sequence; /* see futex */
atomic_t i_count; /* 引用计数 */
atomic_t i_dio_count;
atomic_t i_writecount;
#ifdef CONFIG_IMA
atomic_t i_readcount; /* struct files open RO */
#endif
const struct file_operations *i_fop; /* 缺省的索引节点操作 */
struct file_lock_context *i_flctx;
struct address_space i_data; /* 设备地址映射 */
struct list_head i_devices;
union {
struct pipe_inode_info *i_pipe;
struct block_device *i_bdev;
struct cdev *i_cdev;
char *i_link;
unsigned i_dir_seq;
};
__u32 i_generation; /* 索引节点版本号 */
#ifdef CONFIG_FSNOTIFY
__u32 i_fsnotify_mask; /* all events this inode cares about */
struct fsnotify_mark_connector __rcu *i_fsnotify_marks;
#endif
#if IS_ENABLED(CONFIG_FS_ENCRYPTION)
struct fscrypt_info *i_crypt_info;
#endif
void *i_private; /* fs or device private pointer */
} __randomize_layout;
索引节点对象存储了文件的相关信息，代表了存储设备上的一个实际的物理文件。当一个 文件首次被访问时，内核会在内存中组装相应的索引节点对象，以便向内核提供对一个文件进行操作时所必需的全部信息；保存的其实是实际的数据的一些信息，这些信息称为“元数据”(也就是对文件属性的描述)。例如：文件大小，设备标识符，用户标识符，用户组标识符，文件模式，扩展属性，文件读取或修改的时间戳，链接数量，指向存储该内容的磁盘区块的指针，文件分类等等。这些信息一部分存储在磁盘特定位置，另外一部分是在加载时动态填充的。
什么是文件表（文件对象）
- flie结构代码
/*
*位置：include/linux/fs.h
*功能：
*保存打开文件的信息，状态和操作方法等。
*/
struct file {
union {
struct llist_node fu_llist; /*文件对象链表*/
struct rcu_head fu_rcuhead;//RCU(Read-Copy Update)是Linux内核中新的锁机制
} f_u;
struct path f_path; /* 包含dentry和mnt两个成员，用于确定文件路径*/
struct inode *f_inode; /* 文件的inode节点 */
/* 【文件操作】
* 文件操作结构体，实施具体的文件操作，不同类型的文件通过实现不一样的f_op来
* 实现文件操作的差异化，比如操作GPIO/往proc系统写数据等。
* 这个结构也定义在include/linux/fs.h
*/
const struct file_operations *f_op; /*文件操作表*/
/*
* Protects f_ep_links, f_flags.
* Must not be taken from IRQ context.
*/
spinlock_t f_lock;
enum rw_hint f_write_hint;
atomic_long_t f_count;/* 打开文件的引用计数，如果有多个文件指针指向它，就会增加 */
/* 文件打开时的flag，即open()的flag参数 */
unsigned int f_flags;
fmode_t f_mode;//读写模式：open的mod_t mode参数
struct mutex f_pos_lock;
loff_t f_pos;//当前文件指针位置
struct fown_struct f_owner;
const struct cred *f_cred;
struct file_ra_state f_ra;
u64 f_version;//记录文件的版本号，每次使用之后递增
#ifdef CONFIG_SECURITY
void *f_security;
#endif
/* needed for tty driver, and maybe others */
void *private_data;
#ifdef CONFIG_EPOLL
/* Used by fs/eventpoll.c to link all the hooks to this file */
struct list_head f_ep_links;
struct list_head f_tfile_llink;
#endif /* #ifdef CONFIG_EPOLL */
struct address_space *f_mapping;
errseq_t f_wb_err;
} __randomize_layout
__attribute__((aligned(4))); /* lest something weird decides that 2 is OK */
文件对象是已打开的文件在内存中的表示，主要用于建立进程和磁盘上的文件的对应关系。它由sys_open() 现场创建，由sys_close()销毁。文件对象和物理文件的关系有点像进程和程序的关系一样。当我们站在用户空间来看待VFS，我们像是只需与文件对象打交道，而无须关心超级块，索引节点或目录项。因为多个进程可以同时打开和操作同一个文件，所以同一个文件也可能存在多个对应的文件对象。文件对象仅仅在进程观点上代表已经打开的文件，它反过来指向目录项对象。一个文件对应的文件对象可能不是唯一的，但是其对应的索引节点和目录项对象是唯一的。
什么是fd文件描述符
- fd的结构
/*
*位置：include/linux/fdtable.h
*功能：保存打开文件描述符管理信息
*@max_fds:可打开文件上限
*@fd:指向当前的fd_array元素。
*/
struct fdtable {
unsigned int max_fds; /* 可打开文件上限 */
struct file __rcu **fd; /* 指向文件描述符 */
unsigned long *close_on_exec;
unsigned long *open_fds;
unsigned long *full_fds_bits;
struct rcu_head rcu;
};
当进程打开文件或创建新文件时，内核会返回一个文件描述符（非负整数），用来指向被打开的文件，所有执行I/O操作的系统调用（read、write）都会通过文件描述符。
文件描述符可以理解为进程文件描述表这个表的索引，或者把文件描述表看做一个数组的话，文件描述符可以看做是数组的下标。当需要进行I/O操作的时候，会传入fd作为参数，先从进程文件描述符表查找该fd对应的那个条目，取出对应的那个已经打开的文件的句柄，根据文件句柄指向，去系统fd表中查找到该文件指向的inode，从而定位到该文件的真正位置，从而进行I/O操作。
三者之间的关系
当我们通open() 尝试去打开一个文件的时候，linux内部是如何找到对应的存储在硬件上的该文件的数据：
首先由task_struct作为一个进程结构，该进程发出了打开文件的指令（或者动作），生产一个文件描述符，系统根据这个文件描述符在files_struct中找到对应的file文件。fd作为文件描述符，文件作为数据的载体，我们可以将它们理解为密码和保险柜之间的关系，第一打开文件就是相当初始化时设置密码（建立起了密码和保险柜的联系），当我们以后再需要拿取保险柜中的东西时，只需要通过第一次设置的密码就可以对保险柜进程操作。
file对象中包含一个指针，指向dentry对象。dentry对象代表一个独立的文件路径，如果一个文件路径被打开多次，那么会建立多个file对象，但它们都指向同一个dentry对象。dentry对象中又包含一个指向inode对象的指针。inode对象代表一个独立文件。因为存在硬链接与符号链接，因此不同的dentry 对象可以指向相同的inode对象.inode 对象包含了最终对文件进行操作所需的所有信息，如文件系统类型、文件的操作方法、文件的权限、访问日期等。
第二题
基于Linux4.19.X源代码，分析一下操作系统进程数据结构（task_struct）中的进程标识、进程树关系、进程间通信机制等相关成员变量的定义及涵义。
task_struct结构体是Linux下的进程控制块PCB，PCB里包含着一个进程的所有信息。其源代码如下，并在相应的成员变量中注释了其定义以及用处：
struct task_struct {
#ifdef CONFIG_THREAD_INFO_IN_TASK
/*
* For reasons of header soup (see current_thread_info()), this
* must be the first element of task_struct.
*/
struct thread_info thread_info;
#endif
/*
* -1 不可运行, 0 可以运行, >0 停止:
* TASK_RUNNING: 可运行
* TASK_INTERRUPTIBLE: 可中断的等待状态
* TASK_ZOMBIE: 僵死
* TASK_STOPPED: 暂停
* TASK_DEAD：回收所有资源状态
* 进程执行时，它会根据具体情况改变状态。进程状态是进程调度和对换的依据。
*/
volatile long state;
/*
* This begins the randomizable portion of task_struct. Only
* scheduling-critical items should be added above here.
*/
randomized_struct_fields_start
/* stack: 进程内核栈，进程通过alloc_thread_info函数分配它的内核栈
通过free_thread_info函数释放所分配的内核栈 */
void *stack;
/* usage: 进程描述符使用计数，被置为2时，表示进程描述符正在被使用而且其相应的进程处于活动状态 */
atomic_t usage;
/* flags是进程当前的状态标志(注意和运行状态区分)，Per task flags (PF_*), defined further below: */
unsigned int flags;
unsigned int ptrace;
/* on_cpu：在SMP上帮助实现无加锁的进程切换(unlocked context switches) */
#ifdef CONFIG_SMP
struct llist_node wake_entry;
int on_cpu;
#ifdef CONFIG_THREAD_INFO_IN_TASK
/* Current CPU: */
unsigned int cpu;
#endif
unsigned int wakee_flips;
unsigned long wakee_flip_decay_ts;
struct task_struct *last_wakee;
/*
* recent_used_cpu is initially set as the last CPU used by a task
* that wakes affine another task. Waker/wakee relationships can
* push tasks around a CPU where each wakeup moves to the next one.
* Tracking a recently used CPU allows a quick search for a recently
* used CPU that may be idle.
*/
int recent_used_cpu;
int wake_cpu;
#endif
int on_rq;
int prio;/* 在某些情况下内核需要暂时提高进程的优先级 */
int static_prio;/* 静态优先级是进程"启动"时分配的优先级 */
int normal_prio;/* 基于进程的"静态优先级"和"调度策略"计算出的优先级 */
unsigned int rt_priority; /* 表示实时进程的优先级 */
const struct sched_class *sched_class;/* 该进程所属的调度类 */
struct sched_entity se;
/*
* se：用于普通进程的调用实体
* 调度器不限于调度进程，还可以处理更大的实体，这可以实现"组调度"，可用的CPU时间可以
* 首先在一般的进程组之间分配，接下来分配的时间在组内再次分配
* 这种一般性要求调度器不直接操作进程，而是处理"可调度实体"，一个实体有sched_entity的一个实例标识
* 在最简单的情况下，调度在各个进程上执行，由于调度器设计为处理可调度的实体
* 在调度器看来各个进程也必须也像这样的实体
* 因此se在task_struct中内嵌了一个sched_entity实例，调度器可据此操作各个task_struct
*/
struct sched_rt_entity rt;/* 用于实时进程的调用实体 */
#ifdef CONFIG_CGROUP_SCHED
struct task_group *sched_task_group;
#endif
struct sched_dl_entity dl;
#ifdef CONFIG_PREEMPT_NOTIFIERS
/* List of struct preempt_notifier: */
struct hlist_head preempt_notifiers;
#endif
#ifdef CONFIG_BLK_DEV_IO_TRACE
unsigned int btrace_seq;
#endif
unsigned int policy;
/*
* policy表示进程的调度策略，目前主要有以下五种：
1) #define SCHED_NORMAL 用于普通进程，它们通过完全公平调度器来处理
2) #define SCHED_FIFO 先来先服务调度，由实时调度类处理
3) #define SCHED_RR 时间片轮转调度，由实时调度类处理
4) #define SCHED_BATCH 用于非交互、CPU使用密集的批处理进程，通过完全公平调度器来处理。
5) #define SCHED_IDLE 可用于次要的进程，其相对权重总是最小的，也通过完全公平调度器来处理。
要注意的是，只有root用户能通过sched_setscheduler()系统调用来改变调度策略
*/
int nr_cpus_allowed;
cpumask_t cpus_allowed;
#ifdef CONFIG_PREEMPT_RCU
int rcu_read_lock_nesting;
union rcu_special rcu_read_unlock_special;
struct list_head rcu_node_entry;
struct rcu_node *rcu_blocked_node;
#endif /* #ifdef CONFIG_PREEMPT_RCU */
#ifdef CONFIG_TASKS_RCU
unsigned long rcu_tasks_nvcsw;
u8 rcu_tasks_holdout;
u8 rcu_tasks_idx;
int rcu_tasks_idle_cpu;
struct list_head rcu_tasks_holdout_list;
#endif /* #ifdef CONFIG_TASKS_RCU */
struct sched_info sched_info;
/* 用于调度器统计进程的运行信息 */
struct list_head tasks;
/* 通过list_head将当前进程的task_struct串联进内核的进程列表中，构建；linux进程链表 */
#ifdef CONFIG_SMP
struct plist_node pushable_tasks;
struct rb_node pushable_dl_tasks;
#endif
struct mm_struct *mm;
struct mm_struct *active_mm;
/* Per-thread vma caching: */
struct vmacache vmacache;
#ifdef SPLIT_RSS_COUNTING
struct task_rss_stat rss_stat;
#endif
int exit_state;/* 进程退出状态码 */
int exit_code;
int exit_signal;
/* The signal sent when the parent dies: */
int pdeath_signal;
/* JOBCTL_*, siglock protected: */
unsigned long jobctl;
/* Used for emulating ABI behavior of previous Linux versions: */
unsigned int personality;
/* Scheduler bits, serialized by scheduler locks: */
unsigned sched_reset_on_fork:1;
unsigned sched_contributes_to_load:1;
unsigned sched_migrated:1;
unsigned sched_remote_wakeup:1;
/* Force alignment to the next boundary: */
unsigned :0;
/* in_execve用于通知LSM是否被do_execve()函数所调用
Bit to tell LSMs we're in execve(): */
unsigned in_execve:1;
unsigned in_iowait:1;
#ifndef TIF_RESTORE_SIGMASK
unsigned restore_sigmask:1;
#endif
#ifdef CONFIG_MEMCG
unsigned in_user_fault:1;
#ifdef CONFIG_MEMCG_KMEM
unsigned memcg_kmem_skip_account:1;
#endif
#endif
#ifdef CONFIG_COMPAT_BRK
unsigned brk_randomized:1;
#endif
#ifdef CONFIG_CGROUPS
/* disallow userland-initiated cgroup migration */
unsigned no_cgroup_migration:1;
#endif
#ifdef CONFIG_BLK_CGROUP
/* to be used once the psi infrastructure lands upstream. */
unsigned use_memdelay:1;
#endif
unsigned long atomic_flags; /* Flags requiring atomic access. */
struct restart_block restart_block;
pid_t pid; /* 进程标识符(PID)，全局唯一的标识了某个进程 */
pid_t tgid;
/*
* 在Linux系统中，一个线程组中的所有线程使用和该线程组的领头线程(该组
* 中的第一个轻量级进程)相同的PID，并被存放在tgid成员中。
* 只有线程组的领头线程的pid成员才会被设置为与tgid相同的值。
* 注意，getpid()系统调用返回的是当前进程的tgid值而不是pid值。
*/
#ifdef CONFIG_STACKPROTECTOR
/* Canary value for the -fstack-protector GCC feature: */
unsigned long stack_canary;
#endif
/*
* Pointers to the (original) parent process, youngest child, younger sibling,
* older sibling, respectively. (p->father can be replaced with
* p->real_parent->pid)
*/
/* 指向其父进程，如果创建它的父进程不再存在，则指向PID为1的init进程 */
struct task_struct __rcu *real_parent;
/* 指向其父进程，当它终止时，必须向它的父进程发送信号。通常与real_parent相同 */
struct task_struct __rcu *parent;
/*
* Children/sibling form the list of natural children:
*/
struct list_head children;/* 子进程链表 */
struct list_head sibling; /* 用于把当前进程插入到兄弟链表中(连接到父进程的子进程链表(兄弟链表)) */
struct task_struct *group_leader;/* 指向其所在进程组的领头进程 */
/*
* 'ptraced' is the list of tasks this task is using ptrace() on.
*
* This includes both natural children and PTRACE_ATTACH targets.
* 'ptrace_entry' is this task's link on the p->parent->ptraced list.
*/
struct list_head ptraced;
struct list_head ptrace_entry;
/* PID/PID hash table linkage. */
struct pid *thread_pid;
struct hlist_node pid_links[PIDTYPE_MAX];
struct list_head thread_group;
struct list_head thread_node;
struct completion *vfork_done;
/* CLONE_CHILD_SETTID: */
int __user *set_child_tid;
/* CLONE_CHILD_CLEARTID: */
int __user *clear_child_tid;
u64 utime;
u64 stime;
#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
u64 utimescaled;
u64 stimescaled;
#endif
u64 gtime;
struct prev_cputime prev_cputime;
#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
struct vtime vtime;
#endif
#ifdef CONFIG_NO_HZ_FULL
atomic_t tick_dep_mask;
#endif
/* Context switch counts: */
unsigned long nvcsw;
unsigned long nivcsw;
/* Monotonic time in nsecs: */
u64 start_time;/* 进程创建时间 */
/* Boot based time in nsecs: */
u64 real_start_time;/* 进程时间，还包含了进程睡眠时间 */
/* 缺页统计 */
unsigned long min_flt;
unsigned long maj_flt;
#ifdef CONFIG_POSIX_TIMERS
struct task_cputime cputime_expires;
struct list_head cpu_timers[3];
#endif
/* Process credentials: */
/* Tracer's credentials at attach: */
const struct cred __rcu *ptracer_cred;
/* Objective and real subjective task credentials (COW): */
const struct cred __rcu *real_cred;
/* Effective (overridable) subjective task credentials (COW): */
const struct cred __rcu *cred;
/*
* executable name, excluding path.
*
* - normally initialized setup_new_exec()
* - access it with [gs]et_task_comm()
* - lock it with task_lock()
*/
char comm[TASK_COMM_LEN];
struct nameidata *nameidata;
#ifdef CONFIG_SYSVIPC /* 进程通信(SYSVIPC) */
struct sysv_sem sysvsem;
struct sysv_shm sysvshm;
#endif
#ifdef CONFIG_DETECT_HUNG_TASK
unsigned long last_switch_count;
unsigned long last_switch_time;
#endif
/* 文件 */
/* Filesystem information: */
struct fs_struct *fs;/* 用来表示进程与文件系统的联系，包括当前目录和根目录 */
/* Open file information: */
struct files_struct *files;/* 表示进程当前打开的文件 */
/* Namespaces: */
struct nsproxy *nsproxy;
/* Signal handlers: */
struct signal_struct *signal;/* 指向进程的信号描述符 */
struct sighand_struct *sighand;/* 指向进程的信号处理程序描述符 */
sigset_t blocked;
sigset_t real_blocked;
/* Restored if set_restore_sigmask() was used: */
sigset_t saved_sigmask;
struct sigpending pending;
unsigned long sas_ss_sp;
size_t sas_ss_size;
unsigned int sas_ss_flags;
struct callback_head *task_works;
struct audit_context *audit_context;
#ifdef CONFIG_AUDITSYSCALL
kuid_t loginuid;
unsigned int sessionid;
#endif
struct seccomp seccomp;
/* Thread group tracking: */
u64 parent_exec_id;
u64 self_exec_id;
/* Protection against (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed, mempolicy: */
spinlock_t alloc_lock;
/* Protection of the PI data structures: */
raw_spinlock_t pi_lock;
struct wake_q_node wake_q;
#ifdef CONFIG_RT_MUTEXES
/* PI waiters blocked on a rt_mutex held by this task: */
struct rb_root_cached pi_waiters;
/* Updated under owner's pi_lock and rq lock */
struct task_struct *pi_top_task;
/* Deadlock detection and priority inheritance handling: */
struct rt_mutex_waiter *pi_blocked_on;
#endif
#ifdef CONFIG_DEBUG_MUTEXES
/* Mutex deadlock detection: */
struct mutex_waiter *blocked_on; /* 死锁检测 */
#endif
#ifdef CONFIG_TRACE_IRQFLAGS
unsigned int irq_events;
unsigned long hardirq_enable_ip;
unsigned long hardirq_disable_ip;
unsigned int hardirq_enable_event;
unsigned int hardirq_disable_event;
int hardirqs_enabled;
int hardirq_context;
unsigned long softirq_disable_ip;
unsigned long softirq_enable_ip;
unsigned int softirq_disable_event;
unsigned int softirq_enable_event;
int softirqs_enabled;
int softirq_context;
#endif
#ifdef CONFIG_LOCKDEP
# define MAX_LOCK_DEPTH 48UL
u64 curr_chain_key;
int lockdep_depth;
unsigned int lockdep_recursion;
struct held_lock held_locks[MAX_LOCK_DEPTH];
#endif
#ifdef CONFIG_UBSAN
unsigned int in_ubsan;
#endif
/* Journalling filesystem info: */
void *journal_info;
/* Stacked block device info: */
struct bio_list *bio_list;
#ifdef CONFIG_BLOCK
/* Stack plugging: */
struct blk_plug *plug;
#endif
/* VM state: */
struct reclaim_state *reclaim_state;
struct backing_dev_info *backing_dev_info;
struct io_context *io_context;
/* Ptrace state: */
unsigned long ptrace_message;
siginfo_t *last_siginfo;
struct task_io_accounting ioac;
#ifdef CONFIG_TASK_XACCT
/* Accumulated RSS usage: */
u64 acct_rss_mem1;
/* Accumulated virtual memory usage: */
u64 acct_vm_mem1;
/* stime + utime since last update: */
u64 acct_timexpd;
#endif
#ifdef CONFIG_CPUSETS
/* Protected by ->alloc_lock: */
nodemask_t mems_allowed;
/* Seqence number to catch updates: */
seqcount_t mems_allowed_seq;
int cpuset_mem_spread_rotor;
int cpuset_slab_spread_rotor;
#endif
#ifdef CONFIG_CGROUPS
/* Control Group info protected by css_set_lock: */
struct css_set __rcu *cgroups;
/* cg_list protected by css_set_lock and tsk->alloc_lock: */
struct list_head cg_list;
#endif
#ifdef CONFIG_INTEL_RDT
u32 closid;
u32 rmid;
#endif
#ifdef CONFIG_FUTEX
struct robust_list_head __user *robust_list;
#ifdef CONFIG_COMPAT
struct compat_robust_list_head __user *compat_robust_list;
#endif
struct list_head pi_state_list;
struct futex_pi_state *pi_state_cache;
struct mutex futex_exit_mutex;
unsigned int futex_state;
#endif
#ifdef CONFIG_PERF_EVENTS
struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
struct mutex perf_event_mutex;
struct list_head perf_event_list;
#endif
#ifdef CONFIG_DEBUG_PREEMPT
unsigned long preempt_disable_ip;
#endif
#ifdef CONFIG_NUMA
/* Protected by alloc_lock: */
struct mempolicy *mempolicy;
short il_prev;
short pref_node_fork;
#endif
#ifdef CONFIG_NUMA_BALANCING
int numa_scan_seq;
unsigned int numa_scan_period;
unsigned int numa_scan_period_max;
int numa_preferred_nid;
unsigned long numa_migrate_retry;
/* Migration stamp: */
u64 node_stamp;
u64 last_task_numa_placement;
u64 last_sum_exec_runtime;
struct callback_head numa_work;
struct numa_group __rcu *numa_group;
unsigned long *numa_faults;
unsigned long total_numa_faults;
unsigned long numa_faults_locality[3];
unsigned long numa_pages_migrated;
#endif /* CONFIG_NUMA_BALANCING */
#ifdef CONFIG_RSEQ
struct rseq __user *rseq;
u32 rseq_len;
u32 rseq_sig;
/*
* RmW on rseq_event_mask must be performed atomically
* with respect to preemption.
*/
unsigned long rseq_event_mask;
#endif
struct tlbflush_unmap_batch tlb_ubc;
struct rcu_head rcu;
/* Cache last used pipe for splice(): */
struct pipe_inode_info *splice_pipe;
struct page_frag task_frag;
#ifdef CONFIG_TASK_DELAY_ACCT
struct task_delay_info *delays;
#endif
#ifdef CONFIG_FAULT_INJECTION
int make_it_fail;
unsigned int fail_nth;
#endif
/*
* When (nr_dirtied >= nr_dirtied_pause), it's time to call
* balance_dirty_pages() for a dirty throttling pause:
*/
int nr_dirtied;
int nr_dirtied_pause;
/* Start of a write-and-pause period: */
unsigned long dirty_paused_when;
#ifdef CONFIG_LATENCYTOP
int latency_record_count;
struct latency_record latency_record[LT_SAVECOUNT];
#endif
/*
* Time slack values; these are used to round up poll() and
* select() etc timeout values. These are in nanoseconds.
*/
u64 timer_slack_ns;
u64 default_timer_slack_ns;
#ifdef CONFIG_KASAN
unsigned int kasan_depth;
#endif
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
/* Index of current stored address in ret_stack: */
int curr_ret_stack;
int curr_ret_depth;
/* Stack of return addresses for return function tracing: */
struct ftrace_ret_stack *ret_stack;
/* Timestamp for last schedule: */
unsigned long long ftrace_timestamp;
/*
* Number of functions that haven't been traced
* because of depth overrun:
*/
atomic_t trace_overrun;
/* Pause tracing: */
atomic_t tracing_graph_pause;
#endif
#ifdef CONFIG_TRACING
/* State flags for use by tracers: */
unsigned long trace;
/* Bitmask and counter of trace recursion: */
unsigned long trace_recursion;
#endif /* CONFIG_TRACING */
#ifdef CONFIG_KCOV
/* Coverage collection mode enabled for this task (0 if disabled): */
unsigned int kcov_mode;
/* Size of the kcov_area: */
unsigned int kcov_size;
/* Buffer for coverage collection: */
void *kcov_area;
/* KCOV descriptor wired with this task or NULL: */
struct kcov *kcov;
#endif
#ifdef CONFIG_MEMCG
struct mem_cgroup *memcg_in_oom;
gfp_t memcg_oom_gfp_mask;
int memcg_oom_order;
/* Number of pages to reclaim on returning to userland: */
unsigned int memcg_nr_pages_over_high;
/* Used by memcontrol for targeted memcg charge: */
struct mem_cgroup *active_memcg;
#endif
#ifdef CONFIG_BLK_CGROUP
struct request_queue *throttle_queue;
#endif
#ifdef CONFIG_UPROBES
struct uprobe_task *utask;
#endif
#if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
unsigned int sequential_io;
unsigned int sequential_io_avg;
#endif
#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
unsigned long task_state_change;
#endif
int pagefault_disabled;
#ifdef CONFIG_MMU
struct task_struct *oom_reaper_list;
#endif
#ifdef CONFIG_VMAP_STACK
struct vm_struct *stack_vm_area;
#endif
#ifdef CONFIG_THREAD_INFO_IN_TASK
/* A live task holds one reference: */
atomic_t stack_refcount;
#endif
#ifdef CONFIG_LIVEPATCH
int patch_state;
#endif
#ifdef CONFIG_SECURITY
void *security;
#endif
randomized_struct_fields_end
/* CPU-specific state of this task: */
struct thread_struct thread;
};
task_struct的整体结构
进程树
任何一个进程都是从父进程 fork 来的，任何一个进程都有父进程。所以，整个进程就是一颗进程树。
/* 指向其父进程，如果创建它的父进程不再存在，则指向PID为1的init进程 */
struct task_struct __rcu *real_parent;
/* 指向其父进程，当它终止时，必须向它的父进程发送信号。通常与real_parent相同 */
struct task_struct __rcu *parent;
struct list_head children;/* 子进程链表 */
struct list_head sibling;
/* 用于把当前进程插入到兄弟链表中(连接到父进程的子进程链表(兄弟链表)) */
struct task_struct *group_leader;/* 指向其所在进程组的领头进程 */
关系如图所示
第三题
基于Linux4.19.X源代码，分析一下操作系统的字符设备和块设备相关的数据结构，以及内核与设备驱动程序接口、系统调用与设备驱动程序接口的定义
字符设备及操作
- 提供连续的数据流，应用程序可以顺序读取，通常不支持随机存取。相反，此类设备支持按字节自/字符来读写数据。举例来说，百键盘、串口、调制解调器都是典型的字符设备。
struct cdev {
struct kobject kobj;/* 设备管理机制，由内核决定 */
struct module *owner;
const struct file_operations *ops;/*文件操作结构体*/
struct list_head list;
dev_t dev; /* 设备号 */
unsigned int count;/* 支持的设备 */
} __randomize_layout;
void cdev_init(struct cdev *, const struct file_operations *);
/*初始化cdev的成员，并且建立cdev与file_operation的连接*/
struct cdev *cdev_alloc(void);
/*动态申请一个cdev的内存空间*/
void cdev_put(struct cdev *p);
int cdev_add(struct cdev *, dev_t, unsigned);
/*添加一个cdev，完成字符的注册*/
void cdev_del(struct cdev *);
/*删除一个cdev，完成字符的注销*/
void cd_forget(struct inode *);
/* 设备驱动程序接口 */
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
int (*iterate) (struct file *, struct dir_context *);
int (*iterate_shared) (struct file *, struct dir_context *);
__poll_t (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
unsigned long mmap_supported_flags;
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **, void **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
unsigned (*mmap_capabilities)(struct file *);
#endif
ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
loff_t, size_t, unsigned int);
int (*clone_file_range)(struct file *, loff_t, struct file *, loff_t,
u64);
int (*dedupe_file_range)(struct file *, loff_t, struct file *, loff_t,
u64);
int (*fadvise)(struct file *, loff_t, loff_t, int);
} __randomize_layout;
字符设备、字符设备驱动与用户三者之间的关系
- 使用cdev结构体来描述字符设备;
- Linux通过 cdev_init( ) 建立cdev与 file_operations之间的连接，通过 cdev_add( ) 向系统添加一个cdev以完成注册;
- 系统通过cdev成员函数file_operations来定义字符设备驱动提供给VFS的接口函数，如常见的open()、read()、write()等;
- 用户通过Linux系统调用，如open( )、read( )、write( )，来“调用”file_operations来定义字符设备驱动提供给VFS的接口函数;
块设备
- 应用程序可以随机访问设备数据，程序可自行确定读取数据的位置。硬盘、软盘、CD-ROM驱动器和闪存都是典型度的块设备，应用程序可以寻址磁盘上的任何位置，并由此读取数据。此外，数据的读写知只能以块(通常是512B)的倍数进行。与字符设备不同，块设备并不支持基于字符的寻址。
struct block_device {
dev_t bd_dev; /* not a kdev_t - it's a search key */
int bd_openers;
struct inode * bd_inode; /* will die */
struct super_block * bd_super;
struct mutex bd_mutex; /* open/close mutex */
void * bd_claiming;
void * bd_holder;
int bd_holders;
bool bd_write_holder;
#ifdef CONFIG_SYSFS
struct list_head bd_holder_disks;
#endif
struct block_device * bd_contains;
unsigned bd_block_size;
u8 bd_partno;
struct hd_struct * bd_part;
/* number of times partitions within this device have been opened. */
unsigned bd_part_count;
int bd_invalidated;
struct gendisk * bd_disk;/* 该块设备所在的gendisk结构体 */
struct request_queue * bd_queue;
struct backing_dev_info *bd_bdi;
struct list_head bd_list;
unsigned long bd_private;
/* The counter of freeze processes */
int bd_fsfreeze_count;
/* Mutex for freeze */
struct mutex bd_fsfreeze_mutex;
} __randomize_layout;
可以看到块驱动中是没有read、write函数，而是通过申请request，然后用bio结构体描述具体储存信息，这些结构体都是gendisk结构体的成员。
gendisk结构体：
在Linux中，驱动对块设备的输入或输出(I/O)操作，都会向块设备发出一个请求，在驱动中用request结构体描述。但对于一些磁盘设备而言请求的速度很慢，这时候内核就提供一种队列的机制把这些I/O请求添加到队列中（即：请求队列），在驱动中用request_queue结构体描述。在向块设备提交这些请求前内核会先执行请求的合并和排序预操作，以提高访问的效率，然后再由内核中的I/O调度程序子系统来负责提交I/O请求，调度程序将磁盘资源分配给系统中所有挂起的块I/O请求，其工作是管理块设备的请求队列，决定队列中的请求的排列顺序以及什么时候派发请求到设备。
/* linux 内核使用 gendisk 结构体来描述一个磁盘设备*/
struct gendisk {
int major; /* 磁盘设备的主设备号 */
int first_minor; /* 磁盘的第一个次设备号 */
int minors; /* 磁盘的次设备号数量，即磁盘的分区数量 */
char disk_name[DISK_NAME_LEN]; /* name of major driver */
char *(*devnode)(struct gendisk *gd, umode_t *mode);
unsigned int events; /* supported events */
unsigned int async_events; /* async events, subset of all */
/* 磁盘对应的分区表 */
struct disk_part_tbl __rcu *part_tbl;
struct hd_struct part0;
const struct block_device_operations *fops; /* 块设备操作集 */
struct request_queue *queue; /* 磁盘对应的请求队列 每个磁盘都要分配一个request_queue*/
void *private_data; /*私有数据*/
int flags;
struct device *driverfs_dev; // FIXME: remove
struct kobject *slave_dir;
struct timer_rand_state *random;
atomic_t sync_io; /* RAID */
struct disk_events *ev;
#ifdef CONFIG_BLK_DEV_INTEGRITY
struct blk_integrity *integrity;
#endif
int node_id;
};
/* 块设备操作集 */
struct block_device_operations {
int (*open) (struct block_device *, fmode_t);/* 打开 */
void (*release) (struct gendisk *, fmode_t);/* 释放 */
int (*rw_page)(struct block_device *, sector_t, struct page *, unsigned int);
int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
/* ioctl 函数用于块设备的 I/O 控制 */
int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
unsigned int (*check_events) (struct gendisk *disk,
unsigned int clearing);
/* ->media_changed() is DEPRECATED, use ->check_events() instead */
int (*media_changed) (struct gendisk *);
void (*unlock_native_capacity) (struct gendisk *);
int (*revalidate_disk) (struct gendisk *);
int (*getgeo)(struct block_device *, struct hd_geometry *);
/* getgeo 函数用于获取磁盘信息，包括磁头、柱面和扇区等信息 */
void (*swap_slot_free_notify) (struct block_device *, unsigned long);
struct module *owner;
const struct pr_ops *pr_ops;
};
bio结构体：
由通用块层(Generic Block Layer)负责维持一个I/O请求在上层文件系统与底层物理磁盘之间的关系。在通用块层中，通常用一个bio结构体来对应一个I/O请求。
内核将对块设备的读写都发送到请求队列request_queue中，request_queue中是大量的request(（请求结构体），而request又包含了bio,bio保存了读写相关数据，比如从块设备的哪个地址开始读取、读取的数据长度，读取到哪里，如果是写的话还包括要写入的数据等。
内核、系统调用与设备驱动程序接口的定义
系统调用
计算机的各种硬件资源是有限的，为了更好的管理这些资源，用户进程是不允许直接操作的，所有对这些资源的访问都必须由操作系统控制。为此操作系统为用户态运行的进程与硬件设备之间进行交互提供了一组接口，这组接口就是所谓的系统调用。
系统调用实质上就是函数调用，只不过调用的是系统函数，处于内核态而已。 用户在调用系统调用时会向内核传递一个系统调用号，然后系统调用处理程序通过此号从系统调用表中找到相应的内核函数执行，最后返回。
系统调用最终还是会由内核函数完成，那么为什么不直接调用内核函数呢？
这是因为用户空间的程序无法直接执行内核代码，因为内核驻留在受保护的地址空间上，不允许用户进程在内核地址空间上读写。所以，应用程序会以某种方式通知系统，告诉内核需要执行一个函数调用，这种通知机制是靠软中断来实现的，通过引发一个异常来促使系统切换到内核态去执行异常处理程序。此时的异常处理程序就是所谓的系统调用处理程序。
内核
内核是操作系统的关键组件。 它借助进程间通信和系统调用，在硬件级别上充当应用程序和数据处理之间的桥梁。
每当将操作系统加载到内存中时，首先，将加载内核并将其保留在那里，直到操作系统关闭。 内核负责处理低级任务，例如任务管理，内存管理，风险管理等。
设备驱动程序接口
系统调用是操作系统内核与应用程序之间的接口，设备驱动程序则是操作系统内核与机器硬件的接口。几乎所有的系统操作最终映射到物理设备，除了CPU、内存 和少数其它设备，所有的设备控制操作都由该设备特殊的可执行代码实现，此代码就是设备驱动程序。
操作系统内核需要访问两类主要设备:字符设备和块设备。与此相关主要有两类设备驱动程序，字符设备驱动程序和块设备驱动程序。
通常Linux驱动程序接口分为如下四层：
- 应用程序进程与内核的接口；
- 内核与文件系统的接口；
- 文件系统与设备驱动程序的接口；
- 设备驱动程序与硬件设备的接口。
- 驱动程序文件操作数据结构
扫一扫
4663
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
