Linux 内核设计与实现4

// include/linux/mm.h
struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);

struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
               struct vm_area_struct **pprev);

static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr);

#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags,
           int fd, off_t offset);

// include/linux/mm.h
static inline unsigned long do_mmap(struct file *file, unsigned long addr,
  unsigned long len, unsigned long prot,
  unsigned long flag, unsigned long offset)
{
  unsigned long ret = -EINVAL;
  if ((offset + PAGE_ALIGN(len)) < offset)
    goto out;
  if (!(offset & ~PAGE_MASK))
    ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
out:
  return ret;
}

#include <sys/mman.h>

int munmap(void *addr, size_t length);

// include/linux/mm.h
int do_munmap(struct mm_struct *, unsigned long, size_t);

// mm/nommu.c
int do_munmap(struct mm_struct *mm, unsigned long start, size_t len)
{
  struct vm_area_struct *vma;
  struct rb_node *rb;
  unsigned long end = start + len;
  int ret;

  kenter(",%lx,%zx", start, len);

  if (len == 0)
    return -EINVAL;

  /* find the first potentially overlapping VMA */
  vma = find_vma(mm, start);
  if (!vma) {
    static int limit = 0;
    if (limit < 5) {
      printk(KERN_WARNING
             "munmap of memory not mmapped by process %d"
             " (%s): 0x%lx-0x%lx\n",
             current->pid, current->comm,
             start, start + len - 1);
      limit++;
    }
    return -EINVAL;
  }

  /* we're allowed to split an anonymous VMA but not a file-backed one */
  if (vma->vm_file) {
    do {
      if (start > vma->vm_start) {
        kleave(" = -EINVAL [miss]");
        return -EINVAL;
      }
      if (end == vma->vm_end)
        goto erase_whole_vma;
      rb = rb_next(&vma->vm_rb);
      vma = rb_entry(rb, struct vm_area_struct, vm_rb);
    } while (rb);
    kleave(" = -EINVAL [split file]");
    return -EINVAL;
  } else {
    /* the chunk must be a subset of the VMA found */
    if (start == vma->vm_start && end == vma->vm_end)
      goto erase_whole_vma;
    if (start < vma->vm_start || end > vma->vm_end) {
      kleave(" = -EINVAL [superset]");
      return -EINVAL;
    }
    if (start & ~PAGE_MASK) {
      kleave(" = -EINVAL [unaligned start]");
      return -EINVAL;
    }
    if (end != vma->vm_end && end & ~PAGE_MASK) {
      kleave(" = -EINVAL [unaligned split]");
      return -EINVAL;
    }
    if (start != vma->vm_start && end != vma->vm_end) {
      ret = split_vma(mm, vma, start, 1);
      if (ret < 0) {
        kleave(" = %d [split]", ret);
        return ret;
      }
    }
    return shrink_vma(mm, vma, start, end);
  }

erase_whole_vma:
  delete_vma_from_mm(vma);
  delete_vma(mm, vma);
  kleave(" = 0");
  return 0;
}
EXPORT_SYMBOL(do_munmap);

// include/linux/fs.h
struct address_space {
  struct inode    *host;    /* owner: inode, block_device */
  struct radix_tree_root  page_tree;  /* radix tree of all pages */
  spinlock_t    tree_lock;  /* and lock protecting it */
  unsigned int    i_mmap_writable;/* count VM_SHARED mappings */
  struct prio_tree_root i_mmap;   /* tree of private and shared mappings */
  struct list_head  i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
  spinlock_t    i_mmap_lock;  /* protect tree, count, list */
  unsigned int    truncate_count; /* Cover race condition with truncate */
  unsigned long   nrpages;  /* number of total pages */
  pgoff_t     writeback_index;/* writeback starts here */
  const struct address_space_operations *a_ops; /* methods */
  unsigned long   flags;    /* error bits/gfp mask */
  struct backing_dev_info *backing_dev_info; /* device readahead, etc */
  spinlock_t    private_lock; /* for use by the address_space */
  struct list_head  private_list; /* ditto */
  struct address_space  *assoc_mapping; /* ditto */
} __attribute__((aligned(sizeof(long))));

// include/linux/fs.h
struct address_space_operations {
  int (*writepage)(struct page *page, struct writeback_control *wbc);
  int (*readpage)(struct file *, struct page *);
  void (*sync_page)(struct page *);

  /* Write back some dirty pages from this mapping. */
  int (*writepages)(struct address_space *, struct writeback_control *);

  /* Set a page dirty.  Return true if this dirtied it */
  int (*set_page_dirty)(struct page *page);

  int (*readpages)(struct file *filp, struct address_space *mapping,
      struct list_head *pages, unsigned nr_pages);

