/*  hello-1.c - The simplest kernel module. */
#include <linux/module.h>  /* 모든 모듈에 필요 */
#include <linux/kernel.h>  /* KERN_ALERT에 필요 */

int init_module(void)
{
 printk("<1>Hello world 1.\n");

 // 0이 아닌 값을 리턴하는 것은 init_module이 실패한 것을 의미한다. 고로 모듈은 로드되지 못한다.
 return 0;
}

void cleanup_module(void)
{
 printk(KERN_ALERT "Goodbye world 1.\n");
}

TARGET  := hello-1
WARN    := -W -Wall -Wstrict-prototypes -Wmissing-prototypes
INCLUDE := -isystem /lib/modules/`uname -r`/build/include
CFLAGS  := -O2 -DMODULE -D__KERNEL__ ${WARN} ${INCLUDE}
CC      := gcc-3.0

${TARGET}.o: ${TARGET}.c

.PHONY: clean

clean:
    rm -rf {TARGET}.o

/*  hello-2.c - Demonstrating the module_init() and module_exit() macros.
    This is the preferred over using init_module() and cleanup_module().
hello-2.c – module_init()와 module_exit()매크로의 예. 이것은 init_module()과 cleanup_moduel() 보다 낫다. */
#include <linux/module.h>   // Needed by all modules
#include <linux/kernel.h>   // Needed for KERN_ALERT#include <linux/init.h>     // Needed for the macrosstatic

int hello_2_init(void)
{
   printk(KERN_ALERT "Hello, world 2\n");
   return 0;
}

static void hello_2_exit(void)
{
   printk(KERN_ALERT "Goodbye, world 2\n");
}

module_init(hello_2_init);
module_exit(hello_2_exit);

WARN    := -W -Wall -Wstrict-prototypes -Wmissing-prototypes
INCLUDE := -isystem /lib/modules/`uname -r`/build/include
CFLAGS  := -O2 -DMODULE -D__KERNEL__ ${WARN} ${INCLUDE}
CC      := gcc-3.0
OBJS    := ${patsubst %.c, %.o, ${wildcard *.c}}

all: ${OBJS}

.PHONY: clean

clean:
    rm -rf *.o

/*  hello-3.c - Illustrating the __init, __initdata and __exit macros. */
#include <linux/module.h>      /* Needed by all modules */
#include <linux/kernel.h>      /* Needed for KERN_ALERT */
#include <linux/init.h>        /* Needed for the macros */
static int hello3_data __initdata = 3;

static int __init hello_3_init(void)
{
   printk(KERN_ALERT "Hello, world %d\n", hello3_data);
   return 0;
}

static void __exit hello_3_exit(void)
{
   printk(KERN_ALERT "Goodbye, world 3\n");
}

module_init(hello_3_init);
module_exit(hello_3_exit);

__initfunction(int init_module(void))
{
   printk(KERN_ALERT "Hi there.\n");
   return 0;
}

/*  hello-4.c - Demonstrates module documentation. */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#define DRIVER_AUTHOR "Peiter Jay Salzman <p@dirac.org>"
#define DRIVER_DESC   "A sample driver"

int init_hello_3(void);
void cleanup_hello_3(void);

static int init_hello_4(void){
   printk(KERN_ALERT "Hello, world 4\n");
   return 0;
}

static void cleanup_hello_4(void)
{
   printk(KERN_ALERT "Goodbye, world 4\n");
}

module_init(init_hello_4);
module_exit(cleanup_hello_4);
/*  You can use strings, like this: */
MODULE_LICENSE("GPL");           // Get rid of taint message by declaring code as GPL..
/*  Or with defines, like this: */
MODULE_AUTHOR(DRIVER_AUTHOR);    // Who wrote this module?
MODULE_DESCRIPTION(DRIVER_DESC); // What does this module do?
/*  This module uses /dev/testdevice.
The MODULE_SUPPORTED_DEVICE macro might be used in the future to help automatic configuration of modules, 
but is currently unused other than for documentation purposes.
*/
MODULE_SUPPORTED_DEVICE("testdevice");

int myint = 3;
char *mystr;

MODULE_PARM (myint, "i");
MODULE_PARM (mystr, "s");

int myshortArray[4];
MODULE_PARM (myintArray, "2-4i");

/*  hello-5.c - Demonstrates command line argument passing to a module. */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Peiter Jay Salzman");

static short int myshort = 1;
static int myint = 420;
static long int mylong = 9999;
static char *mystring = "blah";

