「Kernel」Linux kernel lab 浅浅跟随

diff --git a/tools/labs/qemu/Makefile b/tools/labs/qemu/Makefile
index e9ee4ec1b..6e10ac6f0 100644
--- a/tools/labs/qemu/Makefile
+++ b/tools/labs/qemu/Makefile
@@ -135,7 +135,7 @@ rootfs: $(YOCTO_ROOTFS)
   printf '%s\n' '#!/bin/sh' '/bin/login -f root' > rootfs/sbin/rootlogin
   chmod +x rootfs/sbin/rootlogin
   mkdir -p rootfs/home/root/skels
-  echo "//10.0.2.1/skels /home/root/skels cifs port=4450,guest,user=dummy 0 0" >> rootfs/etc/fstab
+  echo "//172.31.2.1/skels /home/root/skels cifs port=4450,guest,user=dummy 0 0" >> rootfs/etc/fstab
   echo "hvc0:12345:respawn:/sbin/getty 115200 hvc0" >> rootfs/etc/inittab

 $(YOCTO_ROOTFS):
diff --git a/tools/labs/qemu/create_net.sh b/tools/labs/qemu/create_net.sh
index c97b6fa0a..f803ed1e4 100755
--- a/tools/labs/qemu/create_net.sh
+++ b/tools/labs/qemu/create_net.sh
@@ -18,7 +18,7 @@ case "$device" in
         subnet=172.30.0
         ;;
     "lkt-tap-smbd")
-        subnet=10.0.2
+        subnet=172.31.2
       ;;
     *)
         echo "Unknown device" 1>&2
diff --git a/tools/labs/qemu/run-qemu.sh b/tools/labs/qemu/run-qemu.sh
index 9938ec18e..abd245be1 100755
--- a/tools/labs/qemu/run-qemu.sh
+++ b/tools/labs/qemu/run-qemu.sh
@@ -24,7 +24,7 @@ case "$mode" in
       ;;
     gui)
       # QEMU_DISPLAY = sdl, gtk, ...
-      qemu_display="-display ${QEMU_DISPLAY:-"sdl"}"
+      qemu_display="-display ${QEMU_DISPLAY:-"gtk"}"
       linux_console=""
       ;;
     checker)
@@ -56,13 +56,13 @@ linux_loglevel=${LINUX_LOGLEVEL:-"15"}
 linux_term=${LINUX_TERM:-"TERM=xterm"}
 linux_addcmdline=${LINUX_ADD_CMDLINE:-""}

-linux_cmdline=${LINUX_CMDLINE:-"root=/dev/cifs rw ip=dhcp cifsroot=//10.0.2.1/rootfs,port=4450,guest,user=dummy $linux_console loglevel=$linux_loglevel pci=noacpi $linux_term $linux_addcmdline"}
+linux_cmdline=${LINUX_CMDLINE:-"root=/dev/cifs rw ip=dhcp cifsroot=//172.31.2.1/rootfs,port=4450,guest,user=dummy $linux_console loglevel=$linux_loglevel pci=noacpi $linux_term $linux_addcmdline"}

 user=$(id -un)

 cat << EOF > "$SAMBA_DIR/smbd.conf"
 [global]
-    interfaces = 10.0.2.1
+    interfaces = 172.31.2.1
     smb ports = 4450
     private dir = $SAMBA_DIR
     bind interfaces only = yes

{
  "clangd.arguments": [
    // highlight-next-line
    "--compile-commands-dir=/linux"
  ]
}