  int (*write_begin)(struct file *, struct address_space *mapping,
        loff_t pos, unsigned len, unsigned flags,
        struct page **pagep, void **fsdata);
  int (*write_end)(struct file *, struct address_space *mapping,
        loff_t pos, unsigned len, unsigned copied,
        struct page *page, void *fsdata);

  /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
  sector_t (*bmap)(struct address_space *, sector_t);
  void (*invalidatepage) (struct page *, unsigned long);
  int (*releasepage) (struct page *, gfp_t);
  ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
      loff_t offset, unsigned long nr_segs);
  int (*get_xip_mem)(struct address_space *, pgoff_t, int,
            void **, unsigned long *);
  /* migrate the contents of a page to the specified target */
  int (*migratepage) (struct address_space *,
      struct page *, struct page *);
  int (*launder_page) (struct page *);
  int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
          unsigned long);
  int (*error_remove_page)(struct address_space *, struct page *);
};

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

static int hello_init(void) {
    printk(KERN_ALERT "I bear a charmed life.\n");
    return 0;
}

static void hello_exit(void) {
    printk(KERN_ALERT "Out, out, brief candle!\n");
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Shakespeare");
MODULE_DESCRIPTION("A Hello, World Module");

obj-m += hello/

obj-$(CONFIG_HELLO) += hello/

obj-$(CONFIG_HELLO) += hello.o

obj-m := hello.o

obj-m := hello.o              # 要生成的模块名      
# hello-objs:= a.o b.o          # 生成这个模块名所需要的目标文件

# KDIR := /lib/modules/`uname -r`/build
KDIR := /home/liuqz/learnLinux/linux-4.15.18
PWD := $(shell pwd)

default:
  make -C $(KDIR) M=$(PWD) modules

clean:
  rm -rf *.o *.o.cmd *.ko *.mod.c .tmp_versions

# 安装模块
insmod hello.ko

# 卸载模块
rmmod hello.ko

module_param(name, type, perm);
// 示例
static int nbr = 10;
module_param(nbr, int, S_IRUGO);

sudo insmod module_name.ko nbr=4

# 查看信息
dmesg | tail -6

int get_pirate_beard_color(struct pirate *p) {
  return p->beard.color;
}
EXPORT_SYMBOL(get_pirate_beard_color);

// 导出符号仅对 GPL 兼容的模块可见
// EXPORT_SYMBOL_GPL(get_pirate_beard_color);

// include/linux/kobject.h
struct kobject {
  const char    *name;
  struct list_head  entry;
  struct kobject    *parent;
  struct kset   *kset;
  struct kobj_type  *ktype;
  struct sysfs_dirent *sd;
  struct kref   kref;
  unsigned int state_initialized:1;
  unsigned int state_in_sysfs:1;
  unsigned int state_add_uevent_sent:1;
  unsigned int state_remove_uevent_sent:1;
  unsigned int uevent_suppress:1;
};

// include/linux/kobject.h
struct kobj_type {
  void (*release)(struct kobject *kobj);
  const struct sysfs_ops *sysfs_ops;
  struct attribute **default_attrs;
};

// include/linux/kobject.h
/**
 * struct kset - a set of kobjects of a specific type, belonging to a specific subsystem.
 *
 * A kset defines a group of kobjects.  They can be individually
 * different "types" but overall these kobjects all want to be grouped
 * together and operated on in the same manner.  ksets are used to
 * define the attribute callbacks and other common events that happen to
 * a kobject.
 *
 * @list: the list of all kobjects for this kset
 * @list_lock: a lock for iterating over the kobjects
 * @kobj: the embedded kobject for this kset (recursion, isn't it fun...)
 * @uevent_ops: the set of uevent operations for this kset.  These are
 * called whenever a kobject has something happen to it so that the kset
 * can add new environment variables, or filter out the uevents if so
 * desired.
 */
struct kset {
  struct list_head list;
  spinlock_t list_lock;
  struct kobject kobj;
  const struct kset_uevent_ops *uevent_ops;
};

void kobject_init(struct kobject *kobj, struct kobj_type *ktype);

memset (kobj, 0, sizeof (*kobj));

// lib/kobject.c
void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
{
  char *err_str;

  if (!kobj) {
    err_str = "invalid kobject pointer!";
    goto error;
  }
  if (!ktype) {
    err_str = "must have a ktype to be initialized properly!\n";
    goto error;
  }
  if (kobj->state_initialized) {
    /* do not error out as sometimes we can recover */
    printk(KERN_ERR "kobject (%p): tried to init an initialized "
           "object, something is seriously wrong.\n", kobj);
    dump_stack();
  }

  kobject_init_internal(kobj);
  kobj->ktype = ktype;
  return;

error:
  printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
  dump_stack();
}
EXPORT_SYMBOL(kobject_init);

static void kobject_init_internal(struct kobject *kobj)
{
  if (!kobj)
    return;
  kref_init(&kobj->kref);
  INIT_LIST_HEAD(&kobj->entry);
  kobj->state_in_sysfs = 0;
  kobj->state_add_uevent_sent = 0;
  kobj->state_remove_uevent_sent = 0;
  kobj->state_initialized = 1;
}

void kref_set(struct kref *kref, int num)
{
  atomic_set(&kref->refcount, num);
  smp_mb();
}

/**
 * kref_init - initialize object.
 * @kref: object in question.
 */
void kref_init(struct kref *kref)
{
  kref_set(kref, 1);
}

static inline void INIT_LIST_HEAD(struct list_head *list)
{
  list->next = list;
  list->prev = list;
}

// include/linux/kref.h
struct kref {
  atomic_t refcount;
};

void kref_set(struct kref *kref, int num);
void kref_init(struct kref *kref);
void kref_get(struct kref *kref);
int kref_put(struct kref *kref, void (*release) (struct kref *kref));

// lib/kref.c
void kref_set(struct kref *kref, int num)
{
  atomic_set(&kref->refcount, num);
  smp_mb();
}

void kref_init(struct kref *kref)
{
  kref_set(kref, 1);
}

void kref_get(struct kref *kref)
{
  WARN_ON(!atomic_read(&kref->refcount));
  atomic_inc(&kref->refcount);
  smp_mb__after_atomic_inc();
}

int kref_put(struct kref *kref, void (*release)(struct kref *kref))
{
  WARN_ON(release == NULL);
  WARN_ON(release == (void (*)(struct kref *))kfree);

  if (atomic_dec_and_test(&kref->refcount)) {
    release(kref);
    return 1;
  }
  return 0;
}

// include/linux/kobject.h
// 递增引用计数
struct kobject *kobject_get(struct kobject *kobj);
void kobject_put(struct kobject *kobj);

// lib/kobject.c
void kobject_put(struct kobject *kobj)
{
  if (kobj) {
    if (!kobj->state_initialized)
      WARN(1, KERN_WARNING "kobject: '%s' (%p): is not "
             "initialized, yet kobject_put() is being "
             "called.\n", kobject_name(kobj), kobj);
    kref_put(&kobj->kref, kobject_release);
  }
}

static void kobject_release(struct kref *kref)
{
  kobject_cleanup(container_of(kref, struct kobject, kref));
}

static void kobject_cleanup(struct kobject *kobj)
{
  struct kobj_type *t = get_ktype(kobj);
  const char *name = kobj->name;

  pr_debug("kobject: '%s' (%p): %s\n",
     kobject_name(kobj), kobj, __func__);

  if (t && !t->release)
    pr_debug("kobject: '%s' (%p): does not have a release() "
       "function, it is broken and must be fixed.\n",
       kobject_name(kobj), kobj);

  /* send "remove" if the caller did not do it but sent "add" */
  if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
    pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
       kobject_name(kobj), kobj);
    kobject_uevent(kobj, KOBJ_REMOVE);
  }

  /* remove from sysfs if the caller did not do it */
  if (kobj->state_in_sysfs) {
    pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
       kobject_name(kobj), kobj);
    kobject_del(kobj);
  }

  if (t && t->release) {
    pr_debug("kobject: '%s' (%p): calling ktype release\n",
       kobject_name(kobj), kobj);
    t->release(kobj);
  }

  /* free name if we allocated it */
  if (name) {
    pr_debug("kobject: '%s': free name\n", name);
    kfree(name);
  }
}