MODULE_PARM (myshort, "h");
MODULE_PARM (myint, "i");
MODULE_PARM (mylong, "l");
MODULE_PARM (mystring, "s");

static int __init hello_5_init(void)
{
   printk(KERN_ALERT "Hello, world 5\n=============\n");
   printk(KERN_ALERT "myshort is a short integer: %hd\n", myshort);
   printk(KERN_ALERT "myint is an integer: %d\n", myint);
   printk(KERN_ALERT "mylong is a long integer: %ld\n", mylong);
   printk(KERN_ALERT "mystring is a string: %s\n", mystring);
   return 0;
}

static void __exit hello_5_exit(void)
{
   printk(KERN_ALERT "Goodbye, world 5\n");
}

module_init(hello_5_init);
module_exit(hello_5_exit);

/*  start.c - Illustration of multi filed modules */
#include <linux/kernel.h>       /* We're doing kernel work */
#include <linux/module.h>       /* Specifically, a module */
int init_module(void)
{
  printk("Hello, world - this is the kernel speaking\n");
  return 0;
}

/*  stop.c - Illustration of multi filed modules */
#if defined(CONFIG_MODVERSIONS) && ! defined(MODVERSIONS)
   #include <linux/modversions.h> /* Will be explained later */
   #define MODVERSIONS
#endif
#include <linux/kernel.h>  /* We're doing kernel work */
#include <linux/module.h>  /* Specifically, a module  */
#define __NO_VERSION__     /* It's not THE file of the kernel module */
#include <linux/version.h> /* Not included by module.h because of __NO_VERSION__ */

void cleanup_module()
{
   printk("<1>Short is the life of a kernel module\n");
}

CC=gcc
MODCFLAGS := -O -Wall –DMODULE -D__KERNEL__

hello.o:        hello2_start.o hello2_stop.o
   ld -m elf_i386 -r -o hello2.o hello2_start.o hello2_stop.o

start.o: hello2_start.c
   ${CC} ${MODCFLAGS} -c hello2_start.c

stop.o: hello2_stop.c
   ${CC} ${MODCFLAGS} -c hello2_stop.c

#include <stdio.h>
int main(void)
{ printf("hello"); return 0; }

struct file_operations {
  struct module *owner;
  loff_t (*llseek) (struct file *, loff_t, int);
  ssize_t (*read) (struct file *, char *, size_t, loff_t *);
  ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
  int (*readdir) (struct file *, void *, filldir_t);
  unsigned int (*poll) (struct file *, struct poll_table_struct *);
  int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
  int (*mmap) (struct file *, struct vm_area_struct *);
  int (*open) (struct inode *, struct file *);
  int (*flush) (struct file *);
  int (*release) (struct inode *, struct file *);
  int (*fsync) (struct file *, struct dentry *, int datasync);
  int (*fasync) (int, struct file *, int);
  int (*lock) (struct file *, int, struct file_lock *);
  ssize_t (*readv)  (struct file *, const struct iovec *, unsigned long, loff_t *);
  ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
};

struct file_operations fops = {
  read: device_read,
  write: device_write,
  open: device_open,
  release: device_release;
}

struct file_operations fops = {
  .read = device_read,
  .write = device_write,
  .open = device_open,
  .release = device_release
};

int register_chrdev(unsigned int major, const char *name, struct file_operations *fops);

/* chardev.c: 얼마나 많이 디바이스 파일에 접근했는지 알려주는 모듈 */
#if defined(CONFIG_MODVERSIONS) && ! defined(MODVERSIONS)
#include <linux/modversions.h>
#define MODVERSIONS
#endif
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>  /* for put_user */

/* Prototypes - this would normally go in a .h file */
int init_module(void);
void cleanup_module(void);
static int device_open(struct inode *, struct file *);
static int device_release(struct inode *, struct file *);
static ssize_t device_read(struct file *, char *, size_t, loff_t *);
static ssize_t device_write(struct file *, const char *, size_t, loff_t *);
#define SUCCESS 0
#define DEVICE_NAME "chardev" /* /proc/devices에 나타나는 장치 이름 */
#define BUF_LEN 80            /* 장치로부터 메시지의 최대 길이 */

/* 정적 변수로 전역변수 선언 */
static int Major;             /* 주장치 번호 */
static int Device_Open = 0;  /* 장치가 열렸는가? 중복사용 방지 */

