linux内核中6个经典C语言函数代码赏析(这段代码片段是内核初始化函数它位于init/main.c文件中负责启动系统)

  (这段代码片段是内核初始化函数它位于 init/main.c 文件中负责启动系统)

https://m.toutiao.com/is/Dhdp7Qw/?= 

在这里，提供一些广受欢迎和被认为是高质量的 Linux 内核代码片段，同时也会解释它们的优点和特点。

1. 内核初始化函数

这段代码片段是内核初始化函数，它位于 init/main.c 文件中，负责启动系统，并执行许多重要的初始化操作。这个函数的优点是它清晰明了，使用了一些高级特性，如 GCC 扩展，它还处理了错误和异常情况。

asmlinkage __visible void __init start_kernel(void){ /* .. code omitted .. */ /* Perform CPU initialization */ smp_prepare_cpus(setup_max_cpus); /* Initialize IRQ subsystem */ init_IRQ(); /* .. code omitted .. */ /* Init memory management */ mem_init(); /* .. code omitted .. */ /* Start init */ kernel_init(); /* .. code omitted .. */}

2. 内存管理函数

这段代码片段是 Linux 内核中的一个内存管理函数，位于 mm/mempolicy.c 文件中。它使用了一些高级技术，如位操作，使代码更加高效和简洁。

int get_mempolicy(int *policy, unsigned long *nodemask,                  unsigned long maxnode, unsigned long addr,                  unsigned long flags){  int ret = 0;  nodemask_t *nodes = NULL;  if (flags & MPOL_F_NODE) {    if (flags & MPOL_F_ADDR) {      ret = -EINVAL;      goto out;    }    if (maxnode >= MAX_NUMNODES) {      ret = -EINVAL;      goto out;    }    if (nodemask != NULL) {      nodes = kmalloc(sizeof(nodemask_t), GFP_KERNEL);      if (nodes == NULL) {        ret = -ENOMEM;        goto out;      }      nodes_clear(*nodes);      *policy = MPOL_BIND;    }  }  /* .. code omitted .. */out:  if (nodes != NULL)    kfree(nodes);  return ret;}

3. 文件系统函数

这段代码片段是 Linux 文件系统中的一个函数，位于 fs/namei.c 文件中。它使用了递归算法，处理了复杂的文件路径，同时也使用了一些高级特性，如位操作和条件编译。

static struct dentry *walk_component(struct nameidata *nd, struct qstr *name, const struct inode *inode, unsigned int flags, const struct path *path){ /* .. code omitted .. */ if (!nd->last_type || (flags & LOOKUP_DIRECTORY)) { if (unlikely(!d_can_lookup(dentry))) { if (!(flags & LOOKUP_DIRECTORY)) return ERR_PTR(-ENOTDIR); return ERR_PTR(-ENOTDIR); } if (unlikely(d_really_is_negative(dentry))) { if (!(flags & LOOKUP_DIRECTORY)) return ERR_PTR(-ENOENT); return ERR_PTR(-ENOENT); } nd->flags &= ~LOOKUP_JUMPED; return dentry; } /* .. code omitted .. */ if (unlikely(d_really_is_negative(dentry))) { nd->flags |= LOOKUP_PARENT; return ERR_PTR(-ENOENT); } /* .. code omitted .. */ if (unlikely(d_is_symlink(dentry))) { /* .. code omitted .. */ return NULL; } /* .. code omitted .. */ if (unlikely(!d_can_lookup(dentry))) return ERR_PTR(-ENOTDIR); if (unlikely(d_really_is_negative(dentry))) return ERR_PTR(-ENOENT); nd->flags &= ~LOOKUP_JUMPED; /* .. code omitted .. */ return dentry;}

4. 系统调用函数

这段代码片段是一个系统调用函数，位于 `
arch/x86/entry/syscalls/syscall_64.c` 文件中，它使用了汇编语言和 C 语言混合编程，实现了 Linux 内核中的系统调用接口。

ENTRY(syscall)/*On syscall entry, interrupts are off and fs points to processkernel_thread_info. We need to save these on the stack so thatwe can later access them in a non-kernel context./pushq %raxpushq %rcxpushq %r11pushq %rdi / syscall number argument must be in register rdi /pushq %rsipushq %rdxmovq %fs, %raxmovq %rax, PER_CPU_VAR(current_task) + TI_threadmovq %rsp, %fs:(TI_stack)/ .. code omitted .. */

5. 进程调度函数

这段代码片段是 Linux 进程调度函数，位于 `kernel/sched/core.c` 文件中。它使用了一些高级技术，如多级反馈队列算法，使 Linux 内核中的进程调度更加高效和公平。

static void __sched schedule(void){ struct task_struct *prev, *next; struct rq *rq; unsigned long long now; s64 delta_exec; int cpu; rcu_note_context_switch(); preempt_disable(); cpu = smp_processor_id(); rq = cpu_rq(cpu); now = rq_clock_task(rq); /* .. code omitted .. */ for (;;) { prev = rq->curr; next = pick_next_task(rq, prev, now); /* .. code omitted .. */ if (likely(prev != next)) { rq->nr_switches++; rq->curr = next; ++*switch_count; prepare_task_switch(rq, prev, next); /* .. code omitted .. */ __schedule(); /* .. code omitted .. */ } /* .. code omitted .. */ }}

6. 内核同步函数

这段代码片段是一个 Linux 内核中的同步函数，位于 `kernel/locking/lockdep.c` 文件中。它使用了一些高级技术，如递归算法和自旋锁机制，来确保内核中的同步和互斥性。

int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,int trylock, int read, int check){  struct task_struct *curr = current;    struct held_lock *this;  struct lock_class *class;  int depth = 0, ret = 0;  u64 curr_chain_key = curr->curr_chain_key;  u64 chain_key = 0;  unsigned long flags;  unsigned int state;  struct held_lock prev_hlock;  / ... code omitted ... /  class = lock->class;  this = find_held_lock(class, curr);  if (this) {    depth = this->nest_lock;    if (read)      this->read++;    else      this->check++;    goto out;  }  / ... code omitted ... /  if (!trylock) {    if (read) {      / ... code omitted ... /      if (!lock_acquire(&class->dep_map, subclass, 0, 1, 0, NULL, RET_IP)) {        / ... code omitted ... /        goto out_release;    	}      / ... code omitted ... /      } else {        / ... code omitted ... /        if (!lock_acquire(&class->dep_map, subclass, 0, 0, 0, NULL, RET_IP)) {        / ... code omitted ... /        goto out_release;      }    / ... code omitted ... /  	}  }  / ... code omitted ... */  out:  return ret;}

这段代码实现了内核中的锁机制，用于保护共享资源不被多个任务同时访问。其中，函数中的 `lockdep_map` 结构体表示锁的相关信息，`held_lock` 结构体表示锁的占有情况，`lock_class` 结构体表示锁的类型和属性。函数通过调用 `lock_acquire` 和 `lock_release` 函数来获取和释放锁，保证了内核中的同步和互斥性。