Python/dynload_beos.c

/***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.

                        All Rights Reserved

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.

STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

******************************************************************/

/* Support for dynamic loading of extension modules */

#include <kernel/image.h>
#include <kernel/OS.h>
#include <stdlib.h>
#include <unistd.h>

#include "Python.h"
#include "importdl.h"

const struct filedescr _PyImport_DynLoadFiletab[] = {
	{".so", "rb", C_EXTENSION},
	{"module.so", "rb", C_EXTENSION},
	{0, 0}
};

#if defined(MAXPATHLEN) && !defined(_SYS_PARAM_H)
#undef MAXPATHLEN
#endif

#ifdef WITH_THREAD
#include "pythread.h"
static PyThread_type_lock beos_dyn_lock;
#endif

static PyObject *beos_dyn_images = NULL;

/* ----------------------------------------------------------------------
 * BeOS dynamic loading support
 *
 * This uses shared libraries, but BeOS has its own way of doing things
 * (much easier than dlfnc.h, from the look of things).  We'll use a
 * Python Dictionary object to store the images_ids so we can be very
 * nice and unload them when we exit.
 *
 * Note that this is thread-safe.  Probably irrelevent, because of losing
 * systems... Python probably disables threads while loading modules.
 * Note the use of "probably"!  Better to be safe than sorry. [chrish]
 *
 * As of 1.5.1 this should also work properly when you've configured
 * Python without thread support; the 1.5 version required it, which wasn't
 * very friendly.  Note that I haven't tested it without threading... why
 * would you want to avoid threads on BeOS? [chrish]
 *
 * As of 1.5.2, the PyImport_BeImageID() function has been removed; Donn
 * tells me it's not necessary anymore because of PyCObject_Import().
 * [chrish]
 */

/* Whack an item; the item is an image_id in disguise, so we'll call
 * unload_add_on() for it.
 */
static void beos_nuke_dyn( PyObject *item )
{
	status_t retval;

	if( item ) {
		image_id id = (image_id)PyInt_AsLong( item );
		
		retval = unload_add_on( id );
	}
}

/* atexit() handler that'll call unload_add_on() for every item in the
 * dictionary.
 */
static void beos_cleanup_dyn( void )
{
	if( beos_dyn_images ) {
		int idx;
		int list_size;
		PyObject *id_list;

#ifdef WITH_THREAD
		PyThread_acquire_lock( beos_dyn_lock, 1 );
#endif

		id_list = PyDict_Values( beos_dyn_images );

		list_size = PyList_Size( id_list );
		for( idx = 0; idx < list_size; idx++ ) {
			PyObject *the_item;
			
			the_item = PyList_GetItem( id_list, idx );
			beos_nuke_dyn( the_item );
		}

		PyDict_Clear( beos_dyn_images );

#ifdef WITH_THREAD
		PyThread_free_lock( beos_dyn_lock );
#endif
	}
}

/*
 * Initialize our dictionary, and the dictionary mutex.
 */
static void beos_init_dyn( void )
{
	/* We're protected from a race condition here by the atomic init_count
	 * variable.
	 */
	static int32 init_count = 0;
	int32 val;

	val = atomic_add( &init_count, 1 );
	if( beos_dyn_images == NULL && val == 0 ) {
		beos_dyn_images = PyDict_New();
#ifdef WITH_THREAD
		beos_dyn_lock = PyThread_allocate_lock();
#endif
		atexit( beos_cleanup_dyn );
	}
}

/*
 * Add an image_id to the dictionary; the module name of the loaded image
 * is the key.  Note that if the key is already in the dict, we unload
 * that image; this should allow reload() to work on dynamically loaded
 * modules (super-keen!).
 */
static void beos_add_dyn( char *name, image_id id )
{
	int retval;
	PyObject *py_id;

	if( beos_dyn_images == NULL ) {
		beos_init_dyn();
	}

#ifdef WITH_THREAD
	retval = PyThread_acquire_lock( beos_dyn_lock, 1 );
#endif

	/* If there's already an object with this key in the dictionary,
	 * we're doing a reload(), so let's nuke it.
	 */
	py_id = PyDict_GetItemString( beos_dyn_images, name );
	if( py_id ) {
		beos_nuke_dyn( py_id );
		retval = PyDict_DelItemString( beos_dyn_images, name );
	}

	py_id = PyInt_FromLong( (long)id );
	if( py_id ) {
		retval = PyDict_SetItemString( beos_dyn_images, name, py_id );
	}

#ifdef WITH_THREAD
	PyThread_release_lock( beos_dyn_lock );
#endif
}



dl_funcptr _PyImport_GetDynLoadFunc(const char *name, const char *funcname,
				    const char *pathname, FILE *fp)
{
	dl_funcptr p;
	image_id the_id;
	status_t retval;
	char fullpath[PATH_MAX];

	if( Py_VerboseFlag ) {
		printf( "load_add_on( %s )\n", pathname );
	}

	/* Hmm, this old bug appears to have regenerated itself; if the
	 * path isn't absolute, load_add_on() will fail.  Reported to Be
	 * April 21, 1998.
	 */
	if( pathname[0] != '/' ) {
		(void)getcwd( fullpath, PATH_MAX );
		(void)strncat( fullpath, "/", PATH_MAX );
		(void)strncat( fullpath, pathname, PATH_MAX );
			
		if( Py_VerboseFlag ) {
			printf( "load_add_on( %s )\n", fullpath );
		}
	} else {
		(void)strcpy( fullpath, pathname );
	}

	the_id = load_add_on( fullpath );
	if( the_id < B_NO_ERROR ) {
		/* It's too bad load_add_on() doesn't set errno or something...
		 */
		char buff[256];  /* hate hard-coded string sizes... */

		if( Py_VerboseFlag ) {
			printf( "load_add_on( %s ) failed", fullpath );
		}

		switch( the_id ) {
		case B_ERROR:
			sprintf( buff, "BeOS: Failed to load %.200s", fullpath );
			break;
		default:
			sprintf( buff, "Unknown error loading %.200s", fullpath );
			break;
		}

		PyErr_SetString( PyExc_ImportError, buff );
		return NULL;
	}

	if( Py_VerboseFlag ) {
		printf( "get_image_symbol( %s )\n", funcname );
	}

	retval = get_image_symbol( the_id, funcname, B_SYMBOL_TYPE_TEXT, &p );
	if( retval != B_NO_ERROR || p == NULL ) {
		/* That's bad, we can't find that symbol in the module...
		 */
		char buff[256];  /* hate hard-coded string sizes... */

		if( Py_VerboseFlag ) {
			printf( "get_image_symbol( %s ) failed", funcname );
		}

		switch( retval ) {
		case B_BAD_IMAGE_ID:
			sprintf( buff, "can't load init function for dynamic module: "
			               "Invalid image ID for %.180s", fullpath );
			break;
		case B_BAD_INDEX:
			sprintf( buff, "can't load init function for dynamic module: "
			               "Bad index for %.180s", funcname );
			break;
		default:
			sprintf( buff, "can't load init function for dynamic module: "
			               "Unknown error looking up %.180s", funcname );
			break;
		}

		retval = unload_add_on( the_id );

		PyErr_SetString( PyExc_ImportError, buff );
		return NULL;
	}

	/* Save the module name and image ID for later so we can clean up
	 * gracefully.
	 */
	beos_add_dyn( name, the_id );

	return p;
}