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 9 * notice, this list of conditions and the following disclaimer 10 * in this position and unchanged. 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. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 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$"); 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/jail.h> 39 #include <sys/lock.h> 40 #include <sys/mutex.h> 41 42 #include <machine/../linux/linux.h> 43 #include <compat/linux/linux_mib.h> 44 45 struct linux_prison { 46 char pr_osname[LINUX_MAX_UTSNAME]; 47 char pr_osrelease[LINUX_MAX_UTSNAME]; 48 int pr_oss_version; 49 }; 50 51 SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0, 52 "Linux mode"); 53 54 static struct mtx osname_lock; 55 MTX_SYSINIT(linux_osname, &osname_lock, "linux osname", MTX_DEF); 56 57 static char linux_osname[LINUX_MAX_UTSNAME] = "Linux"; 58 59 static int 60 linux_sysctl_osname(SYSCTL_HANDLER_ARGS) 61 { 62 char osname[LINUX_MAX_UTSNAME]; 63 int error; 64 65 linux_get_osname(req->td, osname); 66 error = sysctl_handle_string(oidp, osname, LINUX_MAX_UTSNAME, req); 67 if (error || req->newptr == NULL) 68 return (error); 69 error = linux_set_osname(req->td, osname); 70 return (error); 71 } 72 73 SYSCTL_PROC(_compat_linux, OID_AUTO, osname, 74 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON, 75 0, 0, linux_sysctl_osname, "A", 76 "Linux kernel OS name"); 77 78 static char linux_osrelease[LINUX_MAX_UTSNAME] = "2.4.2"; 79 80 static int 81 linux_sysctl_osrelease(SYSCTL_HANDLER_ARGS) 82 { 83 char osrelease[LINUX_MAX_UTSNAME]; 84 int error; 85 86 linux_get_osrelease(req->td, osrelease); 87 error = sysctl_handle_string(oidp, osrelease, LINUX_MAX_UTSNAME, req); 88 if (error || req->newptr == NULL) 89 return (error); 90 error = linux_set_osrelease(req->td, osrelease); 91 return (error); 92 } 93 94 SYSCTL_PROC(_compat_linux, OID_AUTO, osrelease, 95 CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_PRISON, 96 0, 0, linux_sysctl_osrelease, "A", 97 "Linux kernel OS release"); 98 99 static int linux_oss_version = 0x030600; 100 101 static int 102 linux_sysctl_oss_version(SYSCTL_HANDLER_ARGS) 103 { 104 int oss_version; 105 int error; 106 107 oss_version = linux_get_oss_version(req->td); 108 error = sysctl_handle_int(oidp, &oss_version, 0, req); 109 if (error || req->newptr == NULL) 110 return (error); 111 error = linux_set_oss_version(req->td, oss_version); 112 return (error); 113 } 114 115 SYSCTL_PROC(_compat_linux, OID_AUTO, oss_version, 116 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_PRISON, 117 0, 0, linux_sysctl_oss_version, "I", 118 "Linux OSS version"); 119 120 /* 121 * Returns holding the prison mutex if return non-NULL. 122 */ 123 static struct prison * 124 linux_get_prison(struct thread *td) 125 { 126 register struct prison *pr; 127 register struct linux_prison *lpr; 128 129 KASSERT(td == curthread, ("linux_get_prison() called on !curthread")); 130 if (!jailed(td->td_ucred)) 131 return (NULL); 132 pr = td->td_ucred->cr_prison; 133 mtx_lock(&pr->pr_mtx); 134 if (pr->pr_linux == NULL) { 135 /* 136 * If we don't have a linux prison structure yet, allocate 137 * one. We have to handle the race where another thread 138 * could be adding a linux prison to this process already. 139 */ 140 mtx_unlock(&pr->pr_mtx); 141 lpr = malloc(sizeof(struct linux_prison), M_PRISON, 142 M_WAITOK | M_ZERO); 143 mtx_lock(&pr->pr_mtx); 144 if (pr->pr_linux == NULL) 145 pr->pr_linux = lpr; 146 else 147 free(lpr, M_PRISON); 148 } 149 return (pr); 150 } 151 152 void 153 linux_mib_destroy(void) 154 { 155 156 mtx_destroy(&osname_lock); 157 } 158 159 void 160 linux_get_osname(struct thread *td, char *dst) 161 { 162 register struct prison *pr; 163 register struct linux_prison *lpr; 164 165 pr = td->td_ucred->cr_prison; 166 if (pr != NULL) { 167 mtx_lock(&pr->pr_mtx); 168 if (pr->pr_linux != NULL) { 169 lpr = (struct linux_prison *)pr->pr_linux; 170 if (lpr->pr_osname[0]) { 171 bcopy(lpr->pr_osname, dst, LINUX_MAX_UTSNAME); 172 mtx_unlock(&pr->pr_mtx); 173 return; 174 } 175 } 176 mtx_unlock(&pr->pr_mtx); 177 } 178 179 mtx_lock(&osname_lock); 180 bcopy(linux_osname, dst, LINUX_MAX_UTSNAME); 181 mtx_unlock(&osname_lock); 182 } 183 184 int 185 linux_set_osname(struct thread *td, char *osname) 186 { 187 struct prison *pr; 188 struct linux_prison *lpr; 189 190 pr = linux_get_prison(td); 191 if (pr != NULL) { 192 lpr = (struct linux_prison *)pr->pr_linux; 193 strcpy(lpr->pr_osname, osname); 194 mtx_unlock(&pr->pr_mtx); 195 } else { 196 mtx_lock(&osname_lock); 197 strcpy(linux_osname, osname); 198 mtx_unlock(&osname_lock); 199 } 200 201 return (0); 202 } 203 204 void 205 linux_get_osrelease(struct thread *td, char *dst) 206 { 207 register struct prison *pr; 208 struct linux_prison *lpr; 209 210 pr = td->td_ucred->cr_prison; 211 if (pr != NULL) { 212 mtx_lock(&pr->pr_mtx); 213 if (pr->pr_linux != NULL) { 214 lpr = (struct linux_prison *)pr->pr_linux; 215 if (lpr->pr_osrelease[0]) { 216 bcopy(lpr->pr_osrelease, dst, 217 LINUX_MAX_UTSNAME); 218 mtx_unlock(&pr->pr_mtx); 219 return; 220 } 221 } 222 mtx_unlock(&pr->pr_mtx); 223 } 224 225 mtx_lock(&osname_lock); 226 bcopy(linux_osrelease, dst, LINUX_MAX_UTSNAME); 227 mtx_unlock(&osname_lock); 228 } 229 230 int 231 linux_set_osrelease(struct thread *td, char *osrelease) 232 { 233 struct prison *pr; 234 struct linux_prison *lpr; 235 236 pr = linux_get_prison(td); 237 if (pr != NULL) { 238 lpr = (struct linux_prison *)pr->pr_linux; 239 strcpy(lpr->pr_osrelease, osrelease); 240 mtx_unlock(&pr->pr_mtx); 241 } else { 242 mtx_lock(&osname_lock); 243 strcpy(linux_osrelease, osrelease); 244 mtx_unlock(&osname_lock); 245 } 246 247 return (0); 248 } 249 250 int 251 linux_get_oss_version(struct thread *td) 252 { 253 register struct prison *pr; 254 register struct linux_prison *lpr; 255 int version; 256 257 pr = td->td_ucred->cr_prison; 258 if (pr != NULL) { 259 mtx_lock(&pr->pr_mtx); 260 if (pr->pr_linux != NULL) { 261 lpr = (struct linux_prison *)pr->pr_linux; 262 if (lpr->pr_oss_version) { 263 version = lpr->pr_oss_version; 264 mtx_unlock(&pr->pr_mtx); 265 return (version); 266 } 267 } 268 mtx_unlock(&pr->pr_mtx); 269 } 270 271 mtx_lock(&osname_lock); 272 version = linux_oss_version; 273 mtx_unlock(&osname_lock); 274 return (version); 275 } 276 277 int 278 linux_set_oss_version(struct thread *td, int oss_version) 279 { 280 struct prison *pr; 281 struct linux_prison *lpr; 282 283 pr = linux_get_prison(td); 284 if (pr != NULL) { 285 lpr = (struct linux_prison *)pr->pr_linux; 286 lpr->pr_oss_version = oss_version; 287 mtx_unlock(&pr->pr_mtx); 288 } else { 289 mtx_lock(&osname_lock); 290 linux_oss_version = oss_version; 291 mtx_unlock(&osname_lock); 292 } 293 294 return (0); 295 } 296 297 #ifdef DEBUG 298 299 u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))]; 300 301 static int 302 linux_debug(int syscall, int toggle, int global) 303 { 304 305 if (global) { 306 char c = toggle ? 0 : 0xff; 307 308 memset(linux_debug_map, c, sizeof(linux_debug_map)); 309 return (0); 310 } 311 if (syscall < 0 || syscall >= LINUX_SYS_MAXSYSCALL) 312 return (EINVAL); 313 if (toggle) 314 clrbit(linux_debug_map, syscall); 315 else 316 setbit(linux_debug_map, syscall); 317 return (0); 318 } 319 320 /* 321 * Usage: sysctl linux.debug=<syscall_nr>.<0/1> 322 * 323 * E.g.: sysctl linux.debug=21.0 324 * 325 * As a special case, syscall "all" will apply to all syscalls globally. 326 */ 327 #define LINUX_MAX_DEBUGSTR 16 328 static int 329 linux_sysctl_debug(SYSCTL_HANDLER_ARGS) 330 { 331 char value[LINUX_MAX_DEBUGSTR], *p; 332 int error, sysc, toggle; 333 int global = 0; 334 335 value[0] = '\0'; 336 error = sysctl_handle_string(oidp, value, LINUX_MAX_DEBUGSTR, req); 337 if (error || req->newptr == NULL) 338 return (error); 339 for (p = value; *p != '\0' && *p != '.'; p++); 340 if (*p == '\0') 341 return (EINVAL); 342 *p++ = '\0'; 343 sysc = strtol(value, NULL, 0); 344 toggle = strtol(p, NULL, 0); 345 if (strcmp(value, "all") == 0) 346 global = 1; 347 error = linux_debug(sysc, toggle, global); 348 return (error); 349 } 350 351 SYSCTL_PROC(_compat_linux, OID_AUTO, debug, 352 CTLTYPE_STRING | CTLFLAG_RW, 353 0, 0, linux_sysctl_debug, "A", 354 "Linux debugging control"); 355 356 #endif /* DEBUG */ 357