void *s_page;

/* void *kmalloc(size_t size, gfp_t flags) */
s_page = kmalloc((size_t)1234u, GFP_KERNEL);
if(s_page != ((void *)0)) {
    printk("<0>kmalloc success.\n");

    /* void kfree(const void *objp) */
    kfree((const void *)s_page);
}
else {
    printk("<0>kmalloc failed !\n");
}

void *s_vpage;

/* void *vmalloc(unsigned long size) */
s_vpage = vmalloc(1234ul);
if(s_vpage != ((void *)0)) {
    printk("<0>vmalloc success.\n");

    /* void vfree(const void *addr) */
    vfree((const void *)s_vpage);
}
else {
    printk("<0>vmalloc failed !\n");
}

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

#include <linux/mempool.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>

#if !defined(mzdriver_mempool_element_t)
typedef struct mzdriver_mempool_element_ts {
    unsigned char __dummy;
    unsigned char __shadow_area;
}__mzdriver_mempool_element_t;
# define mzdriver_mempool_element_t __mzdriver_mempool_element_t
#endif

static void *mzdriver_mempool_alloc_handler(gfp_t s_gfp_mask, void *s_pool_data)
{
    void *s_result;

    /* void *kmalloc(size_t size, gfp_t flags) */
    s_result = (void *)kmalloc(sizeof(mzdriver_mempool_element_t), s_gfp_mask);
    if(unlikely(s_result == ((void *)0))) {
        printk("<0>mempool_alloc failed !\n");
        return((void *)0);
    }

    printk("<0>mempool_alloc success.\n");
    return(s_result);
}

static void mzdriver_mempool_free_handler(void *s_element, void *s_pool_data)
{
    if(s_element == ((void *)0)) {
        printk("<0>mempool_free EINVAL !\n");
        return;
    }

    /* void kfree(const void *objp) */
    kfree((const void *)s_element);

    printk("<0>mempool_free success.\n");
}

static int __init mzdriver_init(void)
{
    printk("<0>Insert mzdriver module.\n");

    do { /* __get_free_pages, free_page */
        unsigned long s_page;
        unsigned int s_order;

        s_order = MAX_ORDER;
        s_order = get_order((4 << 10) * (1 << s_order));
        if(s_order > ((unsigned int)(MAX_ORDER))) {
            printk("<0>too big order ! (%u/%u)\n", s_order, (unsigned int)(MAX_ORDER));
        }

        /* unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order) */
        s_page = __get_free_pages(GFP_KERNEL, s_order);
        if(s_page != 0ul) {
            printk("<0>__get_free_pages success. (order=%u/%u)\n", s_order, (unsigned int)(MAX_ORDER));
            free_page(s_page);
        }
        else {
            printk("<0>__get_free_pages failed ! (order=%u/%u)\n", s_order, (unsigned int)(MAX_ORDER));
        }
    }while(0);

    do { /* mempool */
        void *s_pool_data;
        mempool_t *s_mempool;
        int s_count, s_max_pool;

        void *s_pool[ 3 ];

        s_pool_data = (void *)0;
        s_max_pool = sizeof(s_pool) / sizeof(void *);

        /* mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *pool_data) */
        s_mempool = mempool_create(0, mzdriver_mempool_alloc_handler, mzdriver_mempool_free_handler, s_pool_data);
        if(s_mempool != ((mempool_t *)0)) {
            printk("<0>mempool_create success.\n");

            for(s_count = 0;s_count < s_max_pool;s_count++) {
                /* void * mempool_alloc(mempool_t *pool, gfp_t gfp_mask) */
                s_pool[s_count] = mempool_alloc(s_mempool, GFP_KERNEL);
                if(s_pool[s_count] != ((void *)0)) {
                   printk("<0>mempool_alloc[%d] success.\n", s_count);
                }
                else {
                   printk("<0>mempool_alloc[%d] failed !\n", s_count);
                }
            }

            printk("<0>mempool_alloc end.\n");

            for(s_count = 0;s_count < s_max_pool;s_count++) {
                if(s_pool[s_count] != ((void *)0)) {
                    /* void mempool_free(void *element, mempool_t *pool) */
                    mempool_free(s_pool[s_count], s_mempool);
                    printk("<0>mempool_free[%d] success.\n", s_count);
                }
                else {
                    printk("<0>mempool_free[%d] ignored !\n", s_count);
                }

            }

            /* void mempool_destroy(mempool_t *pool) */
            mempool_destroy(s_mempool);
        }
        else {
            printk("<0>mempool_create failed !\n");
        }
    }while(0);

    do { /* vmalloc, vfree */
        void *s_vpage;

        /* void *vmalloc(unsigned long size) */
        s_vpage = vmalloc(1234ul);
        if(s_vpage != ((void *)0)) {
            printk("<0>vmalloc success.\n");

            /* void vfree(const void *addr) */
            vfree((const void *)s_vpage);
        }
        else {
            printk("<0>vmalloc failed !\n");
        }
    }while(0);

    return 0;
}

static void __exit mzdriver_exit(void)
{
    printk("<0>Remove mzdriver module.\n");
}

module_init(mzdriver_init);
module_exit(mzdriver_exit);

/* End of source */

#define __init __attribute__ ((__section__ (".init.text"))) __cold

#ifdef MODULE
# define __exit __attribute__ ((__section__(".exit.text"))) __cold
#else
# define __exit __attribute_used__ __attribute__ ((__section__(".exit.text"))) __cold
#endif

#define __define_initcall(level,fn) \
    static initcall_t __initcall_##fn __attribute_used__ \
    __attribute__((__section__(".initcall" level ".init"))) = fn

#define device_initcall(fn) __define_initcall("6",fn)

#define __exit_call __attribute_used__ __attribute__ ((__section__ (".exitcall.exit")))
#define __initcall(fn) device_initcall(fn)
#define __exitcall(fn) static exitcall_t __exitcall_##fn __exit_call = fn

#define module_init(x) __initcall(x);
#define module_exit(x) __exitcall(x);

/* 모듈 작성시에는 반드시 아래의 header는 항상 포함되어야 합니다.. */
#include <linux/module.h>
#include <linux/init.h>
static int __init mzdriver_init(void)
{
    printk("<0>Insert mzdriver module.\n");
    return 0; /* 반환값이 0인 경우 모듈적재에 성공했다고 처리됩니다. */
}

static void __exit mzdriver_exit(void)
{
    printk("<0>Remove mzdriver module.\n");
}

module_init(mzdriver_init); /* mzdriver_init함수를 모듈의 초기화 함수로 지정합니다.. */
module_exit(mzdriver_exit); /* mzdriver_exit함수를 모듈의 해제함수로 지정합니다. */