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 } 255
