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