Python/dynload_beos.c

   1
   2 /* Support for dynamic loading of extension modules */
   3
   4 #include <kernel/image.h>
   5 #include <kernel/OS.h>
   6 #include <stdlib.h>
   7
   8 #include "Python.h"
   9 #include "importdl.h"
  10
  11 const struct filedescr _PyImport_DynLoadFiletab[] = {
  12         {".so", "rb", C_EXTENSION},
  13         {"module.so", "rb", C_EXTENSION},
  14         {0, 0}
  15 };
  16
  17 #if defined(MAXPATHLEN) && !defined(_SYS_PARAM_H)
  18 #undef MAXPATHLEN
  19 #endif
  20
  21 #ifdef WITH_THREAD
  22 #include "pythread.h"
  23 static PyThread_type_lock beos_dyn_lock;
  24 #endif
  25
  26 static PyObject *beos_dyn_images = NULL;
  27
  28 /* ----------------------------------------------------------------------
  29  * BeOS dynamic loading support
  30  *
  31  * This uses shared libraries, but BeOS has its own way of doing things
  32  * (much easier than dlfnc.h, from the look of things).  We'll use a
  33  * Python Dictionary object to store the images_ids so we can be very
  34  * nice and unload them when we exit.
  35  *
  36  * Note that this is thread-safe.  Probably irrelevent, because of losing
  37  * systems... Python probably disables threads while loading modules.
  38  * Note the use of "probably"!  Better to be safe than sorry. [chrish]
  39  *
  40  * As of 1.5.1 this should also work properly when you've configured
  41  * Python without thread support; the 1.5 version required it, which wasn't
  42  * very friendly.  Note that I haven't tested it without threading... why
  43  * would you want to avoid threads on BeOS? [chrish]
  44  *
  45  * As of 1.5.2, the PyImport_BeImageID() function has been removed; Donn
  46  * tells me it's not necessary anymore because of PyCObject_Import().
  47  * [chrish]
  48  */
  49
  50 /* Whack an item; the item is an image_id in disguise, so we'll call
  51  * unload_add_on() for it.
  52  */
  53 static void beos_nuke_dyn( PyObject *item )
  54 {
  55         status_t retval;
  56
  57         if( item ) {
  58                 image_id id = (image_id)PyInt_AsLong( item );
  59
  60                 retval = unload_add_on( id );
  61         }
  62 }
  63
  64 /* atexit() handler that'll call unload_add_on() for every item in the
  65  * dictionary.
  66  */
  67 static void beos_cleanup_dyn( void )
  68 {
  69         if( beos_dyn_images ) {
  70                 int idx;
  71                 int list_size;
  72                 PyObject *id_list;
  73
  74 #ifdef WITH_THREAD
  75                 PyThread_acquire_lock( beos_dyn_lock, 1 );
  76 #endif
  77
  78                 id_list = PyDict_Values( beos_dyn_images );
  79
  80                 list_size = PyList_Size( id_list );
  81                 for( idx = 0; idx < list_size; idx++ ) {
  82                         PyObject *the_item;
  83
  84                         the_item = PyList_GetItem( id_list, idx );
  85                         beos_nuke_dyn( the_item );
  86                 }
  87
  88                 PyDict_Clear( beos_dyn_images );
  89
  90 #ifdef WITH_THREAD
  91                 PyThread_free_lock( beos_dyn_lock );
  92 #endif
  93         }
  94 }
  95
  96 /*
  97  * Initialize our dictionary, and the dictionary mutex.
  98  */
  99 static void beos_init_dyn( void )
 100 {
 101         /* We're protected from a race condition here by the atomic init_count
 102          * variable.
 103          */
 104         static int32 init_count = 0;
 105         int32 val;
 106
 107         val = atomic_add( &init_count, 1 );
 108         if( beos_dyn_images == NULL && val == 0 ) {
 109                 beos_dyn_images = PyDict_New();
 110 #ifdef WITH_THREAD
 111                 beos_dyn_lock = PyThread_allocate_lock();
 112 #endif
 113                 atexit( beos_cleanup_dyn );
 114         }
 115 }
 116
 117 /*
 118  * Add an image_id to the dictionary; the module name of the loaded image
 119  * is the key.  Note that if the key is already in the dict, we unload
 120  * that image; this should allow reload() to work on dynamically loaded
 121  * modules (super-keen!).
 122  */
 123 static void beos_add_dyn( char *name, image_id id )
 124 {
 125         int retval;
 126         PyObject *py_id;
 127
 128         if( beos_dyn_images == NULL ) {
 129                 beos_init_dyn();
 130         }
 131
 132 #ifdef WITH_THREAD
 133         retval = PyThread_acquire_lock( beos_dyn_lock, 1 );
 134 #endif
 135
 136         /* If there's already an object with this key in the dictionary,
 137          * we're doing a reload(), so let's nuke it.
 138          */
 139         py_id = PyDict_GetItemString( beos_dyn_images, name );
 140         if( py_id ) {
 141                 beos_nuke_dyn( py_id );
 142                 retval = PyDict_DelItemString( beos_dyn_images, name );
 143         }
 144
 145         py_id = PyInt_FromLong( (long)id );
 146         if( py_id ) {
 147                 retval = PyDict_SetItemString( beos_dyn_images, name, py_id );
 148         }
 149
 150 #ifdef WITH_THREAD
 151         PyThread_release_lock( beos_dyn_lock );
 152 #endif
 153 }
 154
 155
 156
 157 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
 158                                     const char *pathname, FILE *fp)
 159 {
 160         dl_funcptr p;
 161         image_id the_id;
 162         status_t retval;
 163         char fullpath[PATH_MAX];
 164         char funcname[258];
 165
 166         if( Py_VerboseFlag ) {
 167                 printf( "load_add_on( %s )\n", pathname );
 168         }
 169
 170         /* Hmm, this old bug appears to have regenerated itself; if the
 171          * path isn't absolute, load_add_on() will fail.  Reported to Be
 172          * April 21, 1998.
 173          */
 174         if( pathname[0] != '/' ) {
 175                 (void)getcwd( fullpath, PATH_MAX );
 176                 (void)strncat( fullpath, "/", PATH_MAX );
 177                 (void)strncat( fullpath, pathname, PATH_MAX );
 178
 179                 if( Py_VerboseFlag ) {
 180                         printf( "load_add_on( %s )\n", fullpath );
 181                 }
 182         } else {
 183                 (void)strcpy( fullpath, pathname );
 184         }
 185
 186         the_id = load_add_on( fullpath );
 187         if( the_id < B_NO_ERROR ) {
 188                 /* It's too bad load_add_on() doesn't set errno or something...
 189                  */
 190                 char buff[256];  /* hate hard-coded string sizes... */
 191
 192                 if( Py_VerboseFlag ) {
 193                         printf( "load_add_on( %s ) failed", fullpath );
 194                 }
 195
 196                 if( the_id == B_ERROR )
 197                         PyOS_snprintf( buff, sizeof(buff),
 198                                        "BeOS: Failed to load %.200s",
 199                                        fullpath );
 200                 else
 201                         PyOS_snprintf( buff, sizeof(buff),
 202                                        "Unknown error loading %.200s",
 203                                        fullpath );
 204
 205                 PyErr_SetString( PyExc_ImportError, buff );
 206                 return NULL;
 207         }
 208
 209         PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
 210         if( Py_VerboseFlag ) {
 211                 printf( "get_image_symbol( %s )\n", funcname );
 212         }
 213
 214         retval = get_image_symbol( the_id, funcname, B_SYMBOL_TYPE_TEXT, &p );
 215         if( retval != B_NO_ERROR || p == NULL ) {
 216                 /* That's bad, we can't find that symbol in the module...
 217                  */
 218                 char buff[256];  /* hate hard-coded string sizes... */
 219
 220                 if( Py_VerboseFlag ) {
 221                         printf( "get_image_symbol( %s ) failed", funcname );
 222                 }
 223
 224                 switch( retval ) {
 225                 case B_BAD_IMAGE_ID:
 226                         PyOS_snprintf( buff, sizeof(buff),
 227                                "can't load init function for dynamic module: "
 228                                "Invalid image ID for %.180s", fullpath );
 229                         break;
 230                 case B_BAD_INDEX:
 231                         PyOS_snprintf( buff, sizeof(buff),
 232                                "can't load init function for dynamic module: "
 233                                "Bad index for %.180s", funcname );
 234                         break;
 235                 default:
 236                         PyOS_snprintf( buff, sizeof(buff),
 237                                "can't load init function for dynamic module: "
 238                                "Unknown error looking up %.180s", funcname );
 239                         break;
 240                 }
 241
 242                 retval = unload_add_on( the_id );
 243
 244                 PyErr_SetString( PyExc_ImportError, buff );
 245                 return NULL;
 246         }
 247
 248         /* Save the module name and image ID for later so we can clean up
 249          * gracefully.
 250          */
 251         beos_add_dyn( fqname, the_id );
 252
 253         return p;
 254 }