/*

  *  MemoryMap.cpp

  *  Ottoman

  *

  *  Created by Jens Alfke on 9/17/09.

  *  Copyright 2009 Jens Alfke. All rights reserved.

  *  BSD-Licensed: See the file "LICENSE.txt" for details.

  */

 #include "MemoryMap.h"

 #include <errno.h>

 #include <stdio.h>

 #include <sys/mman.h>

 namespace Mooseyard {

     MemoryMap::~MemoryMap() {

         for (int i=0; i<_nRegions; i++)

             delete _regions[i];

         free(_regions);

     }

     void MemoryMap::mapRegion (off_t pos, size_t length) {

         off_t end = pos+length;

         for (int i=0; i<_nRegions; i++) {

             Region *region = _regions[i];

             if (region->position() <= pos) {

                 if (end <= region->end())

                     return;     // found an existing region covering this range

                 else if (region->setLength((size_t)(end - region->position())))

                     return;     // able to grow the existing region

             }

         }

         // No existing region, so add a new one:

         Region *region = new Region(_file, pos,length);

         _regions = (Region**) realloc(_regions, (_nRegions+1)*sizeof(*_regions));

         _regions[_nRegions++] = region;

     }

     const void* MemoryMap::_at (off_t pos) const {

         for (int i=0; i<_nRegions; i++) {

             const void *ptr = _regions[i]->mappedPosition(pos);

             if (ptr)

                 return ptr;

         }

         return NULL;

     }

     const void* MemoryMap::mappedPosition (off_t pos) const {

         const void *result = _at(pos);

         if (!result)

             throw File::Error("No memory mapped at this position");

         return result;

     }

     MemoryMap::Region::Region (File* file, off_t position, size_t length)

     :_file(file),

     _position(position),

     _length (length),

     _start( (const uint8_t*) ::mmap(NULL, length, PROT_READ, MAP_PRIVATE, file->_fd, position) )

     {

         printf("File#%i: Mapped (%6llu -- %6llu) --> %p\n", file->_fd, _position, end(), _start);

         if (_start==NULL || _start == MAP_FAILED) {

             _start = NULL;

             throw File::Error(errno, strerror(errno));

         }

     }

     MemoryMap::Region::~Region() {

         if (_start) {

             printf("File#%i: Unmapped (%6llu -- %6llu) from %p\n", _file->_fd, _position, end(), _start);

             ::munmap((void*)_start,_length);

         }

     }

     bool MemoryMap::Region::setLength (size_t length) {

         if (length != _length) {

             printf("File#%i: Resiging (%6llu -- %6llu) from %lu to %lu ...", 

                    _file->_fd, _position, end(), _length,length);

             if (::mmap((void*)_start, length, PROT_READ, MAP_PRIVATE | MAP_FIXED, _file->_fd, _position) == MAP_FAILED) {

                 printf("failed! errno=%i\n", errno);

                 return false;

             }

             printf("OK\n");

             _length = length;

         }

         return true;

     }

     const void* MemoryMap::Region::mappedPosition (off_t pos) {

         if (pos >= _position && pos < end())

             return _start + (pos-_position);

         else

             return NULL;

     }

 }