/* access to the device */
static char msg[BUF_LEN];    /* 요청이 있을 때 장치가 보내는 메시지 */
static char *msg_Ptr;
static struct file_operations fops = {
  .read = device_read,
  .write = device_write,
  .open = device_open,
  .release = device_release
};

/* Functions */
int init_module(void)
{
  Major = register_chrdev(0, DEVICE_NAME, &fops);
  if (Major < 0) {
    printk ("Registering the character device failed with %d\n", Major);
    return Major;
  }
  printk("<1>I was assigned major number %d.  To talk to\n", Major);
  printk("<1>the driver, create a dev file with\n");
  printk("'mknod /dev/hello c %d 0'.\n", Major);
  printk("<1>Try various minor numbers.  Try to cat and echo to\n");
  printk("the device file.\n");
  printk("<1>Remove the device file and module when done.\n");
  return 0;
}

void cleanup_module(void)
{
  /* Unregister the device */
  int ret = unregister_chrdev(Major, DEVICE_NAME);
  if (ret < 0) printk("Error in unregister_chrdev: %d\n", ret);
}

/* Methods */
/* "cat /dev/mycharfile" 처럼 프로세스가 디바이스 파일을 열려고 할 때 호출됨 */
static int device_open(struct inode *inode, struct file *file)
{
  static int counter = 0;
  if (Device_Open) return -EBUSY;

  Device_Open++;
  sprintf(msg,"I already told you %d times Hello world!\n", counter++);
  msg_Ptr = msg;
  MOD_INC_USE_COUNT;
  return SUCCESS;
}

/* 디바이스 파일이 닫힐 때 호출됨. */
static int device_release(struct inode *inode, struct file *file)
{
  Device_Open --;  /* We're now ready for our next caller */
                   /* 사용 카운트 감소 혹은 한번 열어본 파일이 아니라면 모듈을 제거할 수 없음 */
  MOD_DEC_USE_COUNT;
  return 0;
}

/* 이미 열린 장치 파일에서 무엇인가 읽으려 할 때 호출 */
static ssize_t device_read(struct file *filp,
                           char *buffer,    /* The buffer to fill with data */
                           size_t length,   /* The length of the buffer     */
                           loff_t *offset)  /* Our offset in the file       */
{
  /* 버퍼에 실제 쓰여진 바이트 수 */
  int bytes_read = 0;
  /* 메시지의 끝에 메시지의 끝임을 알리기 위해 0리턴 */
  if (*msg_Ptr == 0) return 0;
  /* 버퍼에 실제 데이터를 입력 */
  while (length && *msg_Ptr)  {
     /* 버퍼는 커널 세그먼트가 아니고 사용자 세그먼트다
      * 할당은 일어 나지 않는다. 커널 데이터영역에서 사용자 영역으로
      * 데이터를 복사하는 put_user() 사용
      */
    put_user(*(msg_Ptr++), buffer++);
    length--;
    bytes_read++;
  }
  /* 읽혀진 데이터의 바이트 수를 버퍼에 기록 */
  return bytes_read;
}

/*  Called when a process writes to dev file: echo "hi" > /dev/hello */
static ssize_t device_write(struct file *filp,
                            const char *buff,
                            size_t len,
                            loff_t *off)
{
  printk ("<1>Sorry, this operation isn't supported.\n");
  return -EINVAL;
}

#if LINUX_KERNEL_VERSION >= KERNEL_VERSION(2,2,0)
#define KERNEL_VERSION(a,b,c) ((a)*65536+(b)*256+(c))
#endif

/*  procfs.c -  create a "file" in /proc  */
#include <linux/kernel.h>   /* 커널 작업 */
#include <linux/module.h>   /* 모듈 작업 */
/* Deal with CONFIG_MODVERSIONS */
#if CONFIG_MODVERSIONS==1
#define MODVERSIONS
#include <linux/modversions.h>
#endif        /* proc fs를 다룬다 */
#include <linux/proc_fs.h>
/* 2.2.3 버전 이전에는 다음의 매크로가 없다. 필요하다면 여기서 정의 한다.*/
#ifndef KERNEL_VERSION#define KERNEL_VERSION(a,b,c) ((a)*65536+(b)*256+(c))
#endif

