Subversion Repositories or1k_old

/*
 *	linux/mm/mmap.c
 *
 * Written by obz.
 */
 
/*
 * uClinux revisions for NO_MM
 * Copyright (C) 1998  Kenneth Albanowski <kjahds@kjahds.com>,
 *                     The Silver Hammer Group, Ltd.
 * Copyright (C) 1999  D. Jeff Dionne <jeff@uclinux.org>,
 *                     Rt-Control, Inc.
 */  
 
#include <linux/stat.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/shm.h>
#include <linux/errno.h>
#include <linux/mman.h>
#include <linux/string.h>
#include <linux/malloc.h>
#include <linux/pagemap.h>
#include <linux/swap.h>
 
#include <asm/segment.h>
#include <asm/system.h>
#include <asm/pgtable.h>
 
/* If defined, warn whenever someone mmaps a block that has more then this
   number of bytes in slack space (due to kmalloc granularity). */
 
/*#define WARN_ON_SLACK 1024*/
 
/*
 * Combine the mmap "prot" and "flags" argument into one "vm_flags" used
 * internally. Essentially, translate the "PROT_xxx" and "MAP_xxx" bits
 * into "VM_xxx".
 */
static inline unsigned long vm_flags(unsigned long prot, unsigned long flags)
{
#define _trans(x,bit1,bit2) \
((bit1==bit2)?(x&bit1):(x&bit1)?bit2:0)
 
	unsigned long prot_bits, flag_bits;
	prot_bits =
		_trans(prot, PROT_READ, VM_READ) |
		_trans(prot, PROT_WRITE, VM_WRITE) |
		_trans(prot, PROT_EXEC, VM_EXEC);
	flag_bits =
		_trans(flags, MAP_GROWSDOWN, VM_GROWSDOWN) |
		_trans(flags, MAP_DENYWRITE, VM_DENYWRITE) |
		_trans(flags, MAP_EXECUTABLE, VM_EXECUTABLE);
	return prot_bits | flag_bits;
#undef _trans
}
 
asmlinkage unsigned long sys_brk(unsigned long brk)
{
	return -ENOSYS;
}
 
#ifdef DEBUG_MMAP
 
#undef do_mmap
unsigned long do_mmap_flf(struct file * file, unsigned long addr, unsigned long len,
	unsigned long prot, unsigned long flags, unsigned long off, char*filename, int line, char*function)
{
	unsigned long result;
	printk("%s @%s:%d: do_mmap by pid %d of %lu", function, filename, line, current->pid, len);
 
	result=do_mmap(file,addr,len,prot,flags,off);
 
	if (result >= -4096) /* so to speak... */
		printk(" = %lx\n", result);
	else
	if (is_in_rom(result))
		printk("-%lu = %lx\n", len, result);
	else
	printk("+%lu+%lu+%lu = %lx\n",
		ksize(result)-len,
		ksize(current->mm->tblock.next),
		ksize(current->mm->tblock.next->rblock),
		result);
	return result;
}
#endif /* DEBUG_MMAP */
 
#ifdef DEBUG
static void show_process_blocks(void)
{
	struct mm_tblock_struct * tblock, *tmp;
 
	printk("Process blocks %d:", current->pid);
 
	tmp = &current->mm->tblock;
	while (tmp) {
		printk(" %p: %p", tmp, tmp->rblock);
		if (tmp->rblock)
			printk(" (%d @%p #%d)", ksize(tmp->rblock->kblock), tmp->rblock->kblock, tmp->rblock->refcount);
		if (tmp->next)
			printk(" ->");
		else
			printk(".");
		tmp = tmp->next;
	}
	printk("\n");
}
#endif /* DEBUG */
 
extern unsigned long askedalloc, realalloc;
 
unsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len,
	unsigned long prot, unsigned long flags, unsigned long off)
{
	void * result;
	struct mm_tblock_struct * tblock;
 
	if ((flags & MAP_SHARED) && (prot & PROT_WRITE) && (file)) {
		printk("MAP_SHARED not supported (cannot write mappings to disk)\n");
		return -EINVAL;
	}
 
	if ((prot & PROT_WRITE) && (flags & MAP_PRIVATE)) {
		printk("Private writable mappings not supported\n");
		return -EINVAL;
	}
 
	/*
	 * determine the object being mapped and call the appropriate
	 * specific mapper. 
	 */
 
	if (file) {
		struct vm_area_struct vma;
		int error;
 
 
		if (!file->f_op)
			return -ENODEV;
 
		vma.vm_start = addr;
		vma.vm_end = addr + len;
		vma.vm_flags = vm_flags(prot,flags) /*| mm->def_flags*/;
 
		if (file->f_mode & 1)
			vma.vm_flags |= VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;
		if (flags & MAP_SHARED) {
			vma.vm_flags |= VM_SHARED | VM_MAYSHARE;
			/*
			 * This looks strange, but when we don't have the file open
			 * for writing, we can demote the shared mapping to a simpler
			 * private mapping. That also takes care of a security hole
			 * with ptrace() writing to a shared mapping without write
			 * permissions.
			 *
			 * We leave the VM_MAYSHARE bit on, just to get correct output
			 * from /proc/xxx/maps..
			 */
			if (!(file->f_mode & 2))
				vma.vm_flags &= ~(VM_MAYWRITE | VM_SHARED);
		}
		vma.vm_offset = off;
 
#ifdef MAGIC_ROM_PTR
		/* First, try simpler routine designed to give us a ROM pointer. */
 
		if (file->f_op->romptr && !(prot & PROT_WRITE)) {
			error = file->f_op->romptr(file->f_inode, file, &vma);
			/*printk("romptr mmap returned %d /%x\n", error, vma.vm_start);*/
 
			if (!error)
				return vma.vm_start;
			else if (error != -ENOSYS)
				return error;
		} else
#endif /* MAGIC_ROM_PTR */
		/* Then try full mmap routine, which might return a RAM pointer,
		   or do something truly complicated. */
 
		if (file->f_op->mmap) {
			error = file->f_op->mmap(file->f_inode, file, &vma);
 
			/*printk("mmap mmap returned %d /%x\n", error, vma.vm_start);*/
			if (!error)
				return vma.vm_start;
			else if (error != -ENOSYS)
				return error;
		} else
			return -ENODEV; /* No mapping operations defined */
 
		/* An ENOSYS error indicates that mmap isn't possible (as opposed to
		   tried but failed) so we'll fall through to the copy. */
	}
 
	tblock = (struct mm_tblock_struct *)
                        kmalloc(sizeof(struct mm_tblock_struct), GFP_KERNEL);
	if (!tblock) {
		printk("Allocation of tblock for %lu byte allocation from process %d failed\n", len, current->pid);
		show_buffers();
		show_free_areas();
		return -ENOMEM;
	}
 
        tblock->rblock = (struct mm_rblock_struct *)
                        kmalloc(sizeof(struct mm_rblock_struct), GFP_KERNEL);
 
	if (!tblock->rblock) {
		printk("Allocation of rblock for %lu byte allocation from process %d failed\n", len, current->pid);
		show_buffers();
		show_free_areas();
		kfree(tblock);
		return -ENOMEM;
	}
 
 
	result = kmalloc(len, GFP_KERNEL);
	if (!result) {
		printk("Allocation of length %lu from process %d failed\n", len, current->pid);
		show_buffers();
		show_free_areas();
		kfree(tblock->rblock);
		kfree(tblock);
		return -ENOMEM;
	}
 
        tblock->rblock->refcount = 1;
        tblock->rblock->kblock = result;
        tblock->rblock->size = len;
 
	realalloc += ksize(result);
	askedalloc += len;
 
#ifdef WARN_ON_SLACK	
	if ((len+WARN_ON_SLACK) <= ksize(result))
		printk("Allocation of %lu bytes from process %d has %lu bytes of slack\n", len, current->pid, ksize(result)-len);
#endif
 
	if (file) {
		int error;
		int old_fs = get_fs();
        	set_fs(KERNEL_DS);
                error = file->f_op->read(file->f_inode, file, (char*)result, len);
                set_fs(old_fs);
                if (error < 0) {
                	kfree(result);
                	kfree(tblock->rblock);
                	kfree(tblock);
                	return error;
                }
                if (error<len)
	                memset(result+error, '\0', len-error);
        } else {
        	memset(result, '\0', len);
        }
 
 
        realalloc += ksize(tblock);
        askedalloc += sizeof(struct mm_tblock_struct);
 
        realalloc += ksize(tblock->rblock);
        askedalloc += sizeof(struct mm_rblock_struct);
 
        tblock->next = current->mm->tblock.next;
	current->mm->tblock.next = tblock;
 
#ifdef DEBUG
        printk("do_mmap:\n");
	show_process_blocks();
#endif	  
 
	return (unsigned long)result;
}
 
 
asmlinkage int sys_munmap(unsigned long addr, size_t len)
{
	return do_munmap(addr, len);
}
 