[
  {
    "arguments": [
      "clang",
      "-c",
      "-Wp,-MMD,scripts/mod/.empty.o.d",
      "-nostdinc",
      "-isystem",
      "/usr/lib/llvm-10/lib/clang/10.0.0/include",
      "-I./arch/x86/include",
      "-I./arch/x86/include/generated",
      "-I./include",
      "-I./arch/x86/include/uapi",
      "-I./arch/x86/include/generated/uapi",
      "-I./include/uapi",
      "-I./include/generated/uapi",
      "-include",
      "./include/linux/kconfig.h",
      "-include",
      "./include/linux/compiler_types.h",
      "-D__KERNEL__",
      "-Qunused-arguments",
      "-fmacro-prefix-map=./=",
      "-Wall",
      "-Wundef",
      "-Werror=strict-prototypes",
      "-Wno-trigraphs",
      "-fno-strict-aliasing",
      "-fno-common",
      "-fshort-wchar",
      "-fno-PIE",
      "-Werror=implicit-function-declaration",
      "-Werror=implicit-int",
      "-Werror=return-type",
      "-Wno-format-security",
      "-std=gnu89",
      "-no-integrated-as",
      "-Werror=unknown-warning-option",
      "-mno-sse",
      "-mno-mmx",
      "-mno-sse2",
      "-mno-3dnow",
      "-mno-avx",
      "-m32",
      "-msoft-float",
      "-mregparm=3",
      "-freg-struct-return",
      "-fno-pic",
      "-mstack-alignment=4",
      "-march=i686",
      "-Wa,-mtune=generic32",
      "-ffreestanding",
      "-Wno-sign-compare",
      "-fno-asynchronous-unwind-tables",
      "-mretpoline-external-thunk",
      "-fno-delete-null-pointer-checks",
      "-Wno-address-of-packed-member",
      "-O2",
      "-Wframe-larger-than=1024",
      "-fstack-protector-strong",
      "-Wno-format-invalid-specifier",
      "-Wno-gnu",
      "-mno-global-merge",
      "-Wno-unused-const-variable",
      "-fno-omit-frame-pointer",
      "-fno-optimize-sibling-calls",
      "-g",
      "-gdwarf-4",
      "-Wdeclaration-after-statement",
      "-Wvla",
      "-Wno-pointer-sign",
      "-Wno-array-bounds",
      "-fno-strict-overflow",
      "-fno-stack-check",
      "-Werror=date-time",
      "-Werror=incompatible-pointer-types",
      "-fcf-protection=none",
      "-Wno-initializer-overrides",
      "-Wno-format",
      "-Wno-sign-compare",
      "-Wno-format-zero-length",
      "-Wno-tautological-constant-out-of-range-compare",
      "-DKBUILD_MODFILE=\"scripts/mod/empty\"",
      "-DKBUILD_BASENAME=\"empty\"",
      "-DKBUILD_MODNAME=\"empty\"",
      "-o",
      "scripts/mod/empty.o",
      "scripts/mod/empty.c"
    ],
    "directory": "/linux",
    "file": "scripts/mod/empty.c"
  }
]

{
  "clangd.arguments": [
    // highlight-next-line
    "--compile-commands-dir=/linux/tools/lab"
  ]
}

