cpython/Modules/mmapmodule.c

1187 lines
28 KiB
C
Raw Normal View History

/*
/ Author: Sam Rushing <rushing@nightmare.com>
2001-11-05 17:25:42 -04:00
/ Hacked for Unix by AMK
/ $Id$
/ mmapmodule.cpp -- map a view of a file into memory
/
/ todo: need permission flags, perhaps a 'chsize' analog
/ not all functions check range yet!!!
/
/
/ This version of mmapmodule.c has been changed significantly
/ from the original mmapfile.c on which it was based.
/ The original version of mmapfile is maintained by Sam at
/ ftp://squirl.nightmare.com/pub/python/python-ext.
*/
2006-02-17 02:59:14 -04:00
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#ifndef MS_WINDOWS
#define UNIX
#endif
#ifdef MS_WINDOWS
#include <windows.h>
static int
my_getpagesize(void)
{
SYSTEM_INFO si;
GetSystemInfo(&si);
return si.dwPageSize;
}
#endif
#ifdef UNIX
#include <sys/mman.h>
#include <sys/stat.h>
#if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
static int
my_getpagesize(void)
{
return sysconf(_SC_PAGESIZE);
}
#else
#define my_getpagesize getpagesize
#endif
#endif /* UNIX */
#include <string.h>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
2006-02-16 04:08:54 -04:00
/* Prefer MAP_ANONYMOUS since MAP_ANON is deprecated according to man page. */
#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
# define MAP_ANONYMOUS MAP_ANON
#endif
static PyObject *mmap_module_error;
typedef enum
{
ACCESS_DEFAULT,
ACCESS_READ,
ACCESS_WRITE,
ACCESS_COPY
} access_mode;
typedef struct {
PyObject_HEAD
char * data;
size_t size;
size_t pos;
#ifdef MS_WINDOWS
HANDLE map_handle;
HANDLE file_handle;
char * tagname;
#endif
#ifdef UNIX
int fd;
#endif
access_mode access;
} mmap_object;
static void
mmap_object_dealloc(mmap_object *m_obj)
{
#ifdef MS_WINDOWS
if (m_obj->data != NULL)
UnmapViewOfFile (m_obj->data);
if (m_obj->map_handle != INVALID_HANDLE_VALUE)
CloseHandle (m_obj->map_handle);
if (m_obj->file_handle != INVALID_HANDLE_VALUE)
CloseHandle (m_obj->file_handle);
if (m_obj->tagname)
PyMem_Free(m_obj->tagname);
#endif /* MS_WINDOWS */
#ifdef UNIX
if (m_obj->fd >= 0)
(void) close(m_obj->fd);
if (m_obj->data!=NULL) {
2000-06-18 01:25:08 -03:00
msync(m_obj->data, m_obj->size, MS_SYNC);
munmap(m_obj->data, m_obj->size);
}
#endif /* UNIX */
PyObject_Del(m_obj);
}
static PyObject *
mmap_close_method(mmap_object *self, PyObject *unused)
{
#ifdef MS_WINDOWS
/* For each resource we maintain, we need to check
2006-02-16 19:47:20 -04:00
the value is valid, and if so, free the resource
and set the member value to an invalid value so
the dealloc does not attempt to resource clearing
again.
TODO - should we check for errors in the close operations???
*/
if (self->data != NULL) {
UnmapViewOfFile(self->data);
self->data = NULL;
}
if (self->map_handle != INVALID_HANDLE_VALUE) {
CloseHandle(self->map_handle);
self->map_handle = INVALID_HANDLE_VALUE;
}
if (self->file_handle != INVALID_HANDLE_VALUE) {
CloseHandle(self->file_handle);
self->file_handle = INVALID_HANDLE_VALUE;
}
#endif /* MS_WINDOWS */
#ifdef UNIX
(void) close(self->fd);
self->fd = -1;
if (self->data != NULL) {
munmap(self->data, self->size);
self->data = NULL;
}
#endif
Py_INCREF(Py_None);
return Py_None;
}
#ifdef MS_WINDOWS
#define CHECK_VALID(err) \
do { \
if (self->map_handle == INVALID_HANDLE_VALUE) { \
PyErr_SetString(PyExc_ValueError, "mmap closed or invalid"); \
return err; \
} \
} while (0)
#endif /* MS_WINDOWS */
#ifdef UNIX
#define CHECK_VALID(err) \
do { \
if (self->data == NULL) { \
PyErr_SetString(PyExc_ValueError, "mmap closed or invalid"); \
return err; \
} \
} while (0)
#endif /* UNIX */
static PyObject *
mmap_read_byte_method(mmap_object *self,
PyObject *unused)
{
CHECK_VALID(NULL);
if (self->pos < self->size) {
char value = self->data[self->pos];
self->pos += 1;
return Py_BuildValue("c", value);
} else {
PyErr_SetString(PyExc_ValueError, "read byte out of range");
return NULL;
}
}
static PyObject *
mmap_read_line_method(mmap_object *self,
PyObject *unused)
{
char *start = self->data+self->pos;
char *eof = self->data+self->size;
char *eol;
PyObject *result;
CHECK_VALID(NULL);
eol = memchr(start, '\n', self->size - self->pos);
if (!eol)
eol = eof;
else
++eol; /* we're interested in the position after the
newline. */
result = PyString_FromStringAndSize(start, (eol - start));
self->pos += (eol - start);
return result;
}
static PyObject *
mmap_read_method(mmap_object *self,
PyObject *args)
{
2006-02-16 10:30:23 -04:00
Py_ssize_t num_bytes;
PyObject *result;
CHECK_VALID(NULL);
2006-02-16 10:30:23 -04:00
if (!PyArg_ParseTuple(args, "n:read", &num_bytes))
return(NULL);
/* silently 'adjust' out-of-range requests */
if ((self->pos + num_bytes) > self->size) {
num_bytes -= (self->pos+num_bytes) - self->size;
}
result = Py_BuildValue("s#", self->data+self->pos, num_bytes);
2006-02-16 19:47:20 -04:00
self->pos += num_bytes;
return result;
}
static PyObject *
mmap_find_method(mmap_object *self,
PyObject *args)
{
2006-02-16 10:30:23 -04:00
Py_ssize_t start = self->pos;
char *needle;
2006-02-17 02:59:14 -04:00
Py_ssize_t len;
CHECK_VALID(NULL);
if (!PyArg_ParseTuple(args, "s#|n:find", &needle, &len, &start)) {
return NULL;
} else {
char *p;
char *e = self->data + self->size;
if (start < 0)
start += self->size;
if (start < 0)
start = 0;
else if ((size_t)start > self->size)
start = self->size;
for (p = self->data + start; p + len <= e; ++p) {
2006-02-17 02:59:14 -04:00
Py_ssize_t i;
for (i = 0; i < len && needle[i] == p[i]; ++i)
/* nothing */;
if (i == len) {
2006-02-17 02:59:14 -04:00
return PyInt_FromSsize_t(p - self->data);
}
}
2006-02-17 02:59:14 -04:00
return PyInt_FromLong(-1);
}
}
2006-02-16 19:47:20 -04:00
static int
is_writeable(mmap_object *self)
{
if (self->access != ACCESS_READ)
2006-02-16 19:47:20 -04:00
return 1;
PyErr_Format(PyExc_TypeError, "mmap can't modify a readonly memory map.");
return 0;
}
2006-02-16 19:47:20 -04:00
static int
is_resizeable(mmap_object *self)
{
if ((self->access == ACCESS_WRITE) || (self->access == ACCESS_DEFAULT))
2006-02-16 19:47:20 -04:00
return 1;
PyErr_Format(PyExc_TypeError,
"mmap can't resize a readonly or copy-on-write memory map.");
return 0;
}
static PyObject *
mmap_write_method(mmap_object *self,
PyObject *args)
{
2006-02-17 02:59:14 -04:00
Py_ssize_t length;
char *data;
CHECK_VALID(NULL);
if (!PyArg_ParseTuple(args, "s#:write", &data, &length))
return(NULL);
if (!is_writeable(self))
return NULL;
if ((self->pos + length) > self->size) {
PyErr_SetString(PyExc_ValueError, "data out of range");
return NULL;
}
memcpy(self->data+self->pos, data, length);
self->pos = self->pos+length;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
mmap_write_byte_method(mmap_object *self,
PyObject *args)
{
char value;
CHECK_VALID(NULL);
if (!PyArg_ParseTuple(args, "c:write_byte", &value))
return(NULL);
if (!is_writeable(self))
return NULL;
*(self->data+self->pos) = value;
self->pos += 1;
Py_INCREF(Py_None);
return Py_None;
}
2006-02-16 19:47:20 -04:00
static PyObject *
mmap_size_method(mmap_object *self,
PyObject *unused)
{
CHECK_VALID(NULL);
#ifdef MS_WINDOWS
if (self->file_handle != INVALID_HANDLE_VALUE) {
2006-02-18 08:38:35 -04:00
DWORD low,high;
PY_LONG_LONG size;
low = GetFileSize(self->file_handle, &high);
if (low == INVALID_FILE_SIZE) {
/* It might be that the function appears to have failed,
when indeed its size equals INVALID_FILE_SIZE */
DWORD error = GetLastError();
if (error != NO_ERROR)
return PyErr_SetFromWindowsErr(error);
}
if (!high && low < LONG_MAX)
return PyInt_FromLong((long)low);
size = (((PY_LONG_LONG)high)<<32) + low;
return PyLong_FromLongLong(size);
} else {
2006-02-18 08:38:35 -04:00
return PyInt_FromSsize_t(self->size);
}
#endif /* MS_WINDOWS */
#ifdef UNIX
{
struct stat buf;
if (-1 == fstat(self->fd, &buf)) {
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
2006-02-18 08:38:35 -04:00
return PyInt_FromSsize_t(buf.st_size);
}
#endif /* UNIX */
}
/* This assumes that you want the entire file mapped,
/ and when recreating the map will make the new file
/ have the new size
/
/ Is this really necessary? This could easily be done
/ from python by just closing and re-opening with the
/ new size?
*/
static PyObject *
mmap_resize_method(mmap_object *self,
PyObject *args)
{
2006-02-17 02:59:14 -04:00
Py_ssize_t new_size;
CHECK_VALID(NULL);
2006-02-17 02:59:14 -04:00
if (!PyArg_ParseTuple(args, "n:resize", &new_size) ||
!is_resizeable(self)) {
return NULL;
#ifdef MS_WINDOWS
2006-02-16 19:47:20 -04:00
} else {
DWORD dwErrCode = 0;
2006-02-18 08:38:35 -04:00
DWORD newSizeLow, newSizeHigh;
/* First, unmap the file view */
UnmapViewOfFile(self->data);
/* Close the mapping object */
CloseHandle(self->map_handle);
/* Move to the desired EOF position */
2006-02-18 08:38:35 -04:00
#if SIZEOF_SIZE_T > 4
newSizeHigh = (DWORD)(new_size >> 32);
newSizeLow = (DWORD)(new_size & 0xFFFFFFFF);
#else
newSizeHigh = 0;
2006-02-18 08:49:49 -04:00
newSizeLow = (DWORD)new_size;
2006-02-18 08:38:35 -04:00
#endif
SetFilePointer(self->file_handle,
2006-02-18 08:38:35 -04:00
newSizeLow, &newSizeHigh, FILE_BEGIN);
/* Change the size of the file */
SetEndOfFile(self->file_handle);
/* Create another mapping object and remap the file view */
self->map_handle = CreateFileMapping(
self->file_handle,
NULL,
PAGE_READWRITE,
2006-02-18 08:38:35 -04:00
newSizeHigh,
newSizeLow,
self->tagname);
if (self->map_handle != NULL) {
self->data = (char *) MapViewOfFile(self->map_handle,
FILE_MAP_WRITE,
0,
0,
0);
if (self->data != NULL) {
self->size = new_size;
Py_INCREF(Py_None);
return Py_None;
} else {
dwErrCode = GetLastError();
}
} else {
dwErrCode = GetLastError();
}
PyErr_SetFromWindowsErr(dwErrCode);
return NULL;
#endif /* MS_WINDOWS */
#ifdef UNIX
2006-02-16 19:47:20 -04:00
#ifndef HAVE_MREMAP
} else {
PyErr_SetString(PyExc_SystemError,
"mmap: resizing not available--no mremap()");
return NULL;
#else
} else {
2005-09-20 16:04:02 -03:00
void *newmap;
if (ftruncate(self->fd, new_size) == -1) {
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
#ifdef MREMAP_MAYMOVE
newmap = mremap(self->data, self->size, new_size, MREMAP_MAYMOVE);
#else
newmap = mremap(self->data, self->size, new_size, 0);
#endif
2006-02-16 19:47:20 -04:00
if (newmap == (void *)-1)
{
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
self->data = newmap;
self->size = new_size;
Py_INCREF(Py_None);
return Py_None;
#endif /* HAVE_MREMAP */
#endif /* UNIX */
}
}
static PyObject *
mmap_tell_method(mmap_object *self, PyObject *unused)
{
CHECK_VALID(NULL);
return PyInt_FromSize_t(self->pos);
}
static PyObject *
mmap_flush_method(mmap_object *self, PyObject *args)
{
2006-02-16 10:30:23 -04:00
Py_ssize_t offset = 0;
Py_ssize_t size = self->size;
CHECK_VALID(NULL);
if (!PyArg_ParseTuple(args, "|nn:flush", &offset, &size))
return NULL;
if ((size_t)(offset + size) > self->size) {
PyErr_SetString(PyExc_ValueError, "flush values out of range");
return NULL;
} else {
#ifdef MS_WINDOWS
return PyInt_FromLong((long)
FlushViewOfFile(self->data+offset, size));
#endif /* MS_WINDOWS */
#ifdef UNIX
/* XXX semantics of return value? */
/* XXX flags for msync? */
if (-1 == msync(self->data + offset, size,
2000-06-18 01:25:08 -03:00
MS_SYNC))
{
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
return PyInt_FromLong(0);
2006-02-16 19:47:20 -04:00
#endif /* UNIX */
}
}
static PyObject *
mmap_seek_method(mmap_object *self, PyObject *args)
{
2006-02-17 02:59:14 -04:00
Py_ssize_t dist;
int how=0;
CHECK_VALID(NULL);
2006-02-17 02:59:14 -04:00
if (!PyArg_ParseTuple(args, "n|i:seek", &dist, &how))
return NULL;
else {
size_t where;
switch (how) {
case 0: /* relative to start */
if (dist < 0)
goto onoutofrange;
where = dist;
break;
case 1: /* relative to current position */
2006-02-17 02:59:14 -04:00
if ((Py_ssize_t)self->pos + dist < 0)
goto onoutofrange;
where = self->pos + dist;
break;
case 2: /* relative to end */
2006-02-17 02:59:14 -04:00
if ((Py_ssize_t)self->size + dist < 0)
goto onoutofrange;
where = self->size + dist;
break;
default:
PyErr_SetString(PyExc_ValueError, "unknown seek type");
return NULL;
}
if (where > self->size)
goto onoutofrange;
self->pos = where;
Py_INCREF(Py_None);
return Py_None;
}
onoutofrange:
PyErr_SetString(PyExc_ValueError, "seek out of range");
return NULL;
}
static PyObject *
mmap_move_method(mmap_object *self, PyObject *args)
{
unsigned long dest, src, count;
CHECK_VALID(NULL);
if (!PyArg_ParseTuple(args, "kkk:move", &dest, &src, &count) ||
!is_writeable(self)) {
return NULL;
} else {
/* bounds check the values */
if (/* end of source after end of data?? */
((src+count) > self->size)
/* dest will fit? */
|| (dest+count > self->size)) {
PyErr_SetString(PyExc_ValueError,
"source or destination out of range");
return NULL;
} else {
memmove(self->data+dest, self->data+src, count);
Py_INCREF(Py_None);
return Py_None;
}
}
}
static struct PyMethodDef mmap_object_methods[] = {
{"close", (PyCFunction) mmap_close_method, METH_NOARGS},
{"find", (PyCFunction) mmap_find_method, METH_VARARGS},
{"flush", (PyCFunction) mmap_flush_method, METH_VARARGS},
{"move", (PyCFunction) mmap_move_method, METH_VARARGS},
{"read", (PyCFunction) mmap_read_method, METH_VARARGS},
{"read_byte", (PyCFunction) mmap_read_byte_method, METH_NOARGS},
{"readline", (PyCFunction) mmap_read_line_method, METH_NOARGS},
{"resize", (PyCFunction) mmap_resize_method, METH_VARARGS},
{"seek", (PyCFunction) mmap_seek_method, METH_VARARGS},
{"size", (PyCFunction) mmap_size_method, METH_NOARGS},
{"tell", (PyCFunction) mmap_tell_method, METH_NOARGS},
{"write", (PyCFunction) mmap_write_method, METH_VARARGS},
{"write_byte", (PyCFunction) mmap_write_byte_method, METH_VARARGS},
{NULL, NULL} /* sentinel */
};
/* Functions for treating an mmap'ed file as a buffer */
2006-02-15 13:27:45 -04:00
static Py_ssize_t
mmap_buffer_getreadbuf(mmap_object *self, Py_ssize_t index, const void **ptr)
{
CHECK_VALID(-1);
if (index != 0) {
PyErr_SetString(PyExc_SystemError,
"Accessing non-existent mmap segment");
return -1;
}
*ptr = self->data;
return self->size;
}
2006-02-15 13:27:45 -04:00
static Py_ssize_t
mmap_buffer_getwritebuf(mmap_object *self, Py_ssize_t index, const void **ptr)
2006-02-16 19:47:20 -04:00
{
CHECK_VALID(-1);
if (index != 0) {
PyErr_SetString(PyExc_SystemError,
"Accessing non-existent mmap segment");
return -1;
}
if (!is_writeable(self))
return -1;
*ptr = self->data;
return self->size;
}
2006-02-15 13:27:45 -04:00
static Py_ssize_t
mmap_buffer_getsegcount(mmap_object *self, Py_ssize_t *lenp)
{
CHECK_VALID(-1);
2006-02-16 19:47:20 -04:00
if (lenp)
*lenp = self->size;
return 1;
}
2006-02-15 13:27:45 -04:00
static Py_ssize_t
mmap_buffer_getcharbuffer(mmap_object *self, Py_ssize_t index, const void **ptr)
{
if (index != 0) {
PyErr_SetString(PyExc_SystemError,
"accessing non-existent buffer segment");
return -1;
}
*ptr = (const char *)self->data;
return self->size;
}
static PyObject *
mmap_object_getattr(mmap_object *self, char *name)
{
return Py_FindMethod(mmap_object_methods, (PyObject *)self, name);
}
2006-02-15 13:27:45 -04:00
static Py_ssize_t
mmap_length(mmap_object *self)
{
CHECK_VALID(-1);
return self->size;
}
static PyObject *
2006-02-15 13:27:45 -04:00
mmap_item(mmap_object *self, Py_ssize_t i)
{
CHECK_VALID(NULL);
if (i < 0 || (size_t)i >= self->size) {
PyErr_SetString(PyExc_IndexError, "mmap index out of range");
return NULL;
}
return PyString_FromStringAndSize(self->data + i, 1);
}
static PyObject *
2006-02-15 13:27:45 -04:00
mmap_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh)
{
CHECK_VALID(NULL);
if (ilow < 0)
ilow = 0;
else if ((size_t)ilow > self->size)
ilow = self->size;
if (ihigh < 0)
ihigh = 0;
if (ihigh < ilow)
ihigh = ilow;
else if ((size_t)ihigh > self->size)
ihigh = self->size;
2006-02-16 19:47:20 -04:00
return PyString_FromStringAndSize(self->data + ilow, ihigh-ilow);
}
static PyObject *
mmap_concat(mmap_object *self, PyObject *bb)
{
CHECK_VALID(NULL);
PyErr_SetString(PyExc_SystemError,
"mmaps don't support concatenation");
return NULL;
}
static PyObject *
2006-02-15 13:27:45 -04:00
mmap_repeat(mmap_object *self, Py_ssize_t n)
{
CHECK_VALID(NULL);
PyErr_SetString(PyExc_SystemError,
"mmaps don't support repeat operation");
return NULL;
}
static int
2006-02-15 13:27:45 -04:00
mmap_ass_slice(mmap_object *self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
{
const char *buf;
CHECK_VALID(-1);
if (ilow < 0)
ilow = 0;
else if ((size_t)ilow > self->size)
ilow = self->size;
if (ihigh < 0)
ihigh = 0;
if (ihigh < ilow)
ihigh = ilow;
else if ((size_t)ihigh > self->size)
ihigh = self->size;
2006-02-16 19:47:20 -04:00
if (v == NULL) {
PyErr_SetString(PyExc_TypeError,
"mmap object doesn't support slice deletion");
return -1;
}
if (! (PyString_Check(v)) ) {
2006-02-16 19:47:20 -04:00
PyErr_SetString(PyExc_IndexError,
"mmap slice assignment must be a string");
return -1;
}
if (PyString_Size(v) != (ihigh - ilow)) {
2006-02-16 19:47:20 -04:00
PyErr_SetString(PyExc_IndexError,
"mmap slice assignment is wrong size");
return -1;
}
if (!is_writeable(self))
return -1;
buf = PyString_AsString(v);
memcpy(self->data + ilow, buf, ihigh-ilow);
return 0;
}
static int
2006-02-15 13:27:45 -04:00
mmap_ass_item(mmap_object *self, Py_ssize_t i, PyObject *v)
{
const char *buf;
2006-02-16 19:47:20 -04:00
CHECK_VALID(-1);
if (i < 0 || (size_t)i >= self->size) {
PyErr_SetString(PyExc_IndexError, "mmap index out of range");
return -1;
}
if (v == NULL) {
PyErr_SetString(PyExc_TypeError,
"mmap object doesn't support item deletion");
return -1;
}
if (! (PyString_Check(v) && PyString_Size(v)==1) ) {
2006-02-16 19:47:20 -04:00
PyErr_SetString(PyExc_IndexError,
"mmap assignment must be single-character string");
return -1;
}
if (!is_writeable(self))
return -1;
buf = PyString_AsString(v);
self->data[i] = buf[0];
return 0;
}
static PySequenceMethods mmap_as_sequence = {
2006-02-15 13:27:45 -04:00
(lenfunc)mmap_length, /*sq_length*/
(binaryfunc)mmap_concat, /*sq_concat*/
2006-02-15 13:27:45 -04:00
(ssizeargfunc)mmap_repeat, /*sq_repeat*/
(ssizeargfunc)mmap_item, /*sq_item*/
(ssizessizeargfunc)mmap_slice, /*sq_slice*/
(ssizeobjargproc)mmap_ass_item, /*sq_ass_item*/
(ssizessizeobjargproc)mmap_ass_slice, /*sq_ass_slice*/
};
static PyBufferProcs mmap_as_buffer = {
2006-02-15 13:27:45 -04:00
(readbufferproc)mmap_buffer_getreadbuf,
(writebufferproc)mmap_buffer_getwritebuf,
(segcountproc)mmap_buffer_getsegcount,
(charbufferproc)mmap_buffer_getcharbuffer,
};
static PyTypeObject mmap_object_type = {
PyObject_HEAD_INIT(0) /* patched in module init */
0, /* ob_size */
"mmap.mmap", /* tp_name */
sizeof(mmap_object), /* tp_size */
0, /* tp_itemsize */
/* methods */
(destructor) mmap_object_dealloc, /* tp_dealloc */
0, /* tp_print */
(getattrfunc) mmap_object_getattr, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
&mmap_as_sequence, /*tp_as_sequence*/
0, /*tp_as_mapping*/
0, /*tp_hash*/
0, /*tp_call*/
0, /*tp_str*/
0, /*tp_getattro*/
0, /*tp_setattro*/
&mmap_as_buffer, /*tp_as_buffer*/
Py_TPFLAGS_HAVE_GETCHARBUFFER, /*tp_flags*/
0, /*tp_doc*/
};
/* extract the map size from the given PyObject
Returns -1 on error, with an appropriate Python exception raised. On
success, the map size is returned. */
2006-02-17 02:59:14 -04:00
static Py_ssize_t
_GetMapSize(PyObject *o)
{
if (PyIndex_Check(o)) {
Py_ssize_t i = PyNumber_AsSsize_t(o, PyExc_OverflowError);
if (i==-1 && PyErr_Occurred())
return -1;
if (i < 0) {
PyErr_SetString(PyExc_OverflowError,
"memory mapped size must be positive");
return -1;
}
2006-02-17 02:59:14 -04:00
return i;
}
PyErr_SetString(PyExc_TypeError, "map size must be an integral value");
return -1;
}
2006-02-16 19:47:20 -04:00
#ifdef UNIX
static PyObject *
new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
{
#ifdef HAVE_FSTAT
struct stat st;
#endif
mmap_object *m_obj;
PyObject *map_size_obj = NULL;
2006-02-17 02:59:14 -04:00
Py_ssize_t map_size;
int fd, flags = MAP_SHARED, prot = PROT_WRITE | PROT_READ;
int devzero = -1;
int access = (int)ACCESS_DEFAULT;
2006-02-27 13:20:04 -04:00
static char *keywords[] = {"fileno", "length",
2006-02-16 19:47:20 -04:00
"flags", "prot",
"access", NULL};
2006-02-16 19:47:20 -04:00
if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|iii", keywords,
&fd, &map_size_obj, &flags, &prot,
&access))
return NULL;
map_size = _GetMapSize(map_size_obj);
if (map_size < 0)
return NULL;
2006-02-16 19:47:20 -04:00
if ((access != (int)ACCESS_DEFAULT) &&
2006-02-04 23:36:57 -04:00
((flags != MAP_SHARED) || (prot != (PROT_WRITE | PROT_READ))))
2006-02-16 19:47:20 -04:00
return PyErr_Format(PyExc_ValueError,
"mmap can't specify both access and flags, prot.");
2006-02-04 23:36:57 -04:00
switch ((access_mode)access) {
case ACCESS_READ:
flags = MAP_SHARED;
prot = PROT_READ;
break;
case ACCESS_WRITE:
flags = MAP_SHARED;
prot = PROT_READ | PROT_WRITE;
break;
case ACCESS_COPY:
flags = MAP_PRIVATE;
prot = PROT_READ | PROT_WRITE;
break;
2006-02-16 19:47:20 -04:00
case ACCESS_DEFAULT:
/* use the specified or default values of flags and prot */
break;
default:
2006-02-16 19:47:20 -04:00
return PyErr_Format(PyExc_ValueError,
"mmap invalid access parameter.");
}
#ifdef HAVE_FSTAT
# ifdef __VMS
/* on OpenVMS we must ensure that all bytes are written to the file */
fsync(fd);
# endif
if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
if (map_size == 0) {
2006-02-17 02:59:14 -04:00
map_size = st.st_size;
} else if ((size_t)map_size > st.st_size) {
2006-02-16 19:47:20 -04:00
PyErr_SetString(PyExc_ValueError,
"mmap length is greater than file size");
return NULL;
}
}
#endif
m_obj = PyObject_New(mmap_object, &mmap_object_type);
if (m_obj == NULL) {return NULL;}
m_obj->data = NULL;
m_obj->size = (size_t) map_size;
m_obj->pos = (size_t) 0;
if (fd == -1) {
m_obj->fd = -1;
/* Assume the caller wants to map anonymous memory.
This is the same behaviour as Windows. mmap.mmap(-1, size)
on both Windows and Unix map anonymous memory.
*/
#ifdef MAP_ANONYMOUS
/* BSD way to map anonymous memory */
flags |= MAP_ANONYMOUS;
#else
/* SVR4 method to map anonymous memory is to open /dev/zero */
fd = devzero = open("/dev/zero", O_RDWR);
if (devzero == -1) {
Py_DECREF(m_obj);
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
#endif
} else {
m_obj->fd = dup(fd);
if (m_obj->fd == -1) {
Py_DECREF(m_obj);
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
}
2006-02-16 19:47:20 -04:00
m_obj->data = mmap(NULL, map_size,
prot, flags,
fd, 0);
if (devzero != -1) {
close(devzero);
}
if (m_obj->data == (char *)-1) {
m_obj->data = NULL;
Py_DECREF(m_obj);
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
m_obj->access = (access_mode)access;
return (PyObject *)m_obj;
}
#endif /* UNIX */
#ifdef MS_WINDOWS
static PyObject *
new_mmap_object(PyObject *self, PyObject *args, PyObject *kwdict)
{
mmap_object *m_obj;
PyObject *map_size_obj = NULL;
2006-02-17 02:59:14 -04:00
Py_ssize_t map_size;
DWORD size_hi; /* upper 32 bits of m_obj->size */
DWORD size_lo; /* lower 32 bits of m_obj->size */
char *tagname = "";
DWORD dwErr = 0;
int fileno;
HANDLE fh = 0;
int access = (access_mode)ACCESS_DEFAULT;
DWORD flProtect, dwDesiredAccess;
2006-02-27 13:20:04 -04:00
static char *keywords[] = { "fileno", "length",
2006-02-16 19:47:20 -04:00
"tagname",
"access", NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwdict, "iO|zi", keywords,
2006-02-16 19:47:20 -04:00
&fileno, &map_size_obj,
&tagname, &access)) {
return NULL;
}
switch((access_mode)access) {
case ACCESS_READ:
flProtect = PAGE_READONLY;
dwDesiredAccess = FILE_MAP_READ;
break;
case ACCESS_DEFAULT: case ACCESS_WRITE:
flProtect = PAGE_READWRITE;
dwDesiredAccess = FILE_MAP_WRITE;
break;
case ACCESS_COPY:
flProtect = PAGE_WRITECOPY;
dwDesiredAccess = FILE_MAP_COPY;
break;
default:
2006-02-16 19:47:20 -04:00
return PyErr_Format(PyExc_ValueError,
"mmap invalid access parameter.");
}
map_size = _GetMapSize(map_size_obj);
if (map_size < 0)
return NULL;
2006-02-16 19:47:20 -04:00
/* assume -1 and 0 both mean invalid filedescriptor
to 'anonymously' map memory.
XXX: fileno == 0 is a valid fd, but was accepted prior to 2.5.
XXX: Should this code be added?
if (fileno == 0)
PyErr_Warn(PyExc_DeprecationWarning,
"don't use 0 for anonymous memory");
*/
if (fileno != -1 && fileno != 0) {
fh = (HANDLE)_get_osfhandle(fileno);
if (fh==(HANDLE)-1) {
PyErr_SetFromErrno(mmap_module_error);
return NULL;
}
/* Win9x appears to need us seeked to zero */
lseek(fileno, 0, SEEK_SET);
}
m_obj = PyObject_New(mmap_object, &mmap_object_type);
if (m_obj == NULL)
return NULL;
/* Set every field to an invalid marker, so we can safely
destruct the object in the face of failure */
m_obj->data = NULL;
m_obj->file_handle = INVALID_HANDLE_VALUE;
m_obj->map_handle = INVALID_HANDLE_VALUE;
m_obj->tagname = NULL;
if (fh) {
/* It is necessary to duplicate the handle, so the
Python code can close it on us */
if (!DuplicateHandle(
GetCurrentProcess(), /* source process handle */
fh, /* handle to be duplicated */
GetCurrentProcess(), /* target proc handle */
(LPHANDLE)&m_obj->file_handle, /* result */
0, /* access - ignored due to options value */
FALSE, /* inherited by child processes? */
DUPLICATE_SAME_ACCESS)) { /* options */
dwErr = GetLastError();
Py_DECREF(m_obj);
PyErr_SetFromWindowsErr(dwErr);
return NULL;
}
if (!map_size) {
2006-02-18 08:38:35 -04:00
DWORD low,high;
low = GetFileSize(fh, &high);
/* low might just happen to have the value INVALID_FILE_SIZE;
so we need to check the last error also. */
if (low == INVALID_FILE_SIZE &&
(dwErr = GetLastError()) != NO_ERROR) {
Py_DECREF(m_obj);
return PyErr_SetFromWindowsErr(dwErr);
}
#if SIZEOF_SIZE_T > 4
m_obj->size = (((size_t)high)<<32) + low;
#else
if (high)
/* File is too large to map completely */
m_obj->size = (size_t)-1;
else
m_obj->size = low;
#endif
} else {
m_obj->size = map_size;
}
}
else {
m_obj->size = map_size;
}
/* set the initial position */
m_obj->pos = (size_t) 0;
/* set the tag name */
if (tagname != NULL && *tagname != '\0') {
m_obj->tagname = PyMem_Malloc(strlen(tagname)+1);
if (m_obj->tagname == NULL) {
PyErr_NoMemory();
Py_DECREF(m_obj);
return NULL;
}
strcpy(m_obj->tagname, tagname);
}
else
m_obj->tagname = NULL;
m_obj->access = (access_mode)access;
/* DWORD is a 4-byte int. If we're on a box where size_t consumes
2006-02-17 05:59:00 -04:00
* more than 4 bytes, we need to break it apart. Else (size_t
* consumes 4 bytes), C doesn't define what happens if we shift
* right by 32, so we need different code.
*/
#if SIZEOF_SIZE_T > 4
size_hi = (DWORD)(m_obj->size >> 32);
size_lo = (DWORD)(m_obj->size & 0xFFFFFFFF);
#else
size_hi = 0;
size_lo = (DWORD)m_obj->size;
#endif
m_obj->map_handle = CreateFileMapping(m_obj->file_handle,
NULL,
flProtect,
size_hi,
size_lo,
m_obj->tagname);
if (m_obj->map_handle != NULL) {
m_obj->data = (char *) MapViewOfFile(m_obj->map_handle,
dwDesiredAccess,
0,
0,
0);
if (m_obj->data != NULL)
return (PyObject *)m_obj;
else
dwErr = GetLastError();
} else
dwErr = GetLastError();
Py_DECREF(m_obj);
PyErr_SetFromWindowsErr(dwErr);
return NULL;
}
#endif /* MS_WINDOWS */
/* List of functions exported by this module */
static struct PyMethodDef mmap_functions[] = {
2006-02-16 19:47:20 -04:00
{"mmap", (PyCFunction) new_mmap_object,
METH_VARARGS|METH_KEYWORDS},
{NULL, NULL} /* Sentinel */
};
static void
setint(PyObject *d, const char *name, long value)
{
PyObject *o = PyInt_FromLong(value);
2006-08-13 15:41:15 -03:00
if (o && PyDict_SetItemString(d, name, o) == 0) {
Py_DECREF(o);
2006-08-13 15:41:15 -03:00
}
}
PyMODINIT_FUNC
initmmap(void)
{
PyObject *dict, *module;
/* Patch the object type */
mmap_object_type.ob_type = &PyType_Type;
module = Py_InitModule("mmap", mmap_functions);
if (module == NULL)
return;
dict = PyModule_GetDict(module);
if (!dict)
return;
mmap_module_error = PyExc_EnvironmentError;
PyDict_SetItemString(dict, "error", mmap_module_error);
#ifdef PROT_EXEC
setint(dict, "PROT_EXEC", PROT_EXEC);
#endif
#ifdef PROT_READ
setint(dict, "PROT_READ", PROT_READ);
#endif
#ifdef PROT_WRITE
setint(dict, "PROT_WRITE", PROT_WRITE);
#endif
#ifdef MAP_SHARED
setint(dict, "MAP_SHARED", MAP_SHARED);
#endif
#ifdef MAP_PRIVATE
setint(dict, "MAP_PRIVATE", MAP_PRIVATE);
#endif
#ifdef MAP_DENYWRITE
setint(dict, "MAP_DENYWRITE", MAP_DENYWRITE);
#endif
#ifdef MAP_EXECUTABLE
setint(dict, "MAP_EXECUTABLE", MAP_EXECUTABLE);
#endif
#ifdef MAP_ANONYMOUS
setint(dict, "MAP_ANON", MAP_ANONYMOUS);
setint(dict, "MAP_ANONYMOUS", MAP_ANONYMOUS);
#endif
setint(dict, "PAGESIZE", (long)my_getpagesize());
setint(dict, "ACCESS_READ", ACCESS_READ);
setint(dict, "ACCESS_WRITE", ACCESS_WRITE);
setint(dict, "ACCESS_COPY", ACCESS_COPY);
}