1 /* go-libmain.c -- the startup function for a Go library.
2
3 Copyright 2015 The Go Authors. All rights reserved.
4 Use of this source code is governed by a BSD-style
5 license that can be found in the LICENSE file. */
6
7 #include "config.h"
8
9 #include <errno.h>
10 #include <pthread.h>
11 #include <stdlib.h>
12 #include <time.h>
13 #include <unistd.h>
14 #include <sys/types.h>
15 #include <sys/stat.h>
16 #include <fcntl.h>
17
18 #include "runtime.h"
19 #include "array.h"
20 #include "arch.h"
21
22 #if defined(__sun) && defined(__SVR4)
23
24 /* Read a file into memory on Solaris, returning an malloc'ed buffer
25 and setting *SIZE to its size. */
26
27 static char *
28 read_file (const char *fn, size_t *size)
29 {
30 struct stat st;
31 char *buf;
32 int o;
33 ssize_t got;
34
35 if (stat (fn, &st) < 0)
36 return NULL;
37 buf = malloc ((size_t) st.st_size);
38 if (buf == NULL)
39 return NULL;
40 o = open (fn, O_RDONLY);
41 if (o < 0)
42 {
43 free (buf);
44 return NULL;
45 }
46 got = read (o, buf, st.st_size);
47 close (o);
48 if (got != st.st_size)
49 {
50 free (buf);
51 return NULL;
52 }
53
54 *size = (size_t) got;
55 return buf;
56 }
57
58 /* On Solaris we don't get passed argc/argv, but we can fetch it from
59 /proc/PID/cmdline. */
60
61 static void
62 read_cmdline (int *argc, char ***argv)
63 {
64 pid_t pid;
65 char fn[50];
66 char *argbuf;
67 size_t argsize;
68 char *envbuf;
69 size_t envsize;
70 char *p;
71 int i;
72 int ac;
73
74 *argc = 0;
75 *argv = NULL;
76
77 pid = getpid ();
78 snprintf (fn, sizeof fn, "/proc/%ld/cmdline", (long) pid);
79 argbuf = read_file (fn, &argsize);
80 if (argbuf == NULL)
81 return;
82
83 snprintf (fn, sizeof fn, "/proc/%ld/environ", (long) pid);
84 envbuf = read_file (fn, &envsize);
85 if (envbuf == NULL)
86 {
87 free (argbuf);
88 return;
89 }
90
91 i = 0;
92 for (p = argbuf; p < argbuf + argsize; p++)
93 if (*p == '\0')
94 ++i;
95 ac = i;
96 ++i; // For trailing NULL.
97 for (p = envbuf; p < envbuf + envsize; p++)
98 if (*p == '\0')
99 ++i;
100 ++i; // For trailing NULL.
101
102 *argv = (char **) malloc (i * sizeof (char *));
103 if (*argv == NULL)
104 {
105 free (argbuf);
106 free (envbuf);
107 return;
108 }
109
110 *argc = ac;
111 (*argv)[0] = argbuf;
112 i = 0;
113 for (p = argbuf; p < argbuf + argsize; p++)
114 {
115 if (*p == '\0')
116 {
117 ++i;
118 (*argv)[i] = p + 1;
119 }
120 }
121 (*argv)[i] = NULL;
122 ++i;
123 (*argv)[i] = envbuf;
124 for (p = envbuf; p < envbuf + envsize; p++)
125 {
126 if (*p == '\0')
127 {
128 ++i;
129 (*argv)[i] = p + 1;
130 }
131 }
132 (*argv)[i] = NULL;
133 }
134
135 #endif /* defined(__sun) && defined(__SVR4) */
136
137 /* This is used when building a standalone Go library using the Go
138 command's -buildmode=c-archive or -buildmode=c-shared option. It
139 starts up the Go code as a global constructor but does not take any
140 other action. The main program is written in some other language
141 and calls exported Go functions as needed. */
142
143 static void die (const char *, int);
144 /* .init_array section does not exist in AIX XCOFF.
145 -Wl,-binitfini:__go_init option will be required to build go
146 libraries and make sure __go_init is called when the library is
147 loaded. This requires __go_init to be exported. */
148
149 void __go_init (int, char **, char **);
150 static void *gostart (void *);
151
152 /* Used to pass arguments to the thread that runs the Go startup. */
153
154 struct args {
155 int argc;
156 char **argv;
157 };
158
159 #ifndef _AIX
160 /* We use .init_array so that we can get the command line arguments.
161 This obviously assumes .init_array support; different systems may
162 require other approaches. */
163
164 typedef void (*initarrayfn) (int, char **, char **);
165
166 static initarrayfn initarray[1]
167 __attribute__ ((section (".init_array"), used)) =
168 { __go_init };
169 #endif
170
171 /* This function is called at program startup time. It starts a new
172 thread to do the actual Go startup, so that program startup is not
173 paused waiting for the Go initialization functions. Exported cgo
174 functions will wait for initialization to complete if
175 necessary. */
176
177 void
178 __go_init (int argc, char **argv, char** env __attribute__ ((unused)))
179 {
180 int err;
181 pthread_attr_t attr;
182 struct args *a;
183 pthread_t tid;
184
185 #if defined(__sun) && defined(__SVR4)
186 read_cmdline (&argc, &argv);
187 #endif
188
189 runtime_isarchive = true;
190
191 setIsCgo ();
192 runtime_cpuinit ();
193 runtime_initsig(true);
194
195 a = (struct args *) malloc (sizeof *a);
196 if (a == NULL)
197 die ("malloc", errno);
198 a->argc = argc;
199 a->argv = argv;
200
201 err = pthread_attr_init (&attr);
202 if (err != 0)
203 die ("pthread_attr_init", err);
204 err = pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
205 if (err != 0)
206 die ("pthread_attr_setdetachstate", err);
207
208 err = pthread_create (&tid, &attr, gostart, (void *) a);
209 if (err != 0)
210 die ("pthread_create", err);
211
212 err = pthread_attr_destroy (&attr);
213 if (err != 0)
214 die ("pthread_attr_destroy", err);
215 }
216
217 /* Start up the Go runtime. */
218
219 static void *
220 gostart (void *arg)
221 {
222 struct args *a = (struct args *) arg;
223
224 if (runtime_isstarted)
225 return NULL;
226 runtime_isstarted = true;
227
228 runtime_ginit ();
229 runtime_check ();
230 runtime_args (a->argc, (byte **) a->argv);
231 runtime_osinit ();
232 runtime_schedinit ();
233 __go_go ((uintptr)(runtime_main), NULL);
234 runtime_mstart (runtime_m ());
235 abort ();
236 }
237
238 /* If something goes wrong during program startup, crash. There is no
239 way to report failure and nobody to whom to report it. */
240
241 static void
242 die (const char *fn, int err)
243 {
244 fprintf (stderr, "%s: %d\n", fn, err);
245 exit (EXIT_FAILURE);
246 }