linux mmap

mmap will establish a mapping between kernel and userspace, We can use it to read data from kernel more quickly.
mmap is a function pointer in driver, so we have to write a driver to realize it, a simple char device driver is enough.
If you don't know how to write a simple char device driver, my code also can help you know it.
I descript the process as below:
1. define a mmap function for struct file_operations, which will register as a driver.
2. When userspace call mmap(system call), file_operations->mmap() will be called.
3. file_operations->mmap should call remap_page_range() to map the memory between userspace and kernel space.
4. userspace call mmap actively, mmap return a void pointer. Now If userspace modify the pointer's content, kernel will be modified at the same time.

here is also some link which maybe can help you:
1. has a sample too: http://linux.insigma.com.cn/devbbs/printpage.asp?BoardID=14&ID=100

2. has a userspace sample too: http://www.opengroup.org/onlinepubs/009695399/functions/mmap.html

3. "man mmap" will help you more, such as the difference between MAP_SHARED and MAP_PRIVATE.
4. Linux Device Driver(ldd2) has some introduce about mmap. (Section 13)

Note:
1. We should malloc whole page memory in kernel for map.
2. A non-regular file can't be map to write.
3. The size that userspace request to map, will be changed to whole page then sent to kernel.

below is code:
kernel module: mmap.c
Code:
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
#include <linux/wrapper.h>
#include <asm/io.h>
MODULE_PARM(mmap_major, "i");
MODULE_PARM(mmap_nr_devs, "i");
#define DEVICE "mmap"
#define DATASIZE PAGE_SIZE<<3
int mmap_major = 0;
int mmap_nr_devs = 1;
typedef struct mmap_state
{
   char data[DATASIZE];
   unsigned int size;
   void *handle;
   unsigned int access_key;
   struct semaphore sem;
}mmap_state;

#define TYPE(dev) (MINOR(dev) >>4)
#define NUM(dev) (MINOR(dev) &0xf)

int mmap_open(struct inode *inode, struct file *filp);
ssize_t mmap_read(struct file *filp, char *buf, size_t count, loff_t *f_pos);
ssize_t mmap_write(struct file *filp,const char *buf,size_t count,loff_t *f_pos);
int mmap_release(struct inode *inode, struct file *filp);
static int mmap_mmap(struct file * file, struct vm_area_struct * vma);
int mmap_trim(mmap_state *dev);
int mmap_init_module(void);
void mmap_cleanup_module(void);

struct file_operations mmap_fops = {
   open: mmap_open,
   read: mmap_read,
   write: mmap_write,
   llseek: NULL,
   ioctl: NULL,
   release: mmap_release,
   mmap: mmap_mmap,
};

mmap_state *mmap_devices;

int mmap_open(struct inode *inode, struct file *filp)
{
   mmap_state *dev;
   int num = NUM(inode->i_rdev); 
   int type = TYPE(inode->i_rdev);
   if (!filp->private_data && type)
   {
      printk(KERN_WARNING"data is not valid/n");
      return 0;
   }
   dev = (mmap_state *)filp->private_data;
   if (!dev)
   {
      if (num >= mmap_nr_devs)
         return -ENODEV;
      dev = &mmap_devices[num];
      filp->private_data = dev;
   }
   MOD_INC_USE_COUNT;
   if ( (filp->f_flags & O_ACCMODE) == O_WRONLY)
   {
      if (down_interruptible(&dev->sem))
      {
         MOD_DEC_USE_COUNT;
         return -ERESTARTSYS;
      }
      mmap_trim(dev);
      up(&dev->sem);
   }
   return 0;
}
static int mmap_mmap(struct file * file, struct vm_area_struct * vma)
{
   struct mmap_state *state = (struct mmap_state *)file->private_data;
   unsigned long size;
   int ret = -EINVAL;
   //printk("mmap_mmap()/n");
   if (vma->vm_pgoff != 0)
   {
      printk(" vm_pgoff != 0/n");
      goto error;
   }
   /* Don't try to swap out physical pages.. */
   vma->vm_flags |= VM_RESERVED;
   size = vma->vm_end - vma->vm_start;
   //printk(" data = [%p]/n", state->data);

   //printk(" content = [%s]/n", state->data);

   //printk(" start=[%lu] size=[%lu] end=[%lu]/n", vma->vm_start, size, vma->vm_end);

   if (size > state->size)
      goto error;
   if (remap_page_range( vma->vm_start, virt_to_phys(state->data), size,
                 vma->vm_page_prot))
      return -EAGAIN;
   //printk("mmap_mmap() success/n");

   return 0;
error:
   return ret;
}

int mmap_release(struct inode *inode, struct file *filp)
{
   MOD_DEC_USE_COUNT;
   return 0;
}

