高质量 Linux 内核代码片段

1万 · 2023-6-2 16:32

在这里，提供一些广受欢迎和被认为是高质量的 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 .. */

1万 · 2023-6-2 16:32

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 process
kernel_thread_info. We need to save these on the stack so that
we can later access them in a non-kernel context.
/
pushq %rax
pushq %rcx
pushq %r11
pushq %rdi / syscall number argument must be in register rdi /
pushq %rsi
pushq %rdx
movq %fs, %rax
movq %rax, PER_CPU_VAR(current_task) + TI_thread
movq %rsp, %fs:(TI_stack)
/ .. code omitted .. */

1万 · 2023-6-2 16:32

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` 函数来获取和释放锁，保证了内核中的同步和互斥性。

只看该作者 · 2023-6-6 18:09

Linux内核写的都很棒啊，是我写不出来的代码