Commit | Line | Data |
---|---|---|
0f80bc85 JD |
1 | #include <stdio.h> |
2 | #include <stdlib.h> | |
3 | #include <stddef.h> | |
4 | #include <stdarg.h> | |
5 | #include <unistd.h> | |
6 | #include <errno.h> | |
7 | #include <string.h> | |
8 | #include <fcntl.h> | |
9 | #include <sys/types.h> | |
10 | #include <sys/mman.h> | |
966a082f | 11 | #include <sys/statfs.h> |
0f80bc85 JD |
12 | #include "kern_util.h" |
13 | #include "user.h" | |
0f80bc85 JD |
14 | #include "mem_user.h" |
15 | #include "init.h" | |
16 | #include "os.h" | |
17 | #include "tempfile.h" | |
18 | #include "kern_constants.h" | |
19 | ||
20 | #include <sys/param.h> | |
21 | ||
6bf79482 | 22 | /* Modified by which_tmpdir, which is called during early boot */ |
966a082f | 23 | static char *default_tmpdir = "/tmp"; |
6bf79482 JD |
24 | |
25 | /* | |
26 | * Modified when creating the physical memory file and when checking | |
27 | * the tmp filesystem for usability, both happening during early boot. | |
28 | */ | |
0f80bc85 JD |
29 | static char *tempdir = NULL; |
30 | ||
31 | static void __init find_tempdir(void) | |
32 | { | |
c0a9290e | 33 | const char *dirs[] = { "TMP", "TEMP", "TMPDIR", NULL }; |
0f80bc85 JD |
34 | int i; |
35 | char *dir = NULL; | |
36 | ||
81999a01 JD |
37 | if(tempdir != NULL) /* We've already been called */ |
38 | return; | |
0f80bc85 JD |
39 | for(i = 0; dirs[i]; i++){ |
40 | dir = getenv(dirs[i]); | |
41 | if((dir != NULL) && (*dir != '\0')) | |
42 | break; | |
43 | } | |
44 | if((dir == NULL) || (*dir == '\0')) | |
966a082f | 45 | dir = default_tmpdir; |
0f80bc85 JD |
46 | |
47 | tempdir = malloc(strlen(dir) + 2); | |
48 | if(tempdir == NULL){ | |
49 | fprintf(stderr, "Failed to malloc tempdir, " | |
50 | "errno = %d\n", errno); | |
51 | return; | |
52 | } | |
53 | strcpy(tempdir, dir); | |
54 | strcat(tempdir, "/"); | |
55 | } | |
56 | ||
966a082f RL |
57 | /* This will return 1, with the first character in buf being the |
58 | * character following the next instance of c in the file. This will | |
59 | * read the file as needed. If there's an error, -errno is returned; | |
60 | * if the end of the file is reached, 0 is returned. | |
61 | */ | |
c0a9290e | 62 | static int next(int fd, char *buf, size_t size, char c) |
966a082f | 63 | { |
c0a9290e WC |
64 | ssize_t n; |
65 | size_t len; | |
966a082f RL |
66 | char *ptr; |
67 | ||
68 | while((ptr = strchr(buf, c)) == NULL){ | |
69 | n = read(fd, buf, size - 1); | |
70 | if(n == 0) | |
71 | return 0; | |
72 | else if(n < 0) | |
73 | return -errno; | |
74 | ||
75 | buf[n] = '\0'; | |
76 | } | |
77 | ||
78 | ptr++; | |
c2b7a4bb JD |
79 | len = strlen(ptr); |
80 | memmove(buf, ptr, len + 1); | |
81 | ||
82 | /* Refill the buffer so that if there's a partial string that we care | |
83 | * about, it will be completed, and we can recognize it. | |
84 | */ | |
85 | n = read(fd, &buf[len], size - len - 1); | |
86 | if(n < 0) | |
87 | return -errno; | |
88 | ||
89 | buf[len + n] = '\0'; | |
966a082f RL |
90 | return 1; |
91 | } | |
92 | ||
6bf79482 | 93 | /* which_tmpdir is called only during early boot */ |
966a082f RL |
94 | static int checked_tmpdir = 0; |
95 | ||
96 | /* Look for a tmpfs mounted at /dev/shm. I couldn't find a cleaner | |
97 | * way to do this than to parse /proc/mounts. statfs will return the | |
98 | * same filesystem magic number and fs id for both /dev and /dev/shm | |
99 | * when they are both tmpfs, so you can't tell if they are different | |
100 | * filesystems. Also, there seems to be no other way of finding the | |
101 | * mount point of a filesystem from within it. | |
102 | * | |
103 | * If a /dev/shm tmpfs entry is found, then we switch to using it. | |
104 | * Otherwise, we stay with the default /tmp. | |
105 | */ | |
106 | static void which_tmpdir(void) | |
107 | { | |
108 | int fd, found; | |
109 | char buf[128] = { '\0' }; | |
110 | ||
111 | if(checked_tmpdir) | |
112 | return; | |
113 | ||
114 | checked_tmpdir = 1; | |
115 | ||
116 | printf("Checking for tmpfs mount on /dev/shm..."); | |
117 | ||
118 | fd = open("/proc/mounts", O_RDONLY); | |
119 | if(fd < 0){ | |
120 | printf("failed to open /proc/mounts, errno = %d\n", errno); | |
121 | return; | |
122 | } | |
123 | ||
124 | while(1){ | |
91b165c0 | 125 | found = next(fd, buf, ARRAY_SIZE(buf), ' '); |
966a082f RL |
126 | if(found != 1) |
127 | break; | |
128 | ||
129 | if(!strncmp(buf, "/dev/shm", strlen("/dev/shm"))) | |
130 | goto found; | |
131 | ||
91b165c0 | 132 | found = next(fd, buf, ARRAY_SIZE(buf), '\n'); |
966a082f RL |
133 | if(found != 1) |
134 | break; | |
135 | } | |
136 | ||
137 | err: | |
138 | if(found == 0) | |
139 | printf("nothing mounted on /dev/shm\n"); | |
140 | else if(found < 0) | |
141 | printf("read returned errno %d\n", -found); | |
142 | ||
80c13749 JD |
143 | out: |
144 | close(fd); | |
145 | ||
966a082f RL |
146 | return; |
147 | ||
148 | found: | |
91b165c0 | 149 | found = next(fd, buf, ARRAY_SIZE(buf), ' '); |
966a082f RL |
150 | if(found != 1) |
151 | goto err; | |
152 | ||
153 | if(strncmp(buf, "tmpfs", strlen("tmpfs"))){ | |
154 | printf("not tmpfs\n"); | |
80c13749 | 155 | goto out; |
966a082f RL |
156 | } |
157 | ||
158 | printf("OK\n"); | |
159 | default_tmpdir = "/dev/shm"; | |
80c13749 | 160 | goto out; |
966a082f RL |
161 | } |
162 | ||
0f80bc85 JD |
163 | /* |
164 | * This proc still used in tt-mode | |
165 | * (file: kernel/tt/ptproxy/proxy.c, proc: start_debugger). | |
166 | * So it isn't 'static' yet. | |
167 | */ | |
36e45463 JD |
168 | int __init make_tempfile(const char *template, char **out_tempname, |
169 | int do_unlink) | |
0f80bc85 | 170 | { |
87276f72 | 171 | char *tempname; |
0f80bc85 JD |
172 | int fd; |
173 | ||
966a082f | 174 | which_tmpdir(); |
87276f72 | 175 | tempname = malloc(MAXPATHLEN); |
c9a3072d WC |
176 | if (!tempname) |
177 | goto out; | |
87276f72 | 178 | |
0f80bc85 | 179 | find_tempdir(); |
87276f72 | 180 | if (template[0] != '/') |
0f80bc85 JD |
181 | strcpy(tempname, tempdir); |
182 | else | |
87276f72 | 183 | tempname[0] = '\0'; |
c9a3072d | 184 | strncat(tempname, template, MAXPATHLEN-1-strlen(tempname)); |
0f80bc85 JD |
185 | fd = mkstemp(tempname); |
186 | if(fd < 0){ | |
187 | fprintf(stderr, "open - cannot create %s: %s\n", tempname, | |
188 | strerror(errno)); | |
87276f72 | 189 | goto out; |
0f80bc85 JD |
190 | } |
191 | if(do_unlink && (unlink(tempname) < 0)){ | |
192 | perror("unlink"); | |
87276f72 | 193 | goto out; |
0f80bc85 JD |
194 | } |
195 | if(out_tempname){ | |
87276f72 PBG |
196 | *out_tempname = tempname; |
197 | } else { | |
198 | free(tempname); | |
0f80bc85 | 199 | } |
81999a01 | 200 | return fd; |
87276f72 PBG |
201 | out: |
202 | free(tempname); | |
203 | return -1; | |
0f80bc85 JD |
204 | } |
205 | ||
206 | #define TEMPNAME_TEMPLATE "vm_file-XXXXXX" | |
207 | ||
208 | /* | |
209 | * This proc is used in start_up.c | |
210 | * So it isn't 'static'. | |
211 | */ | |
36e45463 | 212 | int __init create_tmp_file(unsigned long long len) |
0f80bc85 JD |
213 | { |
214 | int fd, err; | |
215 | char zero; | |
216 | ||
217 | fd = make_tempfile(TEMPNAME_TEMPLATE, NULL, 1); | |
218 | if(fd < 0) { | |
219 | exit(1); | |
220 | } | |
221 | ||
222 | err = fchmod(fd, 0777); | |
223 | if(err < 0){ | |
512b6fb1 | 224 | perror("fchmod"); |
0f80bc85 JD |
225 | exit(1); |
226 | } | |
227 | ||
190f4939 JD |
228 | /* Seek to len - 1 because writing a character there will |
229 | * increase the file size by one byte, to the desired length. | |
230 | */ | |
231 | if (lseek64(fd, len - 1, SEEK_SET) < 0) { | |
512b6fb1 | 232 | perror("lseek64"); |
0f80bc85 JD |
233 | exit(1); |
234 | } | |
235 | ||
236 | zero = 0; | |
237 | ||
a61f334f | 238 | err = write(fd, &zero, 1); |
0f80bc85 | 239 | if(err != 1){ |
a61f334f | 240 | perror("write"); |
0f80bc85 JD |
241 | exit(1); |
242 | } | |
243 | ||
81999a01 | 244 | return fd; |
0f80bc85 JD |
245 | } |
246 | ||
36e45463 | 247 | int __init create_mem_file(unsigned long long len) |
0f80bc85 JD |
248 | { |
249 | int err, fd; | |
250 | ||
02dea087 | 251 | fd = create_tmp_file(len); |
0f80bc85 | 252 | |
512b6fb1 | 253 | err = os_set_exec_close(fd); |
0f80bc85 JD |
254 | if(err < 0){ |
255 | errno = -err; | |
256 | perror("exec_close"); | |
257 | } | |
81999a01 | 258 | return fd; |
0f80bc85 | 259 | } |
966a082f RL |
260 | |
261 | ||
36e45463 | 262 | void __init check_tmpexec(void) |
966a082f RL |
263 | { |
264 | void *addr; | |
265 | int err, fd = create_tmp_file(UM_KERN_PAGE_SIZE); | |
266 | ||
267 | addr = mmap(NULL, UM_KERN_PAGE_SIZE, | |
268 | PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE, fd, 0); | |
269 | printf("Checking PROT_EXEC mmap in %s...",tempdir); | |
270 | fflush(stdout); | |
271 | if(addr == MAP_FAILED){ | |
272 | err = errno; | |
273 | perror("failed"); | |
c9a3072d | 274 | close(fd); |
966a082f RL |
275 | if(err == EPERM) |
276 | printf("%s must be not mounted noexec\n",tempdir); | |
277 | exit(1); | |
278 | } | |
279 | printf("OK\n"); | |
280 | munmap(addr, UM_KERN_PAGE_SIZE); | |
281 | ||
282 | close(fd); | |
283 | } |