motylewski.h.orig

Linux共享内存share memory通信机制的内核实现

/*
 *  Copyright (C) 1999 Tomasz Motylewski <[e-mail]>
 *
 *  The general driver layout borrowed from BIOS FLASH driver:
 * Copyright (C) 1998 Stefan Reinauer <[e-mail]>
 *
 * routines for vmalloc'ed area remapping from bttv.c linux 2.1 driver.
 *
 * (EDITED IN MY SO CALLED "TYPING STYLE" (Paolo Mantegazza))
 */

/* convert virtual user memory address to physical address */
/* (virt_to_phys only works for kmalloced kernel memory) */

static inline unsigned long uvirt_to_phys(unsigned long adr)
{
	pgd_t *pgd;
	pmd_t *pmd;
	pte_t *ptep, pte;
  
	pgd = pgd_offset(current->mm, adr);
	if (pgd_none(*pgd)) {
		return 0;
	}
	pmd = pmd_offset(pgd, adr);
	if (pmd_none(*pmd)) {
		return 0;
	}
	ptep = pte_offset(pmd, adr);
	pte = *ptep;
	if (!pte_present(pte)) {
		return 0;
	}
	return virt_to_phys((void *)(pte_page(pte) | (adr & (PAGE_SIZE - 1))));
}

static inline unsigned long uvirt_to_bus(unsigned long adr) 
{
	return virt_to_bus(phys_to_virt(uvirt_to_phys(adr)));
}

/* convert virtual kernel memory address to physical address */
/* (virt_to_phys only works for kmalloced kernel memory) */

static inline unsigned long kvirt_to_phys(unsigned long adr) 
{
	return uvirt_to_phys(VMALLOC_VMADDR(adr));
}

static inline unsigned long kvirt_to_bus(unsigned long adr) 
{
	return uvirt_to_bus(VMALLOC_VMADDR(adr));
}

/* allocate user space mmapable block of memory in the kernel space */

void *rvmalloc(unsigned long size)
{
	void *mem;
	unsigned long adr, page;
        
	mem = vmalloc(size);
	if (mem) {
		memset(mem, 0, size);
	        adr = (unsigned long)mem;
		while (size > 0) {
	                page = kvirt_to_phys(adr);
			mem_map_reserve(MAP_NR(phys_to_virt(page)));
			adr += PAGE_SIZE;
			size -= PAGE_SIZE;
		}
	}
	return mem;
}

/* freee user space mmapable block of memory in the kernel space */

void rvfree(void *mem, unsigned long size)
{
        unsigned long adr, page;
        
	if (mem) {
	        adr = (unsigned long)mem;
		while (size > 0) {
	                page = kvirt_to_phys(adr);
			mem_map_unreserve(MAP_NR(phys_to_virt(page)));
			adr += PAGE_SIZE;
			size -= PAGE_SIZE;
		}
		vfree(mem);
	}
}

/* this function will map rvmalloc'ed memory area to user space */

int rvmmap(void *mem, unsigned memsize, struct vm_area_struct *vma) 
{
	unsigned long pos, size, start = vma->vm_start;

	/* this is not time critical code, so we check the arguments */
	/* vma->vm_offset HAS to be checked (and is checked)*/

	if (vma->vm_offset < 0) {
		return -EFAULT;
	}
	size = vma->vm_end - vma->vm_start;
	if ((size + vma->vm_offset) > memsize) {
		return -EFAULT;
	}
	pos = (unsigned long)mem + vma->vm_offset;
	if (pos%PAGE_SIZE || start%PAGE_SIZE || size%PAGE_SIZE) {
		return -EFAULT;
	}
		
	while (size > 0) {
		if (remap_page_range(start, kvirt_to_phys(pos), PAGE_SIZE, vma->vm_page_prot)) {
			return -EFAULT;
		}
		pos += PAGE_SIZE;
		start += PAGE_SIZE;
		size -= PAGE_SIZE;
	}
	return 0;
}