#ifdef DEBUG_MMAP
#undef do_munmap
int do_munmap_flf(unsigned long addr, size_t len, char * filename, int line, char*function)
{
	printk("do_munmap of %lx bytes at %x invoked from %s @%s:%d\n", ksize(addr), addr, function, filename, line);
	return do_munmap(addr,len);
}
 
#endif
 
 
/*
 * Munmap is split into 2 main parts -- this part which finds
 * what needs doing, and the areas themselves, which do the
 * work.  This now handles partial unmappings.
 * Jeremy Fitzhardine <jeremy@sw.oz.au>
 */
int do_munmap(unsigned long addr, size_t len)
{
	struct mm_tblock_struct * tblock, *tmp;
 
#ifdef MAGIC_ROM_PTR
	/* For efficiency's sake, if the pointer is obviously in ROM,
	   don't bother walking the lists to free it */
	if (is_in_rom(addr))
		return 0;
#endif
 
#ifdef DEBUG
        printk("do_munmap:\n");
#endif
 
	tmp = &current->mm->tblock;
	while ((tblock=tmp->next) && (tblock->rblock) && (tblock->rblock->kblock != (void*)addr)) 
		tmp = tblock;
 
	if (!tblock) {
	        printk("munmap of non-mmaped memory by process %d (%s): %p\n", current->pid, current->comm, (void*)addr);
	        return -EINVAL;
	}
	if(tblock->rblock)
		if(!--tblock->rblock->refcount) {
			if (tblock->rblock->kblock) {
				realalloc -= ksize(tblock->rblock->kblock);
				askedalloc -= tblock->rblock->size;
				kfree(tblock->rblock->kblock);
			}
 
			realalloc -= ksize(tblock->rblock);
			askedalloc -= sizeof(struct mm_rblock_struct);
			kfree(tblock->rblock);
		}
	tmp->next = tblock->next;
	realalloc -= ksize(tblock);
	askedalloc -= sizeof(struct mm_tblock_struct);
	kfree(tblock);
 
#ifdef DEBUG
	show_process_blocks();
#endif	  
 
	return -EINVAL;
}
 
/* Release all mmaps. */
void exit_mmap(struct mm_struct * mm)
{
        struct mm_tblock_struct * tmp = &mm->tblock;
        /*unsigned long flags;*/
 
        if (!mm)
                return;
 
	if (mm->executable)
		iput(mm->executable);
	mm->executable = 0;
 
        /*save_flags(flags); cli();*/
 
        if (mm->count > 1) {
                /*restore_flags(flags);*/
                return;
        }
 
#ifdef DEBUG
        printk("Exit_mmap:\n");
#endif
 
        while((tmp = tmp->next)) {
                if (tmp->rblock) {
                        if (!--tmp->rblock->refcount) {
                                if (tmp->rblock->kblock) {
                                        realalloc -= ksize(tmp->rblock->kblock);
                                        askedalloc -= tmp->rblock->size;
                                        kfree(tmp->rblock->kblock);
                                }
                                realalloc -= ksize(tmp->rblock);
                                askedalloc -= sizeof(struct mm_rblock_struct);
                                kfree(tmp->rblock);
                        }
                        tmp->rblock = 0;
                }
                mm->tblock.next = tmp->next;
                realalloc -= ksize(tmp);
                askedalloc -= sizeof(struct mm_tblock_struct);
                kfree(tmp);
        }
 
#ifdef DEBUG
	show_process_blocks();
#endif	  
 
        /*restore_flags(flags);*/
 
}