// include/linux/kobject.h
int kobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...);

// lib/kobject.c
int kobject_add(struct kobject *kobj, struct kobject *parent,
    const char *fmt, ...)
{
  va_list args;
  int retval;

  if (!kobj)
    return -EINVAL;

  if (!kobj->state_initialized) {
    printk(KERN_ERR "kobject '%s' (%p): tried to add an "
           "uninitialized object, something is seriously wrong.\n",
           kobject_name(kobj), kobj);
    dump_stack();
    return -EINVAL;
  }
  va_start(args, fmt);
  retval = kobject_add_varg(kobj, parent, fmt, args);
  va_end(args);

  return retval;
}
EXPORT_SYMBOL(kobject_add);

// include/linux/kobject.h
void kobject_del(struct kobject *kobj)

// fs/sysfs/file.c
void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr)
{
  sysfs_hash_and_remove(kobj->sd, attr->name);
}

// fs/sysfs/symlink.c
void sysfs_remove_link(struct kobject * kobj, const char * name)
{
  struct sysfs_dirent *parent_sd = NULL;

  if (!kobj)
    parent_sd = &sysfs_root;
  else
    parent_sd = kobj->sd;

  sysfs_hash_and_remove(parent_sd, name);
}

printk(KERN_INFO "SMP alternatives: switching to SMP code\n");