Deleted Added
sdiff udiff text old ( 191972 ) new ( 192895 )
full compact
linux_mib.c (191972) linux_mib.c (192895)
1/*-
2 * Copyright (c) 1999 Marcel Moolenaar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 13 unchanged lines hidden (view full) ---

22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 1999 Marcel Moolenaar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 13 unchanged lines hidden (view full) ---

22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/sys/compat/linux/linux_mib.c 191972 2009-05-10 18:27:20Z dchagin $");
30__FBSDID("$FreeBSD: head/sys/compat/linux/linux_mib.c 192895 2009-05-27 14:11:23Z jamie $");
31
32#include <sys/param.h>
33#include <sys/kernel.h>
34#include <sys/systm.h>
35#include <sys/sysctl.h>
36#include <sys/proc.h>
37#include <sys/malloc.h>
38#include <sys/mount.h>

--- 13 unchanged lines hidden (view full) ---

52
53struct linux_prison {
54 char pr_osname[LINUX_MAX_UTSNAME];
55 char pr_osrelease[LINUX_MAX_UTSNAME];
56 int pr_oss_version;
57 int pr_osrel;
58};
59
31
32#include <sys/param.h>
33#include <sys/kernel.h>
34#include <sys/systm.h>
35#include <sys/sysctl.h>
36#include <sys/proc.h>
37#include <sys/malloc.h>
38#include <sys/mount.h>

--- 13 unchanged lines hidden (view full) ---

52
53struct linux_prison {
54 char pr_osname[LINUX_MAX_UTSNAME];
55 char pr_osrelease[LINUX_MAX_UTSNAME];
56 int pr_oss_version;
57 int pr_osrel;
58};
59
60static struct linux_prison lprison0 = {
61 .pr_osname = "Linux",
62 .pr_osrelease = "2.6.16",
63 .pr_oss_version = 0x030600,
64 .pr_osrel = 2006016
65};
66
60static unsigned linux_osd_jail_slot;
61
62SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0,
63 "Linux mode");
64
67static unsigned linux_osd_jail_slot;
68
69SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0,
70 "Linux mode");
71
65static struct mtx osname_lock;
66MTX_SYSINIT(linux_osname, &osname_lock, "linux osname", MTX_DEF);
67
68static char linux_osname[LINUX_MAX_UTSNAME] = "Linux";
69
70static int
71linux_sysctl_osname(SYSCTL_HANDLER_ARGS)
72{
73 char osname[LINUX_MAX_UTSNAME];
74 int error;
75
76 linux_get_osname(req->td, osname);
77 error = sysctl_handle_string(oidp, osname, LINUX_MAX_UTSNAME, req);
78 if (error || req->newptr == NULL)
79 return (error);
80 error = linux_set_osname(req->td, osname);
81 return (error);
82}
83
84SYSCTL_PROC(_compat_linux, OID_AUTO, osname,
85 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
86 0, 0, linux_sysctl_osname, "A",
87 "Linux kernel OS name");
88
72static int
73linux_sysctl_osname(SYSCTL_HANDLER_ARGS)
74{
75 char osname[LINUX_MAX_UTSNAME];
76 int error;
77
78 linux_get_osname(req->td, osname);
79 error = sysctl_handle_string(oidp, osname, LINUX_MAX_UTSNAME, req);
80 if (error || req->newptr == NULL)
81 return (error);
82 error = linux_set_osname(req->td, osname);
83 return (error);
84}
85
86SYSCTL_PROC(_compat_linux, OID_AUTO, osname,
87 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
88 0, 0, linux_sysctl_osname, "A",
89 "Linux kernel OS name");
90
89static char linux_osrelease[LINUX_MAX_UTSNAME] = "2.6.16";
90static int linux_osrel = 2006016;
91
92static int
93linux_sysctl_osrelease(SYSCTL_HANDLER_ARGS)
94{
95 char osrelease[LINUX_MAX_UTSNAME];
96 int error;
97
98 linux_get_osrelease(req->td, osrelease);
99 error = sysctl_handle_string(oidp, osrelease, LINUX_MAX_UTSNAME, req);
100 if (error || req->newptr == NULL)
101 return (error);
102 error = linux_set_osrelease(req->td, osrelease);
103 return (error);
104}
105
106SYSCTL_PROC(_compat_linux, OID_AUTO, osrelease,
107 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
108 0, 0, linux_sysctl_osrelease, "A",
109 "Linux kernel OS release");
110
91static int
92linux_sysctl_osrelease(SYSCTL_HANDLER_ARGS)
93{
94 char osrelease[LINUX_MAX_UTSNAME];
95 int error;
96
97 linux_get_osrelease(req->td, osrelease);
98 error = sysctl_handle_string(oidp, osrelease, LINUX_MAX_UTSNAME, req);
99 if (error || req->newptr == NULL)
100 return (error);
101 error = linux_set_osrelease(req->td, osrelease);
102 return (error);
103}
104
105SYSCTL_PROC(_compat_linux, OID_AUTO, osrelease,
106 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON | CTLFLAG_MPSAFE,
107 0, 0, linux_sysctl_osrelease, "A",
108 "Linux kernel OS release");
109
111static int linux_oss_version = 0x030600;
112
113static int
114linux_sysctl_oss_version(SYSCTL_HANDLER_ARGS)
115{
116 int oss_version;
117 int error;
118
119 oss_version = linux_get_oss_version(req->td);
120 error = sysctl_handle_int(oidp, &oss_version, 0, req);

--- 35 unchanged lines hidden (view full) ---

156 if (v < 1000000)
157 return (EINVAL);
158
159 *osrel = v;
160 return (0);
161}
162
163/*
110static int
111linux_sysctl_oss_version(SYSCTL_HANDLER_ARGS)
112{
113 int oss_version;
114 int error;
115
116 oss_version = linux_get_oss_version(req->td);
117 error = sysctl_handle_int(oidp, &oss_version, 0, req);

--- 35 unchanged lines hidden (view full) ---

153 if (v < 1000000)
154 return (EINVAL);
155
156 *osrel = v;
157 return (0);
158}
159
160/*
164 * Returns holding the prison mutex if return non-NULL.
161 * Find a prison with Linux info.
162 * Return the Linux info and the (locked) prison.
165 */
166static struct linux_prison *
163 */
164static struct linux_prison *
167linux_get_prison(struct thread *td, struct prison **prp)
165linux_find_prison(struct prison *spr, struct prison **prp)
168{
169 struct prison *pr;
170 struct linux_prison *lpr;
171
166{
167 struct prison *pr;
168 struct linux_prison *lpr;
169
172 KASSERT(td == curthread, ("linux_get_prison() called on !curthread"));
173 *prp = pr = td->td_ucred->cr_prison;
174 if (pr == NULL || !linux_osd_jail_slot)
175 return (NULL);
176 mtx_lock(&pr->pr_mtx);
177 lpr = osd_jail_get(pr, linux_osd_jail_slot);
178 if (lpr == NULL)
170 if (!linux_osd_jail_slot)
171 /* In case osd_register failed. */
172 spr = &prison0;
173 for (pr = spr;; pr = pr->pr_parent) {
174 mtx_lock(&pr->pr_mtx);
175 lpr = (pr == &prison0)
176 ? &lprison0
177 : osd_jail_get(pr, linux_osd_jail_slot);
178 if (lpr != NULL)
179 break;
179 mtx_unlock(&pr->pr_mtx);
180 mtx_unlock(&pr->pr_mtx);
181 }
182 *prp = pr;
180 return (lpr);
181}
182
183/*
183 return (lpr);
184}
185
186/*
184 * Ensure a prison has its own Linux info. The prison should be locked on
185 * entrance and will be locked on exit (though it may get unlocked in the
186 * interrim).
187 * Ensure a prison has its own Linux info. If lprp is non-null, point it to
188 * the Linux info and lock the prison.
187 */
188static int
189linux_alloc_prison(struct prison *pr, struct linux_prison **lprp)
190{
189 */
190static int
191linux_alloc_prison(struct prison *pr, struct linux_prison **lprp)
192{
193 struct prison *ppr;
191 struct linux_prison *lpr, *nlpr;
192 int error;
193
194 /* If this prison already has Linux info, return that. */
195 error = 0;
194 struct linux_prison *lpr, *nlpr;
195 int error;
196
197 /* If this prison already has Linux info, return that. */
198 error = 0;
196 mtx_assert(&pr->pr_mtx, MA_OWNED);
197 lpr = osd_jail_get(pr, linux_osd_jail_slot);
198 if (lpr != NULL)
199 lpr = linux_find_prison(pr, &ppr);
200 if (ppr == pr)
199 goto done;
200 /*
201 * Allocate a new info record. Then check again, in case something
202 * changed during the allocation.
203 */
201 goto done;
202 /*
203 * Allocate a new info record. Then check again, in case something
204 * changed during the allocation.
205 */
204 mtx_unlock(&pr->pr_mtx);
206 mtx_unlock(&ppr->pr_mtx);
205 nlpr = malloc(sizeof(struct linux_prison), M_PRISON, M_WAITOK);
207 nlpr = malloc(sizeof(struct linux_prison), M_PRISON, M_WAITOK);
206 mtx_lock(&pr->pr_mtx);
207 lpr = osd_jail_get(pr, linux_osd_jail_slot);
208 if (lpr != NULL) {
208 lpr = linux_find_prison(pr, &ppr);
209 if (ppr == pr) {
209 free(nlpr, M_PRISON);
210 goto done;
211 }
210 free(nlpr, M_PRISON);
211 goto done;
212 }
213 /* Inherit the initial values from the ancestor. */
214 mtx_lock(&pr->pr_mtx);
212 error = osd_jail_set(pr, linux_osd_jail_slot, nlpr);
215 error = osd_jail_set(pr, linux_osd_jail_slot, nlpr);
213 if (error)
214 free(nlpr, M_PRISON);
215 else {
216 if (error == 0) {
217 bcopy(lpr, nlpr, sizeof(*lpr));
216 lpr = nlpr;
218 lpr = nlpr;
217 mtx_lock(&osname_lock);
218 strncpy(lpr->pr_osname, linux_osname, LINUX_MAX_UTSNAME);
219 strncpy(lpr->pr_osrelease, linux_osrelease, LINUX_MAX_UTSNAME);
220 lpr->pr_oss_version = linux_oss_version;
221 lpr->pr_osrel = linux_osrel;
222 mtx_unlock(&osname_lock);
219 } else {
220 free(nlpr, M_PRISON);
221 lpr = NULL;
223 }
222 }
224done:
223 mtx_unlock(&ppr->pr_mtx);
224 done:
225 if (lprp != NULL)
226 *lprp = lpr;
225 if (lprp != NULL)
226 *lprp = lpr;
227 else
228 mtx_unlock(&pr->pr_mtx);
227 return (error);
228}
229
230/*
231 * Jail OSD methods for Linux prison data.
232 */
233static int
234linux_prison_create(void *obj, void *data)
235{
229 return (error);
230}
231
232/*
233 * Jail OSD methods for Linux prison data.
234 */
235static int
236linux_prison_create(void *obj, void *data)
237{
236 int error;
237 struct prison *pr = obj;
238 struct vfsoptlist *opts = data;
239
240 if (vfs_flagopt(opts, "nolinux", NULL, 0))
241 return (0);
242 /*
243 * Inherit a prison's initial values from its parent
244 * (different from NULL which also inherits changes).
245 */
238 struct prison *pr = obj;
239 struct vfsoptlist *opts = data;
240
241 if (vfs_flagopt(opts, "nolinux", NULL, 0))
242 return (0);
243 /*
244 * Inherit a prison's initial values from its parent
245 * (different from NULL which also inherits changes).
246 */
246 mtx_lock(&pr->pr_mtx);
247 error = linux_alloc_prison(pr, NULL);
248 mtx_unlock(&pr->pr_mtx);
249 return (error);
247 return linux_alloc_prison(pr, NULL);
250}
251
252static int
253linux_prison_check(void *obj __unused, void *data)
254{
255 struct vfsoptlist *opts = data;
256 char *osname, *osrelease;
248}
249
250static int
251linux_prison_check(void *obj __unused, void *data)
252{
253 struct vfsoptlist *opts = data;
254 char *osname, *osrelease;
257 int error, len, oss_version;
255 int error, len, osrel, oss_version;
258
259 /* Check that the parameters are correct. */
260 (void)vfs_flagopt(opts, "linux", NULL, 0);
261 (void)vfs_flagopt(opts, "nolinux", NULL, 0);
262 error = vfs_getopt(opts, "linux.osname", (void **)&osname, &len);
263 if (error != ENOENT) {
264 if (error != 0)
265 return (error);

--- 9 unchanged lines hidden (view full) ---

275 if (error != 0)
276 return (error);
277 if (len == 0 || osrelease[len - 1] != '\0')
278 return (EINVAL);
279 if (len > LINUX_MAX_UTSNAME) {
280 vfs_opterror(opts, "linux.osrelease too long");
281 return (ENAMETOOLONG);
282 }
256
257 /* Check that the parameters are correct. */
258 (void)vfs_flagopt(opts, "linux", NULL, 0);
259 (void)vfs_flagopt(opts, "nolinux", NULL, 0);
260 error = vfs_getopt(opts, "linux.osname", (void **)&osname, &len);
261 if (error != ENOENT) {
262 if (error != 0)
263 return (error);

--- 9 unchanged lines hidden (view full) ---

273 if (error != 0)
274 return (error);
275 if (len == 0 || osrelease[len - 1] != '\0')
276 return (EINVAL);
277 if (len > LINUX_MAX_UTSNAME) {
278 vfs_opterror(opts, "linux.osrelease too long");
279 return (ENAMETOOLONG);
280 }
281 error = linux_map_osrel(osrelease, &osrel);
282 if (error != 0) {
283 vfs_opterror(opts, "linux.osrelease format error");
284 return (error);
285 }
283 }
284 error = vfs_copyopt(opts, "linux.oss_version", &oss_version,
285 sizeof(oss_version));
286 return (error == ENOENT ? 0 : error);
287}
288
289static int
290linux_prison_set(void *obj, void *data)

--- 14 unchanged lines hidden (view full) ---

305 yeslinux = 1;
306 error = vfs_getopt(opts, "linux.osrelease", (void **)&osrelease, &len);
307 if (error == ENOENT)
308 osrelease = NULL;
309 else
310 yeslinux = 1;
311 error = vfs_copyopt(opts, "linux.oss_version", &oss_version,
312 sizeof(oss_version));
286 }
287 error = vfs_copyopt(opts, "linux.oss_version", &oss_version,
288 sizeof(oss_version));
289 return (error == ENOENT ? 0 : error);
290}
291
292static int
293linux_prison_set(void *obj, void *data)

--- 14 unchanged lines hidden (view full) ---

308 yeslinux = 1;
309 error = vfs_getopt(opts, "linux.osrelease", (void **)&osrelease, &len);
310 if (error == ENOENT)
311 osrelease = NULL;
312 else
313 yeslinux = 1;
314 error = vfs_copyopt(opts, "linux.oss_version", &oss_version,
315 sizeof(oss_version));
313 gotversion = error == 0;
316 gotversion = (error == 0);
314 yeslinux |= gotversion;
315 if (nolinux) {
316 /* "nolinux": inherit the parent's Linux info. */
317 mtx_lock(&pr->pr_mtx);
318 osd_jail_del(pr, linux_osd_jail_slot);
319 mtx_unlock(&pr->pr_mtx);
320 } else if (yeslinux) {
321 /*
322 * "linux" or "linux.*":
323 * the prison gets its own Linux info.
324 */
317 yeslinux |= gotversion;
318 if (nolinux) {
319 /* "nolinux": inherit the parent's Linux info. */
320 mtx_lock(&pr->pr_mtx);
321 osd_jail_del(pr, linux_osd_jail_slot);
322 mtx_unlock(&pr->pr_mtx);
323 } else if (yeslinux) {
324 /*
325 * "linux" or "linux.*":
326 * the prison gets its own Linux info.
327 */
325 mtx_lock(&pr->pr_mtx);
326 error = linux_alloc_prison(pr, &lpr);
327 if (error) {
328 mtx_unlock(&pr->pr_mtx);
329 return (error);
330 }
331 if (osrelease) {
332 error = linux_map_osrel(osrelease, &lpr->pr_osrel);
333 if (error) {

--- 21 unchanged lines hidden (view full) ---

355 "Jail Linux kernel OS release");
356SYSCTL_JAIL_PARAM(_linux, oss_version, CTLTYPE_INT | CTLFLAG_RW,
357 "I", "Jail Linux OSS version");
358
359static int
360linux_prison_get(void *obj, void *data)
361{
362 struct linux_prison *lpr;
328 error = linux_alloc_prison(pr, &lpr);
329 if (error) {
330 mtx_unlock(&pr->pr_mtx);
331 return (error);
332 }
333 if (osrelease) {
334 error = linux_map_osrel(osrelease, &lpr->pr_osrel);
335 if (error) {

--- 21 unchanged lines hidden (view full) ---

357 "Jail Linux kernel OS release");
358SYSCTL_JAIL_PARAM(_linux, oss_version, CTLTYPE_INT | CTLFLAG_RW,
359 "I", "Jail Linux OSS version");
360
361static int
362linux_prison_get(void *obj, void *data)
363{
364 struct linux_prison *lpr;
365 struct prison *ppr;
363 struct prison *pr = obj;
364 struct vfsoptlist *opts = data;
365 int error, i;
366
366 struct prison *pr = obj;
367 struct vfsoptlist *opts = data;
368 int error, i;
369
367 mtx_lock(&pr->pr_mtx);
368 /* Tell whether this prison has its own Linux info. */
369 lpr = osd_jail_get(pr, linux_osd_jail_slot);
370 i = lpr != NULL;
370 static int version0;
371
372 /* See if this prison is the one with the Linux info. */
373 lpr = linux_find_prison(pr, &ppr);
374 i = (ppr == pr);
371 error = vfs_setopt(opts, "linux", &i, sizeof(i));
372 if (error != 0 && error != ENOENT)
373 goto done;
374 i = !i;
375 error = vfs_setopt(opts, "nolinux", &i, sizeof(i));
376 if (error != 0 && error != ENOENT)
377 goto done;
375 error = vfs_setopt(opts, "linux", &i, sizeof(i));
376 if (error != 0 && error != ENOENT)
377 goto done;
378 i = !i;
379 error = vfs_setopt(opts, "nolinux", &i, sizeof(i));
380 if (error != 0 && error != ENOENT)
381 goto done;
378 /*
379 * It's kind of bogus to give the root info, but leave it to the caller
380 * to check the above flag.
381 */
382 if (lpr != NULL) {
383 error = vfs_setopts(opts, "linux.osname", lpr->pr_osname);
382 if (i) {
383 /*
384 * If this prison is inheriting its Linux info, report
385 * empty/zero parameters.
386 */
387 error = vfs_setopts(opts, "linux.osname", "");
384 if (error != 0 && error != ENOENT)
385 goto done;
388 if (error != 0 && error != ENOENT)
389 goto done;
386 error = vfs_setopts(opts, "linux.osrelease", lpr->pr_osrelease);
390 error = vfs_setopts(opts, "linux.osrelease", "");
387 if (error != 0 && error != ENOENT)
388 goto done;
391 if (error != 0 && error != ENOENT)
392 goto done;
389 error = vfs_setopt(opts, "linux.oss_version",
390 &lpr->pr_oss_version, sizeof(lpr->pr_oss_version));
393 error = vfs_setopt(opts, "linux.oss_version", &version0,
394 sizeof(lpr->pr_oss_version));
391 if (error != 0 && error != ENOENT)
392 goto done;
393 } else {
395 if (error != 0 && error != ENOENT)
396 goto done;
397 } else {
394 mtx_lock(&osname_lock);
395 error = vfs_setopts(opts, "linux.osname", linux_osname);
398 error = vfs_setopts(opts, "linux.osname", lpr->pr_osname);
396 if (error != 0 && error != ENOENT)
397 goto done;
399 if (error != 0 && error != ENOENT)
400 goto done;
398 error = vfs_setopts(opts, "linux.osrelease", linux_osrelease);
401 error = vfs_setopts(opts, "linux.osrelease", lpr->pr_osrelease);
399 if (error != 0 && error != ENOENT)
400 goto done;
401 error = vfs_setopt(opts, "linux.oss_version",
402 if (error != 0 && error != ENOENT)
403 goto done;
404 error = vfs_setopt(opts, "linux.oss_version",
402 &linux_oss_version, sizeof(linux_oss_version));
405 &lpr->pr_oss_version, sizeof(lpr->pr_oss_version));
403 if (error != 0 && error != ENOENT)
404 goto done;
406 if (error != 0 && error != ENOENT)
407 goto done;
405 mtx_unlock(&osname_lock);
406 }
407 error = 0;
408
409 done:
408 }
409 error = 0;
410
411 done:
410 mtx_unlock(&pr->pr_mtx);
412 mtx_unlock(&ppr->pr_mtx);
411 return (error);
412}
413
414static void
415linux_prison_destructor(void *data)
416{
417
418 free(data, M_PRISON);

--- 10 unchanged lines hidden (view full) ---

429 [PR_METHOD_CHECK] = linux_prison_check
430 };
431
432 linux_osd_jail_slot =
433 osd_jail_register(linux_prison_destructor, methods);
434 if (linux_osd_jail_slot > 0) {
435 /* Copy the system linux info to any current prisons. */
436 sx_xlock(&allprison_lock);
413 return (error);
414}
415
416static void
417linux_prison_destructor(void *data)
418{
419
420 free(data, M_PRISON);

--- 10 unchanged lines hidden (view full) ---

431 [PR_METHOD_CHECK] = linux_prison_check
432 };
433
434 linux_osd_jail_slot =
435 osd_jail_register(linux_prison_destructor, methods);
436 if (linux_osd_jail_slot > 0) {
437 /* Copy the system linux info to any current prisons. */
438 sx_xlock(&allprison_lock);
437 TAILQ_FOREACH(pr, &allprison, pr_list) {
438 mtx_lock(&pr->pr_mtx);
439 TAILQ_FOREACH(pr, &allprison, pr_list)
439 (void)linux_alloc_prison(pr, NULL);
440 (void)linux_alloc_prison(pr, NULL);
440 mtx_unlock(&pr->pr_mtx);
441 }
442 sx_xunlock(&allprison_lock);
443 }
444}
445
446void
447linux_osd_jail_deregister(void)
448{
449
450 if (linux_osd_jail_slot)
451 osd_jail_deregister(linux_osd_jail_slot);
452}
453
454void
455linux_get_osname(struct thread *td, char *dst)
456{
457 struct prison *pr;
458 struct linux_prison *lpr;
459
441 sx_xunlock(&allprison_lock);
442 }
443}
444
445void
446linux_osd_jail_deregister(void)
447{
448
449 if (linux_osd_jail_slot)
450 osd_jail_deregister(linux_osd_jail_slot);
451}
452
453void
454linux_get_osname(struct thread *td, char *dst)
455{
456 struct prison *pr;
457 struct linux_prison *lpr;
458
460 lpr = linux_get_prison(td, &pr);
461 if (lpr != NULL) {
462 bcopy(lpr->pr_osname, dst, LINUX_MAX_UTSNAME);
463 mtx_unlock(&pr->pr_mtx);
464 } else {
465 mtx_lock(&osname_lock);
466 bcopy(linux_osname, dst, LINUX_MAX_UTSNAME);
467 mtx_unlock(&osname_lock);
468 }
459 lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
460 bcopy(lpr->pr_osname, dst, LINUX_MAX_UTSNAME);
461 mtx_unlock(&pr->pr_mtx);
469}
470
471int
472linux_set_osname(struct thread *td, char *osname)
473{
474 struct prison *pr;
475 struct linux_prison *lpr;
476
462}
463
464int
465linux_set_osname(struct thread *td, char *osname)
466{
467 struct prison *pr;
468 struct linux_prison *lpr;
469
477 lpr = linux_get_prison(td, &pr);
478 if (lpr != NULL) {
479 strlcpy(lpr->pr_osname, osname, LINUX_MAX_UTSNAME);
480 mtx_unlock(&pr->pr_mtx);
481 } else {
482 mtx_lock(&osname_lock);
483 strcpy(linux_osname, osname);
484 mtx_unlock(&osname_lock);
485 }
486
470 lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
471 strlcpy(lpr->pr_osname, osname, LINUX_MAX_UTSNAME);
472 mtx_unlock(&pr->pr_mtx);
487 return (0);
488}
489
490void
491linux_get_osrelease(struct thread *td, char *dst)
492{
493 struct prison *pr;
494 struct linux_prison *lpr;
495
473 return (0);
474}
475
476void
477linux_get_osrelease(struct thread *td, char *dst)
478{
479 struct prison *pr;
480 struct linux_prison *lpr;
481
496 lpr = linux_get_prison(td, &pr);
497 if (lpr != NULL) {
498 bcopy(lpr->pr_osrelease, dst, LINUX_MAX_UTSNAME);
499 mtx_unlock(&pr->pr_mtx);
500 } else {
501 mtx_lock(&osname_lock);
502 bcopy(linux_osrelease, dst, LINUX_MAX_UTSNAME);
503 mtx_unlock(&osname_lock);
504 }
482 lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
483 bcopy(lpr->pr_osrelease, dst, LINUX_MAX_UTSNAME);
484 mtx_unlock(&pr->pr_mtx);
505}
506
507int
508linux_kernver(struct thread *td)
509{
510 struct prison *pr;
511 struct linux_prison *lpr;
512 int osrel;
513
485}
486
487int
488linux_kernver(struct thread *td)
489{
490 struct prison *pr;
491 struct linux_prison *lpr;
492 int osrel;
493
514 lpr = linux_get_prison(td, &pr);
515 if (lpr != NULL) {
516 osrel = lpr->pr_osrel;
517 mtx_unlock(&pr->pr_mtx);
518 } else
519 osrel = linux_osrel;
494 lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
495 osrel = lpr->pr_osrel;
496 mtx_unlock(&pr->pr_mtx);
520 return (osrel);
521}
522
523int
524linux_set_osrelease(struct thread *td, char *osrelease)
525{
526 struct prison *pr;
527 struct linux_prison *lpr;
528 int error;
529
497 return (osrel);
498}
499
500int
501linux_set_osrelease(struct thread *td, char *osrelease)
502{
503 struct prison *pr;
504 struct linux_prison *lpr;
505 int error;
506
530 lpr = linux_get_prison(td, &pr);
531 if (lpr != NULL) {
532 error = linux_map_osrel(osrelease, &lpr->pr_osrel);
533 if (error) {
534 mtx_unlock(&pr->pr_mtx);
535 return (error);
536 }
507 lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
508 error = linux_map_osrel(osrelease, &lpr->pr_osrel);
509 if (error == 0)
537 strlcpy(lpr->pr_osrelease, osrelease, LINUX_MAX_UTSNAME);
510 strlcpy(lpr->pr_osrelease, osrelease, LINUX_MAX_UTSNAME);
538 mtx_unlock(&pr->pr_mtx);
539 } else {
540 mtx_lock(&osname_lock);
541 error = linux_map_osrel(osrelease, &linux_osrel);
542 if (error) {
543 mtx_unlock(&osname_lock);
544 return (error);
545 }
546 strcpy(linux_osrelease, osrelease);
547 mtx_unlock(&osname_lock);
548 }
549
550 return (0);
511 mtx_unlock(&pr->pr_mtx);
512 return (error);
551}
552
553int
554linux_get_oss_version(struct thread *td)
555{
556 struct prison *pr;
557 struct linux_prison *lpr;
558 int version;
559
513}
514
515int
516linux_get_oss_version(struct thread *td)
517{
518 struct prison *pr;
519 struct linux_prison *lpr;
520 int version;
521
560 lpr = linux_get_prison(td, &pr);
561 if (lpr != NULL) {
562 version = lpr->pr_oss_version;
563 mtx_unlock(&pr->pr_mtx);
564 } else
565 version = linux_oss_version;
522 lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
523 version = lpr->pr_oss_version;
524 mtx_unlock(&pr->pr_mtx);
566 return (version);
567}
568
569int
570linux_set_oss_version(struct thread *td, int oss_version)
571{
572 struct prison *pr;
573 struct linux_prison *lpr;
574
525 return (version);
526}
527
528int
529linux_set_oss_version(struct thread *td, int oss_version)
530{
531 struct prison *pr;
532 struct linux_prison *lpr;
533
575 lpr = linux_get_prison(td, &pr);
576 if (lpr != NULL) {
577 lpr->pr_oss_version = oss_version;
578 mtx_unlock(&pr->pr_mtx);
579 } else {
580 mtx_lock(&osname_lock);
581 linux_oss_version = oss_version;
582 mtx_unlock(&osname_lock);
583 }
584
534 lpr = linux_find_prison(td->td_ucred->cr_prison, &pr);
535 lpr->pr_oss_version = oss_version;
536 mtx_unlock(&pr->pr_mtx);
585 return (0);
586}
587
588#if defined(DEBUG) || defined(KTR)
589
590u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))];
591
592static int

--- 55 unchanged lines hidden --- 		537 return (0);
538}
539
540#if defined(DEBUG) || defined(KTR)
541
542u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))];
543
544static int

--- 55 unchanged lines hidden ---