1 /* $NetBSD: linux32_sysctl.c,v 1.19 2020/03/21 16:28:56 pgoyette Exp $ */
2
3 /*-
4 * Copyright (c) 2006 Emmanuel Dreyfus, all rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by Emmanuel Dreyfus
17 * 4. The name of the author may not be used to endorse or promote
18 * products derived from this software without specific prior written
19 * permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE THE AUTHOR AND CONTRIBUTORS ``AS IS''
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
23 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: linux32_sysctl.c,v 1.19 2020/03/21 16:28:56 pgoyette Exp $");
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/errno.h>
39 #include <sys/proc.h>
40 #include <sys/mount.h>
41 #include <sys/sysctl.h>
42 #include <sys/syscallargs.h>
43 #include <sys/ktrace.h>
44
45 #include <compat/netbsd32/netbsd32.h>
46
47 #include <compat/linux/common/linux_types.h>
48 #include <compat/linux/common/linux_signal.h>
49 #include <compat/linux/common/linux_sysctl.h>
50 #include <compat/linux/common/linux_ipc.h>
51 #include <compat/linux/common/linux_sem.h>
52 #include <compat/linux/linux_syscallargs.h>
53
54 #include <compat/linux32/common/linux32_types.h>
55 #include <compat/linux32/common/linux32_signal.h>
56 #include <compat/linux32/common/linux32_sysctl.h>
57 #include <compat/linux32/linux32_syscallargs.h>
58
59 char linux32_sysname[128] = "Linux";
60 char linux32_release[128] = "3.11.6";
61 char linux32_version[128] = "#1 SMP PREEMPT Thu Oct 24 16:23:02 UTC 2013";
62
63 struct sysctlnode linux32_sysctl_root = {
64 .sysctl_flags = SYSCTL_VERSION|
65 CTLFLAG_ROOT|CTLTYPE_NODE|CTLFLAG_READWRITE,
66 .sysctl_num = 0,
67 .sysctl_name = "(linux32_root)",
68 .sysctl_size = sizeof(struct sysctlnode),
69 };
70
71 extern int linux32_enabled;
72
73 /*
74 * We need our own sysctllog here because we deal with two
75 * separate sysctl trees; each clog is restricted to a
76 * single tree.
77 */
78
79 static struct sysctllog *linux32_clog;
80
81 void
linux32_sysctl_fini(void)82 linux32_sysctl_fini(void)
83 {
84
85 sysctl_teardown(&linux32_clog);
86 sysctl_free(&linux32_sysctl_root);
87 }
88
89 SYSCTL_SETUP(linux32_sysctl_init, "linux32 emulation sysctls")
90 {
91 const struct sysctlnode *node = &linux32_sysctl_root;
92
93 sysctl_createv(clog, 0, NULL, NULL,
94 CTLFLAG_PERMANENT,
95 CTLTYPE_NODE, "linux32",
96 SYSCTL_DESCR("Linux 32 bit emulation settings"),
97 NULL, 0, NULL, 0,
98 CTL_EMUL, EMUL_LINUX32, CTL_EOL);
99 sysctl_createv(clog, 0, NULL, NULL,
100 CTLFLAG_PERMANENT,
101 CTLTYPE_NODE, "kern",
102 SYSCTL_DESCR("Linux 32 bit kernel emulation settings"),
103 NULL, 0, NULL, 0,
104 CTL_EMUL, EMUL_LINUX32, EMUL_LINUX32_KERN, CTL_EOL);
105
106 sysctl_createv(clog, 0, NULL, NULL,
107 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
108 CTLTYPE_STRING, "ostype",
109 SYSCTL_DESCR("Linux 32 bit operating system type"),
110 NULL, 0, linux32_sysname, sizeof(linux32_sysname),
111 CTL_EMUL, EMUL_LINUX32, EMUL_LINUX32_KERN,
112 EMUL_LINUX32_KERN_OSTYPE, CTL_EOL);
113 sysctl_createv(clog, 0, NULL, NULL,
114 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
115 CTLTYPE_STRING, "osrelease",
116 SYSCTL_DESCR("Linux 32 bit operating system release"),
117 NULL, 0, linux32_release, sizeof(linux32_release),
118 CTL_EMUL, EMUL_LINUX32, EMUL_LINUX32_KERN,
119 EMUL_LINUX32_KERN_OSRELEASE, CTL_EOL);
120 sysctl_createv(clog, 0, NULL, NULL,
121 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
122 CTLTYPE_STRING, "osversion",
123 SYSCTL_DESCR("Linux 32 bit operating system revision"),
124 NULL, 0, linux32_version, sizeof(linux32_version),
125 CTL_EMUL, EMUL_LINUX32, EMUL_LINUX32_KERN,
126 EMUL_LINUX32_KERN_VERSION, CTL_EOL);
127 sysctl_createv(clog, 0, NULL, NULL,
128 CTLFLAG_READWRITE,
129 CTLTYPE_INT, "enabled",
130 SYSCTL_DESCR("Linux 32 bit compat enabled."),
131 linux32_sysctl_enable, 0, &linux32_enabled, 0,
132 CTL_EMUL, EMUL_LINUX32, CTL_CREATE, CTL_EOL);
133
134 sysctl_createv(&linux32_clog, 0, &node, &node,
135 CTLFLAG_PERMANENT,
136 CTLTYPE_NODE, "kern", NULL,
137 NULL, 0, NULL, 0,
138 LINUX_CTL_KERN, CTL_EOL);
139
140 sysctl_createv(&linux32_clog, 0, &node, NULL,
141 CTLFLAG_PERMANENT,
142 CTLTYPE_STRING, "ostype", NULL,
143 NULL, 0, linux32_sysname, sizeof(linux32_sysname),
144 LINUX_KERN_OSTYPE, CTL_EOL);
145 sysctl_createv(&linux32_clog, 0, &node, NULL,
146 CTLFLAG_PERMANENT,
147 CTLTYPE_STRING, "osrelease", NULL,
148 NULL, 0, linux32_release, sizeof(linux32_release),
149 LINUX_KERN_OSRELEASE, CTL_EOL);
150 sysctl_createv(&linux32_clog, 0, &node, NULL,
151 CTLFLAG_PERMANENT,
152 CTLTYPE_STRING, "version", NULL,
153 NULL, 0, linux32_version, sizeof(linux32_version),
154 LINUX_KERN_VERSION, CTL_EOL);
155
156 linux32_sysctl_root.sysctl_flags &= ~CTLFLAG_READWRITE;
157 }
158
159 int
linux32_sys___sysctl(struct lwp * l,const struct linux32_sys___sysctl_args * uap,register_t * retval)160 linux32_sys___sysctl(struct lwp *l, const struct linux32_sys___sysctl_args *uap, register_t *retval)
161 {
162 /* {
163 syscallarg(linux32___sysctlp_t) lsp;
164 } */
165 struct linux32_sysctl ls32;
166 int name[CTL_MAXNAME];
167 size_t savelen;
168 netbsd32_size_t oldlen32;
169 size_t oldlen;
170 int error;
171
172 /*
173 * Read sysctl arguments
174 */
175 if ((error = copyin(SCARG_P32(uap, lsp), &ls32, sizeof(ls32))) != 0)
176 return error;
177
178 /*
179 * Read oldlen
180 */
181 if (NETBSD32PTR64(ls32.oldlenp) != NULL) {
182 if ((error = copyin(NETBSD32PTR64(ls32.oldlenp),
183 &oldlen32, sizeof(oldlen32))) != 0)
184 return error;
185 } else {
186 oldlen32 = 0;
187 }
188
189 savelen = (size_t)oldlen32;
190
191 /*
192 * Sanity check nlen
193 */
194 if ((ls32.nlen > CTL_MAXNAME) || (ls32.nlen < 1))
195 return ENOTDIR;
196
197 /*
198 * Read the sysctl name
199 */
200 if ((error = copyin(NETBSD32PTR64(ls32.name), &name,
201 ls32.nlen * sizeof(int))) != 0)
202 return error;
203
204 ktrmib(name, ls32.nlen);
205 /*
206 * First try linux32 tree, then linux tree
207 */
208 oldlen = (size_t)oldlen32;
209 sysctl_lock(NETBSD32PTR64(ls32.newval) != NULL);
210 error = sysctl_dispatch(name, ls32.nlen,
211 NETBSD32PTR64(ls32.oldval), &oldlen,
212 NETBSD32PTR64(ls32.newval), ls32.newlen,
213 name, l, &linux32_sysctl_root);
214 oldlen32 = (netbsd32_size_t)oldlen;
215 sysctl_unlock();
216
217 /*
218 * Check for oldlen overflow (not likely, but who knows...)
219 */
220 if (oldlen != oldlen32) {
221 #ifdef DEBUG_LINUX
222 printf("%s: oldlen32 = %d, oldlen = %ld\n",
223 __func__, oldlen32, oldlen);
224 #endif
225 return EINVAL;
226 }
227
228 /*
229 * set caller's oldlen, even if we got an error
230 */
231 if (NETBSD32PTR64(ls32.oldlenp)) {
232 int nerror;
233
234 nerror = copyout(&oldlen32,
235 NETBSD32PTR64(ls32.oldlenp), sizeof(oldlen32));
236
237 if (error == 0)
238 error = nerror;
239 }
240
241 /*
242 * oldlen was too short
243 */
244 if ((error == 0) &&
245 (NETBSD32PTR64(ls32.oldval) != NULL) &&
246 (savelen < oldlen32))
247 error = ENOMEM;
248
249 return error;
250 }
251