Use MAP_ANON instead of MAP_ANONYMOUS.
[kopensolaris-gnu/glibc.git] / elf / dl-open.c
1 /* Load a shared object at runtime, relocate it, and run its initializer.
2    Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <dlfcn.h>
21 #include <errno.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/mman.h>           /* Check whether MAP_COPY is defined.  */
25 #include <bits/libc-lock.h>
26 #include <elf/ldsodefs.h>
27
28
29 extern ElfW(Addr) _dl_sysdep_start (void **start_argptr,
30                                     void (*dl_main) (const ElfW(Phdr) *phdr,
31                                                      ElfW(Word) phnum,
32                                                      ElfW(Addr) *user_entry));
33 weak_extern (_dl_sysdep_start)
34
35 /* This function is used to unload the cache file if necessary.  */
36 extern void _dl_unload_cache (void);
37
38 extern int __libc_multiple_libcs;       /* Defined in init-first.c.  */
39
40 extern int __libc_argc;
41 extern char **__libc_argv;
42
43 extern char **__environ;
44
45
46 /* During the program run we must not modify the global data of
47    loaded shared object simultanously in two threads.  Therefore we
48    protect `_dl_open' and `_dl_close' in dl-close.c.
49
50    This must be a recursive lock since the initializer function of
51    the loaded object might as well require a call to this function.
52    At this time it is not anymore a problem to modify the tables.  */
53 __libc_lock_define_initialized_recursive (, _dl_load_lock)
54
55
56 /* We must be carefull not to leave us in an inconsistent state.  Thus we
57    catch any error and re-raise it after cleaning up.  */
58
59 struct dl_open_args
60 {
61   const char *file;
62   int mode;
63   struct link_map *map;
64 };
65
66 static void
67 dl_open_worker (void *a)
68 {
69   struct dl_open_args *args = a;
70   const char *file = args->file;
71   int mode = args->mode;
72   struct link_map *new, *l;
73   ElfW(Addr) init;
74   struct r_debug *r;
75   unsigned int global_add;
76
77   /* Load the named object.  */
78   args->map = new = _dl_map_object (NULL, file, 0, lt_loaded, 0);
79   if (new->l_searchlist.r_list)
80     /* It was already open.  */
81     return;
82
83   /* Load that object's dependencies.  */
84   global_add = _dl_map_object_deps (new, NULL, 0, 0, mode & RTLD_GLOBAL);
85
86   /* So far, so good.  Now check the versions.  */
87   (void) _dl_check_all_versions (new, 0);
88
89   /* Relocate the objects loaded.  We do this in reverse order so that copy
90      relocs of earlier objects overwrite the data written by later objects.  */
91
92   l = new;
93   while (l->l_next)
94     l = l->l_next;
95   while (1)
96     {
97       if (! l->l_relocated)
98         {
99 #ifdef PIC
100           if (_dl_profile != NULL)
101             {
102               /* If this here is the shared object which we want to profile
103                  make sure the profile is started.  We can find out whether
104                  this is necessary or not by observing the `_dl_profile_map'
105                  variable.  If was NULL but is not NULL afterwars we must
106                  start the profiling.  */
107               struct link_map *old_profile_map = _dl_profile_map;
108
109               _dl_relocate_object (l, l->l_scope, 1, 1);
110
111               if (old_profile_map == NULL && _dl_profile_map != NULL)
112                 /* We must prepare the profiling.  */
113                 _dl_start_profile (_dl_profile_map, _dl_profile_output);
114             }
115           else
116 #endif
117             _dl_relocate_object (l, l->l_scope,
118                                  (mode & RTLD_BINDING_MASK) == RTLD_LAZY, 0);
119         }
120
121       if (l == new)
122         break;
123       l = l->l_prev;
124     }
125
126   /* Notify the debugger we have added some objects.  We need to call
127      _dl_debug_initialize in a static program in case dynamic linking has
128      not been used before.  */
129   r = _dl_debug_initialize (0);
130   r->r_state = RT_ADD;
131   _dl_debug_state ();
132
133   /* Run the initializer functions of new objects.  */
134   while ((init = _dl_init_next (&new->l_searchlist)))
135     (*(void (*) (int, char **, char **)) init) (__libc_argc, __libc_argv,
136                                                 __environ);
137
138   if (new->l_global)
139     /* Now we can make the new map available in the global scope.  */
140     _dl_main_searchlist->r_nlist += global_add;
141
142   if (_dl_sysdep_start == NULL)
143     /* We must be the static _dl_open in libc.a.  A static program that
144        has loaded a dynamic object now has competition.  */
145     __libc_multiple_libcs = 1;
146 }
147
148
149 struct link_map *
150 internal_function
151 _dl_open (const char *file, int mode)
152 {
153   struct dl_open_args args;
154   char *errstring;
155   int errcode;
156
157   if ((mode & RTLD_BINDING_MASK) == 0)
158     /* One of the flags must be set.  */
159     _dl_signal_error (EINVAL, file, _("invalid mode for dlopen()"));
160
161   /* Make sure we are alone.  */
162   __libc_lock_lock (_dl_load_lock);
163
164   args.file = file;
165   args.mode = mode;
166   args.map = NULL;
167   errcode = _dl_catch_error (&errstring, dl_open_worker, &args);
168
169 #ifndef MAP_COPY
170   /* We must munmap() the cache file.  */
171   _dl_unload_cache ();
172 #endif
173
174   /* Release the lock.  */
175   __libc_lock_unlock (_dl_load_lock);
176
177   if (errstring)
178     {
179       /* Some error occured during loading.  */
180       char *local_errstring;
181
182       /* Remove the object from memory.  It may be in an inconsistent
183          state if relocation failed, for example.  */
184       if (args.map)
185         _dl_close (args.map);
186
187       /* Make a local copy of the error string so that we can release the
188          memory allocated for it.  */
189       local_errstring = strdupa (errstring);
190       free (errstring);
191
192       /* Reraise the error.  */
193       _dl_signal_error (errcode, NULL, local_errstring);
194     }
195
196   return args.map;
197 }