/* proc fs에 데이터 전달.   
Argument   =========   
1. 데이터가 삽입되는 버퍼, 만일 사용하기 원한다면
2. 문자열에 대한 포인터, 만일 커널이 버퍼를 할당하기 원하지 않는 경우 사용
3. 파일에서 현재 위치
4. 첫 인자 버퍼의 크기
5. 0(미래의 사용을 위해?). 
Usage and Return Value  ======================
만일 자신만의 버퍼를 원한다면 내가 한 것처럼 두번 째 인자에 넣고 버퍼에서 사용한 바이트 수를 리턴하라
리턴 값이 NULL인것은 더 이상의 정보가 없음을 의미한다(end of file). 또한 음수인 경우 에러 상황이다.
For More Information   ====================
The way I discovered what to do with this function 
내가 이 함수에서 무엇인가를 발견한 방법은 문서를 읽는 것이 아니고, 사용되는 코드를 읽는 것이었다. 
proc_dir_entry구조체의 get_info필드를 어디다 쓰는가를 살펴봤다. 
또한 /fs/proc/array.c 파일이 사용되는 것을 살펴 본 것이다.
If something is unknown about the kernel, this is
무언가 커널에서 잘 모르는 부분이 있다면 이런 방식이 일반적으로 행해진다.
리눅스에서 우리는 커널 코드를 얻을 수 있다는 것은 대단한 장점이다. 활용하라. */

int procfile_read(char *buffer,
                  char **buffer_location, off_t offset,
                  int buffer_length,
                  int zero)
{
  int len;  /* 실제 사용되는 바이트 수 */
            /* 우리가 이 함수를 나갈 때도 이 스테틱 변수이기 때문에 메모리에 남겨 진다. */

  static char my_buffer[80];
  static int count = 1;
  /* 우리(직역)는 한번에 모든 정보를 주기 때문에 유저(?직역)가 추가적인 정보를 요구할 때 우리의 대답은 NO다.
   * 표준 라이브러리 함수는 커널이 더 이상 줄 정보가 없다고 말할 때까지, 혹은 표준 라이브러리 함수의 버퍼가 다 찰 때까지
   * read 시스템 콜을 하기 때 문에 중요하다. */

  if (offset > 0) return 0;   /* Fill the buffer and get its length */
  len = sprintf(my_buffer, "For the %d%s time, go away!\n", count,
           (count % 100 > 10 && count % 100 < 14) ? "th" : (count % 10 == 1) ? "st" : (count % 10 == 2) ? "nd" :
           (count % 10 == 3) ? "rd" : "th" );
  count++;                          /* 함수에 버퍼의 위치를 알린다. */
  *buffer_location = my_buffer;  /* Return the length */
  return len;
}

struct proc_dir_entry Our_Proc_File =
{0,  /* Inode 번호 &#8211;여기서는 무시한다. 이것은 proc_register[_dynamic]에 의해 채워진다. */
 4,  /* 파일의 이름 길이 */
 "test",  /* 파일이름 */
 S_IFREG | S_IRUGO,  /* File mode &#8211; 일반 파일, 소유자, 그룹, 모든 사람들이 있을 수 있다.*/
 1,  /* 파일이 참고하는 디렉토리의 링크 개수*/
 0, 0,  /* uid, gid 루트에게 권한을 준다.*/
 80,  /* ls에 의해 보고되는 파일의 크기. */
 NULL, /* link, remove등 inode상에 행해지는 함수- 우리는 아무것도 지원하지 않는다. */
 procfile_read, /* 읽기 함수, 무엇인가를 읽으려 할 때 호출되는 함수 */
 NULL /* 퍼미션, 소유권 등을 다루는 inode를 채우는 함수의 포인터 */ };

/* Initialize the module - register the proc file */
int init_module()
{
  /* proc_register[_dynamic]이 성공하면 성공, 아니면 실패 */
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,2,0)
  /* 구조체에서 그 값이 0이면 2.2버전에서는 proc_register()함수가 inode번호를 동적으로 할당한다.
   * proc_register_dynamic()함수가 필요없게 된다. */
  return proc_register(&proc_root, &Our_Proc_File);
#else
  return proc_register_dynamic(&proc_root, &Our_Proc_File);
#endif
/* proc_root는 proc파일 시스템의 루트(/proc)
 * 우리가 파일을 위치시키기 원하는 위치다.
 */
}

/* Cleanup - unregister our file from /proc */
void cleanup_module()
{
  proc_unregister(&proc_root, Our_Proc_File.low_ino);
}

/*  procfs.c -  create a "file" in /proc, which allows both input and output. */
#include <linux/kernel.h>   /* We're doing kernel work */
#include <linux/module.h>   /* Specifically, a module */
/* Necessary because we use proc fs */
#include <linux/proc_fs.h>