/* Each module must use one module_init(). */
#define module_init(initfn)          \
  static inline initcall_t __maybe_unused __inittest(void)    \
  { return initfn; }          \
  int init_module(void) __copy(initfn)      \
    __attribute__((alias(#initfn)));    \
  ___ADDRESSABLE(init_module, __initdata);

/* This is only required if you want to be unloadable. */
#define module_exit(exitfn)          \
  static inline exitcall_t __maybe_unused __exittest(void)    \
  { return exitfn; }          \
  void cleanup_module(void) __copy(exitfn)    \
    __attribute__((alias(#exitfn)));    \
  ___ADDRESSABLE(cleanup_module, __exitdata);

#endif

static bool __read_mostly ignore_loglevel;

static bool suppress_message_printing(int level)
{
  return (level >= console_loglevel && !ignore_loglevel);
}

/*
 * Page fault error code bits:
 *
 *   bit 0 ==   0: no page found  1: protection fault
 *   bit 1 ==   0: read access    1: write access
 *   bit 2 ==   0: kernel-mode access  1: user-mode access
 *   bit 3 ==        1: use of reserved bit detected
 *   bit 4 ==        1: fault was an instruction fetch
 *   bit 5 ==        1: protection keys block access
 *   bit 6 ==        1: shadow stack access fault
 *   bit 15 ==        1: SGX MMU page-fault
 *   bit 31 ==        1: fault was due to RMP violation
 */
enum x86_pf_error_code {
  X86_PF_PROT  =    BIT(0),
  X86_PF_WRITE  =    BIT(1),
  X86_PF_USER  =    BIT(2),
  X86_PF_RSVD  =    BIT(3),
  X86_PF_INSTR  =    BIT(4),
  X86_PF_PK  =    BIT(5),
  X86_PF_SHSTK  =    BIT(6),
  X86_PF_SGX  =    BIT(15),
  X86_PF_RMP  =    BIT(31),
};

/**
 * module_param - typesafe helper for a module/cmdline parameter
 * @name: the variable to alter, and exposed parameter name.
 * @type: the type of the parameter
 * @perm: visibility in sysfs.
 *
 * @name becomes the module parameter, or (prefixed by KBUILD_MODNAME and a
 * ".") the kernel commandline parameter.  Note that - is changed to _, so
 * the user can use "foo-bar=1" even for variable "foo_bar".
 *
 * @perm is 0 if the variable is not to appear in sysfs, or 0444
 * for world-readable, 0644 for root-writable, etc.  Note that if it
 * is writable, you may need to use kernel_param_lock() around
 * accesses (esp. charp, which can be kfreed when it changes).
 *
 * The @type is simply pasted to refer to a param_ops_##type and a
 * param_check_##type: for convenience many standard types are provided but
 * you can create your own by defining those variables.
 *
 * Standard types are:
 *  byte, hexint, short, ushort, int, uint, long, ulong
 *  charp: a character pointer
 *  bool: a bool, values 0/1, y/n, Y/N.
 *  invbool: the above, only sense-reversed (N = true).
 */
#define module_param(name, type, perm)        \
  module_param_named(name, name, type, perm)

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
/* TODO: add missing headers */

MODULE_DESCRIPTION("List current processes");
MODULE_AUTHOR("Kernel Hacker");
MODULE_LICENSE("GPL");

static int my_proc_init(void)
{
        struct task_struct *p;

        /* TODO: print current process pid and its name */

        /* TODO: print the pid and name of all processes */

        return 0;
}

static void my_proc_exit(void)
{
        /* TODO: print current process pid and name */
}

module_init(my_proc_init);
module_exit(my_proc_exit);

static int my_proc_init(void)
{
    // hightlight-start
        struct task_struct *p;
        p = current;
        pr_info("[I] Current PID: %d\n", p->pid);
        pr_info("            Name: %s\n", p->comm);
        /* TODO: print current process pid and its name */
    // highlight-end

        /* TODO: print the pid and name of all processes */

        return 0;
}

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/sched/signal.h>
/* TODO: add missing headers */

MODULE_DESCRIPTION("List current processes");
MODULE_AUTHOR("Kernel Hacker");
MODULE_LICENSE("GPL");

static int my_proc_init(void)
{
        struct task_struct *p;
        p = current;
        pr_info("[I] Current PID: %d\n", p->pid);
        pr_info("            Name: %s\n", p->comm);
        /* TODO: print current process pid and its name */

        for_each_process(p) {
            pr_info("[I] Current PID: %d\n", p->pid);
            pr_info("            Name: %s\n", p->comm);
        }
        /* TODO: print the pid and name of all processes */

        return 0;
}

static void my_proc_exit(void)
{
        struct task_struct* p = current;
        pr_info("[I] Current PID: %d\n", p->pid);
        pr_info("            Name: %s\n", p->comm);
}

module_init(my_proc_init);
module_exit(my_proc_exit);

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm_types.h>

MODULE_AUTHOR("Muel Nova");
MODULE_DESCRIPTION("SHOW MEM");
MODULE_LICENSE("GPL");

static int mem_init(void) {
    struct task_struct* p = current;
    struct mm_struct* mm = p->mm;
    struct vm_area_struct* vma = mm->mmap;
    while (vma) {
        printk("0x%lx - 0x%lx\n", vma->vm_start, vma->vm_end);
        vma = vma->vm_next;
    }
    return 0;
}

mem = kmalloc(4096 * sizeof(*mem), GFP_KERNEL);

  spin_lock(&lock);

  set_current_state(TASK_INTERRUPTIBLE);
  /* Try to sleep for 5 seconds. */
  schedule_timeout(5 * HZ);

  spin_unlock(&lock);

#include <linux/jiffies.h>

static struct task_info *task_info_alloc(int pid)
{
  struct task_info *ti;

  /* TODO 1: allocated and initialize a task_info struct */
  ti = kmalloc(sizeof(struct task_info), GFP_KERNEL);
    if (ti == NULL)
    return NULL;
  ti->pid = pid;
  ti->timestamp = jiffies;

  return ti;
}

static int memory_init(void)
{
  struct task_struct* cur = get_current();
  ti1 = task_info_alloc(cur->pid);
  ti2 = task_info_alloc(cur->parent->pid);
  ti3 = task_info_alloc(next_task(cur)->pid);
  ti4 = task_info_alloc(next_task(next_task(cur))->pid);

  /* TODO 2: call task_info_alloc for current pid */

  /* TODO 2: call task_info_alloc for parent PID */

  /* TODO 2: call task_info alloc for next process PID */

  /* TODO 2: call task_info_alloc for next process of the next process */

  return 0;
}

static void memory_exit(void)
{

  /* TODO 3: print ti* field values */
  printk("[task_info] Current:\n\tPID:%d\n\ttimestamp:%lu\n\n", ti1->pid, ti1->timestamp);
  printk("[task_info] Parent:\n\tPID:%d\n\ttimestamp:%lu\n\n", ti2->pid, ti2->timestamp);
  printk("[task_info] Next:\n\tPID:%d\n\ttimestamp:%lu\n\n", ti3->pid, ti3->timestamp);
  printk("[task_info] Next(Next):\n\tPID:%d\n\ttimestamp:%lu\n", ti4->pid, ti4->timestamp);

  /* TODO 4: free ti* structures */
  kfree(ti1);
  kfree(ti2);
  kfree(ti3);
  kfree(ti4);
}

static void task_info_add_to_list(int pid)
{
  struct task_info *ti;

  /* TODO 1: Allocate task_info and add it to list */
  ti = task_info_alloc(pid);
  if (ti == NULL)
    return;
  list_add(&ti->list, &head);
}

static void task_info_purge_list(void)
{
  struct list_head *p, *q;
  struct task_info *ti;

  /* TODO 2: Iterate over the list and delete all elements */
  list_for_each_safe(p, q, &head) {
    ti = list_entry(p, struct task_info, list);
    list_del(p);
    kfree(ti);
  }
}

static struct task_info *task_info_find_pid(int pid)
{
  struct list_head *p;
  struct task_info *ti;

  /* TODO 1: Look for pid and return task_info or NULL if not found */
  list_for_each(p, &head) {
    ti = list_entry(p, struct task_info, list);
    if (ti->pid == pid)
      return ti;
  }

  return NULL;
}

static void list_full_exit(void)
{
  struct task_info *ti;

  /* TODO 2: Ensure that at least one task is not deleted */

  ti = list_entry(head.next, struct task_info, list);

  atomic_set(&ti->count, 5);
  task_info_print_list("after removing expired");
  task_info_remove_expired();
  task_info_print_list("after removing expired");
  task_info_purge_list();
}

/*
 * Linux API lab
 *
 * list-sync.c - Synchronize access to a list
 */

#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/sched/signal.h>

MODULE_DESCRIPTION("Full list processing with synchronization");
MODULE_AUTHOR("SO2");
MODULE_LICENSE("GPL");

struct task_info {
  pid_t pid;
  unsigned long timestamp;
  atomic_t count;
  struct list_head list;
};

static struct list_head head;

/* TODO 1: you can use either a spinlock or rwlock, define it here */
// 写互斥，读并行，没毛病哦老铁们。
DEFINE_RWLOCK(lock);

static struct task_info *task_info_alloc(int pid)
{
  struct task_info *ti;

  ti = kmalloc(sizeof(*ti), GFP_KERNEL);
  if (ti == NULL)
    return NULL;
  ti->pid = pid;
  ti->timestamp = jiffies;
  atomic_set(&ti->count, 0);

  return ti;
}

static struct task_info *task_info_find_pid(int pid)
{
  struct list_head *p;
  struct task_info *ti;

  list_for_each(p, &head) {
    ti = list_entry(p, struct task_info, list);
    if (ti->pid == pid) {
      return ti;
    }
  }

  return NULL;
}

static void task_info_add_to_list(int pid)
{
  struct task_info *ti;

  /* TODO 1: Protect list, is this read or write access? */
    // find_pid 会读，那肯定拿读锁
  read_lock(&lock);
  ti = task_info_find_pid(pid);
  if (ti != NULL) {
         // 注意这里，如果找到了那就先释放读锁，准备写。等所有读都解锁了在写。
    read_unlock(&lock);
         write_lock(&lock);
    ti->timestamp = jiffies;
    atomic_inc(&ti->count);
         write_unlock(&lock);
    /* TODO: Guess why this comment was added  here */

    return;
  }
  read_unlock(&lock);

  /* TODO 1: critical section ends here */

  ti = task_info_alloc(pid);
  // 这里注意，alloc 因为有 GFP_KERNEL FLAG，因此是可抢占的，我们不能在上一句里面拿锁！！
  write_lock(&lock);
  /* TODO 1: protect list access, is this read or write access? */
  list_add(&ti->list, &head);
  write_unlock(&lock);
  /* TODO 1: critical section ends here */
}

void task_info_add_for_current(void)
{
  task_info_add_to_list(current->pid);
  task_info_add_to_list(current->parent->pid);
  task_info_add_to_list(next_task(current)->pid);
  task_info_add_to_list(next_task(next_task(current))->pid);
}
/* TODO 2: Export the kernel symbol */
EXPORT_SYMBOL(task_info_add_for_current);

void task_info_print_list(const char *msg)
{
  struct list_head *p;
  struct task_info *ti;

  pr_info("%s: [ ", msg);

  /* TODO 1: Protect list, is this read or write access? */
    // 这个没必要写在循环里，拿锁贵的
  read_lock(&lock);
  list_for_each(p, &head) {

    ti = list_entry(p, struct task_info, list);
    pr_info("(%d, %lu) ", ti->pid, ti->timestamp);

  }
    read_unlock(&lock);

  /* TODO 1: Critical section ends here */
  pr_info("]\n");
}
/* TODO 2: Export the kernel symbol */
EXPORT_SYMBOL(task_info_print_list);

void task_info_remove_expired(void)
{
  struct list_head *p, *q;
  struct task_info *ti;

  /* TODO 1: Protect list, is this read or write access? */
    // 这里 list_del 是写操作，我们可以直接拿写锁，不需要再拿读锁读完再拿写锁了
  write_lock(&lock);
  list_for_each_safe(p, q, &head) {
    ti = list_entry(p, struct task_info, list);
    if (jiffies - ti->timestamp > 3 * HZ && atomic_read(&ti->count) < 5) {
      list_del(p);
      kfree(ti);
    }
  }
  write_unlock(&lock);
  /* TODO 1: Critical section ends here */
}
/* TODO 2: Export the kernel symbol */
EXPORT_SYMBOL(task_info_remove_expired);

static void task_info_purge_list(void)
{
  struct list_head *p, *q;
  struct task_info *ti;

  /* TODO 1: Protect list, is this read or write access? */
    // 写操作
  write_lock(&lock);
  list_for_each_safe(p, q, &head) {
    ti = list_entry(p, struct task_info, list);
    list_del(p);
    kfree(ti);
  }
  write_unlock(&lock);
  /* TODO 1: Critical sections ends here */
}

static int list_sync_init(void)
{
  INIT_LIST_HEAD(&head);

  task_info_add_for_current();
  task_info_print_list("after first add");

  set_current_state(TASK_INTERRUPTIBLE);
  schedule_timeout(5 * HZ);

  return 0;
}

static void list_sync_exit(void)
{
  struct task_info *ti;

  ti = list_entry(head.prev, struct task_info, list);
  atomic_set(&ti->count, 10);

  task_info_remove_expired();
  task_info_print_list("after removing expired");
  task_info_purge_list();
}

module_init(list_sync_init);
module_exit(list_sync_exit);