c语言函数大全及详解，c语言函数大全及详解_pdf百度

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

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