ssize_t mmap_read(struct file *filp, char *buf, size_t count,
               loff_t *f_pos)
{
   int ret = 0;
   mmap_state *dev = filp->private_data;
   if (down_interruptible(&dev->sem))
      return -ERESTARTSYS;
   if (*f_pos >= dev->size)
      goto out;
   if (*f_pos + count > dev->size)
      count = dev->size - *f_pos;
   if (copy_to_user(buf, &dev->data[*f_pos], count))
   {
      ret = -EFAULT;
      goto out;
   }
   *f_pos += count;
   ret = count;
out:
   up(&dev->sem);
   return ret;
}
ssize_t
mmap_write(struct file *filp, const char *buf, size_t count,loff_t *f_pos)
{
   int ret = 0;
   mmap_state *dev = filp->private_data;
   if (down_interruptible(&dev->sem))
      return -ERESTARTSYS;
   if (*f_pos + count > dev->size)
      count = dev->size - *f_pos;
   if (copy_from_user(&dev->data[*f_pos], buf, count))
   {
      ret = -EFAULT;
      goto out;
   }
   *f_pos += count;
   ret = count;

   if (dev->size < *f_pos)
      dev->size = *f_pos;
   
out:
   up(&dev->sem);
   return ret;
}

int mmap_trim(mmap_state *dev)
{
   memset(dev->data, 0, sizeof(dev->data));
   return 0;
}
int mmap_init_module(void)
{
   int result, i;
   struct page *page;
   SET_MODULE_OWNER(&mmap_fops);
   result = register_chrdev(mmap_major, DEVICE, &mmap_fops);
   if (result < 0)
   {
      
      printk(KERN_WARNING "mmap:cann't get major %d/n", mmap_major);
      return result;
   }
   if (mmap_major == 0)
      mmap_major = result;
   mmap_devices = kmalloc(mmap_nr_devs*sizeof(mmap_state),GFP_KERNEL);
   if (!mmap_devices)
   {
      result = -ENOMEM;
      goto fail;
   }
   memset(mmap_devices, 0, mmap_nr_devs * sizeof(mmap_state));
   for (i = 0; i < mmap_nr_devs; i++)
   {
      memset(mmap_devices[i].data, 0, sizeof(mmap_devices[i].data));
                                strcpy(mmap_devices[i].data, "aaa");
      mmap_devices[i].size = DATASIZE;
      /* Note here: if miss it, user space will get NULL */
      for (page = virt_to_page(mmap_devices[i].data); page <= virt_to_page(mmap_devices[i].data + (DATASIZE)); page++)
      {
         mem_map_reserve(page);
      }
      
      sema_init(&mmap_devices[i].sem, 1);
   }
   
   EXPORT_NO_SYMBOLS;
   return 0;
fail:
   mmap_cleanup_module();
   return result;
}

void mmap_cleanup_module(void)
{
   int i;
   unregister_chrdev(mmap_major, DEVICE);
   if (mmap_devices)
   {
      for (i = 0; i < mmap_nr_devs; i++)
         mmap_trim(mmap_devices + i);
      kfree(mmap_devices);
   }
}
module_init(mmap_init_module);
module_exit(mmap_cleanup_module);
MODULE_LICENSE("GPL");
EXPORT_NO_SYMBOLS;

Makefile here:
Code:
KERNELDIR = /usr/src/linux

include $(KERNELDIR)/.config

CFLAGS = -DEXPORT_SYMTAB -D__KERNEL__ -DMODULE -I$(KERNELDIR)/include -O -Wall

ifdef CONFIG_SMP
   CFLAGS += -D__SMP__ -DSMP
endif

ifdef CONFIG_MODVERSIONS
   CFLAGS += -DMODVERSIONS /
      -include $(KERNELDIR)/include/linux/modversions.h
endif
OBJ=mmap.o
all:$(OBJ)
clean:
   rm -f *.o



userspace: mmap_user.c
Code:
#include <sys/mman.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main()
{
   char *ptr = NULL;
   int fd = open("/dev/mmap0", O_RDWR);
   if (fd <= 0)
   {
      printf("open fail/n");
      return 1;
   }
   ptr = mmap(0, 90, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
   printf("ptr = [%s]/n", ptr);
   ptr[2] = 'c';
   printf("ptr = [%s]/n", ptr);
}



here is also a script to register a device:
Code:
#!/bin/sh
module="mmap"
device="mmap"
mode="664"

/sbin/insmod ./$module.o $* || exit 1
major=`cat /proc/devices | awk "//$2==/"$device/" {print //$1}"`
echo $major
rm -f /dev/${device}[0-3]
mknod /dev/${device}0 c $major 0
ln -sf ${device}0 /dev/${device}