/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Implementation of mmap/munmap/msync.
*
*/


// INCLUDE FILES

#include <e32hal.h>
#include <sys/errno.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <fcntl.h>
#include "mmapcontrollernode.h"
#include "sysreent.h"
#include "lposix.h"
#include "mmap.h"

__BEGIN_DECLS

static int ComputeMemFlag(int prot);

// -----------------------------------------------------------------------------
// Funcation name: _mmap_r
// Description: Provides mmap functionality.
// Returns:  valid address : On success
//           -1    		   : On error
// In case of error, errno value set
// -----------------------------------------------------------------------------

EXPORT_C TAny* _mmap_r(struct _reent *r, size_t len, int prot, int flags, int fildes, off_t offset)
{	
	TInt pageSize = -1;	
	UserHal::PageSizeInBytes(pageSize);	
	size_t lpagesize = pageSize;/*getpagesize();*/
	int lshmflg;
	void* lmapaddr=NULL;
	int lfileflg;
	size_t maplen;
	
	if((0 == len) || (!(flags & MAP_PRIVATE) && !(flags & MAP_SHARED)))
	{
		r->_errno = EINVAL;
		return MAP_FAILED;
	}	
	else
	{
		/*Align len to page boundry*/
		size_t ltemp;
		maplen = len;
		ltemp = (len / lpagesize);
		if(len % lpagesize)
		{			
			len = (ltemp * lpagesize) + lpagesize;
		}		 	
	}
	/* validate fd */
	long anArg = 0L;
	int aErrno = 0;
	lfileflg = _fcntl_r(&aErrno, fildes, F_GETFL, anArg); 
	if((-1 ==  lfileflg) || (-1 == fildes))	
	{
		r->_errno = EBADF;
		return MAP_FAILED;
	}
	/* offset should be page aligned */	
	if(offset % lpagesize)
	{			
		r->_errno = EINVAL;
		return MAP_FAILED;
	}
	/* MAP_FIXED is not supported*/		
	if(!(MAP_FIXED & flags))	
	{	
		if(((O_RDONLY == lfileflg) && (PROT_WRITE & prot) && (MAP_SHARED & flags)) \
		 || (O_WRONLY == lfileflg))
		{
			r->_errno = EACCES;
			return MAP_FAILED;	
		}
		lshmflg = ComputeMemFlag(prot);		
		if(lshmflg)
		{
			/* check for any leave */	
			TRAPD(err, lmapaddr = CMmapControllerNode::AddMmapNodeL(r, len, flags, lshmflg, fildes, offset, maplen));
	            	if(err != KErrNone)
	            	{
	                	MapError(err, r->_errno);
	                	return MAP_FAILED;
	            	}
			if(((void *)-1) == lmapaddr)
			{					
				return MAP_FAILED;	
			}
			else
			{				
				return lmapaddr;
			}
		}
		else
		{				
			r->_errno = ENOTSUP;
			return MAP_FAILED;
		}
	}
	else
	{
		r->_errno = ENOTSUP;
		return MAP_FAILED;
	}
		        
}


// -----------------------------------------------------------------------------
// Funcation name: _munmap_r
// Description: Provides munmap functionality.
// Returns:   0 : On success
//           -1 : On error
// In case of error, errno value set
// Remark: support for unmapping part of the mapped pages is not supported
//         Unmap will remove all mappings those were mapped starting from the offset
//         to offset + len (refer to mmap signature)  
// -----------------------------------------------------------------------------

EXPORT_C int _munmap_r(struct _reent *r, void *addr, size_t len)
{
	int retval = -1;
	if(0 != len)
	{
		CMmapControllerNode* lmemcontrol = (CMmapControllerNode*)r->_memaddr;
		if(lmemcontrol)
		{
			retval = lmemcontrol->DeleteMmapNode(addr, r->_errno);
		}		
	}	
	else
	{
		r->_errno = EINVAL;
		retval = -1;
	}	
	return retval;
}



// -----------------------------------------------------------------------------
// Funcation name: _msync_r
// Description: Provides msync functionality.
// Returns:   0 : On success
//           -1 : On error
// In case of error, errno value set
// -----------------------------------------------------------------------------

EXPORT_C int _msync_r(struct _reent *r, void *addr, size_t len, int flags)
{
	int retval = -1;
	CMmapControllerNode* lmemcontrol = (CMmapControllerNode*)r->_memaddr;	
	
	if(lmemcontrol)
	{
		retval = lmemcontrol->SyncMmapNode(addr, len, flags, r->_errno);
	}
	else
	{
		r->_errno = ENOMEM;
		retval = -1;
	}
	return retval;
	
}


// -----------------------------------------------------------------------------
// Funcation name: _mprotect_r
// Description: Provides msync functionality.
// Returns:   0 : On success
//           -1 : On error
// In case of error, errno value set
// Remark: mprotect is only build enabled and not functional     
// -----------------------------------------------------------------------------

EXPORT_C int _mprotect_r(struct _reent *r, const void *addr, size_t len, int prot)
{
	int retval = -1;
	CMmapControllerNode* lmemcontrol = (CMmapControllerNode*)r->_memaddr;	
	
	if(lmemcontrol)
	{
		retval = lmemcontrol->ChprotMmapNode(addr, len, prot, r->_errno);
	}	
	else
	{
		r->_errno = EINVAL;
		retval = -1;
	}
	return retval;
}


/*------------------------------------------------------------------------------
 *                 LOCAL FUNCTIONS
 *------------------------------------------------------------------------------
 */
 
static int ComputeMemFlag(int prot)
{
	int lshmflg = 0;
	switch(prot)
	{
	/* A read/write/exec here would mean read/write/exec for owner alone, 
	 * as "group and others" concept are not supported by the platform
	 * exec-only will not supported since memory execution is not 
	 * supported by the platform. Everything else is translated to read/write
	 * since shared memory (used internally by mmap) supports only read/write 
	 * mode.
	 */ 
	case PROT_READ:
	case PROT_WRITE:
	case PROT_WRITE | PROT_READ:
	case PROT_READ  | PROT_EXEC:
	case PROT_WRITE | PROT_EXEC:
	case PROT_WRITE | PROT_READ | PROT_EXEC:
		lshmflg = lshmflg | S_IRWXU | IPC_CREAT | IPC_EXCL;
		break;				
	case PROT_NONE:
	case PROT_EXEC:
	default:		
		break;
	}
	return lshmflg;
}

    
__END_DECLS
//  End of File