# mount
/dev/hda7 on / type ext3 (rw)
none on /proc type proc (rw)
/dev/hda5 on /usr type ext3 (rw)
...
			

struct proc_dir_entry *entry;

entry->read_proc = read_proc_foo;
entry->write_proc = write_proc_foo;
			

#include <linux/module.h>
#include <linux/tty.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <asm/uaccess.h>

#define MODULE_VERSION	"1.0"

// 모듈의 이름이다. 
// 이 모듈이름으로 /proc밑에 디렉토리가 생성된다. 
#define MODULE_NAME		"myproc"

// 생성된 /proc/MODULE_NAME 밑에 아래 2개의 파일이 
// 생성된다. 
#define FOO_FILE		"foo"
#define JIFFIE_FILE		"jiffies" 

#define FOOBAR_LEN 8

// foo 파일에 저장될 데이터 구조체
struct fb_data_t
{
	char name[FOOBAR_LEN + 1];
	char value[FOOBAR_LEN + 1];
};
struct fb_data_t foo_data;


static struct proc_dir_entry *example_dir, *foo_file, *jiffies_file;

// 사용자가 cat등을 통해서 /proc/[MODULE_NAME]/jiffies파일을 열면 
// 커널은 이 함수를 호출해서 해당 정보를 넘겨준다. 
static int proc_read_jiffies(char *page, char **start, off_t off,
			   int count, int *eof, void *data)
{
	int len;

	MOD_INC_USE_COUNT;
	// 사용자가 이해하기 쉬운 포맷으로 만든다. 
	// cat, vi등을 사용해서 이 파일을 열경우 
	// jiffies = 1234 와 같은 형식으로 보인다. 
	len = sprintf(page, "jiffies = %ld\n", jiffies);
	// 해당 내용을 printk를 통해서 로그로 남긴다.  
	// 이 데이터는 /var/log/message로 출력된다.
	printk("<1> read jiffies = %ld\n", jiffies);
	MOD_DEC_USE_COUNT;

	return len;
}

// 사용자가 /proc/[MODULE_NAME]/foo 파일을 열었을 때 
// 출력해주는 정보 
static int proc_read_foobar(char *page, char **start, off_t off, 
							int count, int *eof, void *data)
{
	int len;
	struct fb_data_t *fb_data = (struct fb_data_t *)data;

	MOD_INC_USE_COUNT;
	// fb_data구조체의 내용을 보시쉽게 만들어서 출력해준다. 
	len = sprintf(page, "%s = %s",
					fb_data->name, fb_data->value);
	MOD_DEC_USE_COUNT;
	return len;
}

// 사용자는 /proc/[MODULE_NAME]/foo에 내용을 쓰기를 원할때도 있을 것이다.
// 이 때 이함수가 호출된다.
static int proc_write_foobar(struct file *foke, const char *buffer,
							unsigned long count, void *data)
{
	int len;
	struct fb_data_t *fb_data = (struct fb_data_t *)data;

	MOD_INC_USE_COUNT;
	if (count > FOOBAR_LEN)
		len = FOOBAR_LEN;
	else
		len = count;

	printk("<1> DATA COPY %d\n", len);
	// echo "xxxxx" > /proc/[MODULE_NAME]/foo 등으로 입력받은 값을
	// fb_data->value에 저장한다. 
	if (copy_from_user(fb_data->value, buffer, len))
	{
		MOD_DEC_USE_COUNT;
		return -EFAULT;
	}

	fb_data->value[len] = 0x00;
	MOD_DEC_USE_COUNT;

	return len;

}

// 커널 모듈 초기화 함수
static int init_myproc(void)
{
	int rv = 0;

	printk("<1> Module Start\n");
	example_dir = proc_mkdir(MODULE_NAME, NULL);
	if (example_dir == NULL)
	{
		rv = -ENOMEM;
		printk("<1> mkdir failure\n");
		goto out;
	}

	// JIFFILE파일의 경우 단지 읽기만 허용한다.
	example_dir->owner = THIS_MODULE;
	jiffies_file = create_proc_read_entry(JIFFIE_FILE, 0444, example_dir,
									proc_read_jiffies, NULL);
	if (jiffies_file == NULL)
	{
		rv = -ENOMEM;
		printk("<1> read entry failure\n");
		goto no_jiffies;
	}
	printk("<1> OK MAKE MODULE\n");
	jiffies_file->owner = THIS_MODULE; 

	// FOO_FILE의 경우 읽기와 쓰기 모두 가능해도록 해야 하며 
	// 각각의 경우에 호출될 함수를 지정해 줘야 한다. 
	foo_file = create_proc_entry(FOO_FILE, 0644, example_dir);
	if (foo_file == NULL)
	{
		rv = -ENOMEM;
		goto no_foo;
	}

	strcpy(foo_data.name, "foo");
	strcpy(foo_data.value, "dream");

	// 커널 자료구조에 저장될 데이터 
	foo_file->data = &foo_data;
	// 읽기를 요청했을 때 호출될 함수
	foo_file->read_proc = proc_read_foobar;
	// 쓰기가 요청되었을 때 호출될 함수
	foo_file->write_proc = proc_write_foobar;
	foo_file->owner = THIS_MODULE;

	printk("<1> %s %s initialised\n", "myproc", "1.0");

	// 제대로 초기화가 이루어졌다면 0을 리턴해야 한다. 
	return 0;
	no_foo:
		remove_proc_entry(FOO_FILE, example_dir);
	no_jiffies:
		remove_proc_entry(MODULE_NAME, NULL);
	out:
		return rv;
}

// cleanup 함수
static void cleanup_myproc(void) 
{
	printk("<1> END\n"); 
	remove_proc_entry(FOO_FILE, example_dir);
	remove_proc_entry(JIFFIE_FILE, example_dir);
}

module_init(init_myproc);
module_exit(cleanup_myproc);

MODULE_AUTHOR("yundream");
MODULE_DESCRIPTION("Sanmpe proc");
			

WARN    := -W -Wall -Wstrict-prototypes -Wmissing-prototypes    
INCLUDE := -isystem /lib/modules/`uname -r`/build/include    
CFLAGS  := -O2 -DMODULE -D__KERNEL__ ${WARN} ${INCLUDE}    
CC      := gcc                                 
TARGET  := my_proc 
     
my_proc.o: my_proc.c
	${CC} ${CFLAGS} -c my_proc.c 
                                     
.PHONY: clean                                                      
                                          
clean:                                    
	rm -rf ${TARGET}.o    
			

# echo "okok" > /proc/myproc/foo
# cat /proc/myproc/foo
foo = okok