diff options
Diffstat (limited to 'mmalloc/mmap-sup.c')
| -rw-r--r-- | mmalloc/mmap-sup.c | 205 |
1 files changed, 205 insertions, 0 deletions
diff --git a/mmalloc/mmap-sup.c b/mmalloc/mmap-sup.c new file mode 100644 index 00000000000..f278789808e --- /dev/null +++ b/mmalloc/mmap-sup.c @@ -0,0 +1,205 @@ +/* Support for an sbrk-like function that uses mmap. + Copyright 1992 Free Software Foundation, Inc. + + Contributed by Fred Fish at Cygnus Support. fnf@cygnus.com + +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#if defined(HAVE_MMAP) + +#include <stdio.h> +#include <fcntl.h> +#include <sys/mman.h> + +#ifndef SEEK_SET +#define SEEK_SET 0 +#endif + +#include "mmprivate.h" + +/* Cache the pagesize for the current host machine. Note that if the host + does not readily provide a getpagesize() function, we need to emulate it + elsewhere, not clutter up this file with lots of kluges to try to figure + it out. */ + +static size_t pagesize; +extern int getpagesize PARAMS ((void)); + +#define PAGE_ALIGN(addr) (caddr_t) (((long)(addr) + pagesize - 1) & \ + ~(pagesize - 1)) + +/* Get core for the memory region specified by MDP, using SIZE as the + amount to either add to or subtract from the existing region. Works + like sbrk(), but using mmap(). */ + +PTR +__mmalloc_mmap_morecore (mdp, size) + struct mdesc *mdp; + int size; +{ + PTR result = NULL; + off_t foffset; /* File offset at which new mapping will start */ + size_t mapbytes; /* Number of bytes to map */ + caddr_t moveto; /* Address where we wish to move "break value" to */ + caddr_t mapto; /* Address we actually mapped to */ + char buf = 0; /* Single byte to write to extend mapped file */ + + if (pagesize == 0) + { + pagesize = getpagesize (); + } + if (size == 0) + { + /* Just return the current "break" value. */ + result = mdp -> breakval; + } + else if (size < 0) + { + /* We are deallocating memory. If the amount requested would cause + us to try to deallocate back past the base of the mmap'd region + then do nothing, and return NULL. Otherwise, deallocate the + memory and return the old break value. */ + if (mdp -> breakval + size >= mdp -> base) + { + result = (PTR) mdp -> breakval; + mdp -> breakval += size; + moveto = PAGE_ALIGN (mdp -> breakval); + munmap (moveto, (size_t) (mdp -> top - moveto)); + mdp -> top = moveto; + } + } + else + { + /* We are allocating memory. Make sure we have an open file + descriptor and then go on to get the memory. */ + if (mdp -> fd < 0) + { + result = NULL; + } + else if (mdp -> breakval + size > mdp -> top) + { + /* The request would move us past the end of the currently + mapped memory, so map in enough more memory to satisfy + the request. This means we also have to grow the mapped-to + file by an appropriate amount, since mmap cannot be used + to extend a file. */ + moveto = PAGE_ALIGN (mdp -> breakval + size); + mapbytes = moveto - mdp -> top; + foffset = mdp -> top - mdp -> base; + /* FIXME: Test results of lseek() and write() */ + lseek (mdp -> fd, foffset + mapbytes - 1, SEEK_SET); + write (mdp -> fd, &buf, 1); + if (mdp -> base == 0) + { + /* Let mmap pick the map start address */ + mapto = mmap (0, mapbytes, PROT_READ | PROT_WRITE, + MAP_SHARED, mdp -> fd, foffset); + if (mapto != (caddr_t) -1) + { + mdp -> base = mdp -> breakval = mapto; + mdp -> top = mdp -> base + mapbytes; + result = (PTR) mdp -> breakval; + mdp -> breakval += size; + } + } + else + { + mapto = mmap (mdp -> top, mapbytes, PROT_READ | PROT_WRITE, + MAP_SHARED | MAP_FIXED, mdp -> fd, foffset); + if (mapto == mdp -> top) + { + mdp -> top = moveto; + result = (PTR) mdp -> breakval; + mdp -> breakval += size; + } + } + } + else + { + result = (PTR) mdp -> breakval; + mdp -> breakval += size; + } + } + return (result); +} + +PTR +__mmalloc_remap_core (mdp) + struct mdesc *mdp; +{ + caddr_t base; + + /* FIXME: Quick hack, needs error checking and other attention. */ + + base = mmap (mdp -> base, mdp -> top - mdp -> base, + PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, + mdp -> fd, 0); + return ((PTR) base); +} + +PTR +mmalloc_findbase (size) + int size; +{ + int fd; + int flags; + caddr_t base = NULL; + +#ifdef MAP_ANONYMOUS + flags = MAP_SHARED | MAP_ANONYMOUS; + fd = -1; +#else +#ifdef MAP_FILE + flags = MAP_SHARED | MAP_FILE; +#else + flags = MAP_SHARED; +#endif + fd = open ("/dev/zero", O_RDWR); + if (fd != -1) + { + return ((PTR) NULL); + } +#endif + base = mmap (0, size, PROT_READ | PROT_WRITE, flags, fd, 0); + if (base != (caddr_t) -1) + { + munmap (base, (size_t) size); + } + if (fd != -1) + { + close (fd); + } + if (base == 0) + { + /* Don't allow mapping at address zero. We use that value + to signal an error return, and besides, it is useful to + catch NULL pointers if it is unmapped. Instead start + at the next page boundary. */ + base = (caddr_t) getpagesize (); + } + else if (base == (caddr_t) -1) + { + base = NULL; + } + return ((PTR) base); +} + +#else /* defined(HAVE_MMAP) */ +/* Prevent "empty translation unit" warnings from the idiots at X3J11. */ +static char ansi_c_idiots = 69; +#endif /* defined(HAVE_MMAP) */ |