1 /* $NetBSD: aoutm68k_stat.c,v 1.6 2002/03/16 20:43:48 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Steve C. Woodford. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: aoutm68k_stat.c,v 1.6 2002/03/16 20:43:48 christos Exp $"); 41 42 #if defined(_KERNEL_OPT) 43 #include "opt_compat_netbsd.h" 44 #include "opt_compat_43.h" 45 #endif 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/mount.h> 50 #include <sys/proc.h> 51 #include <sys/stat.h> 52 53 #include <sys/syscall.h> 54 #include <sys/syscallargs.h> 55 56 #include <compat/aoutm68k/aoutm68k_util.h> 57 #include <compat/aoutm68k/aoutm68k_stat.h> 58 #include <compat/aoutm68k/aoutm68k_syscall.h> 59 #include <compat/aoutm68k/aoutm68k_syscallargs.h> 60 61 #ifdef COMPAT_43 62 static void aoutm68k_stat43_convert(struct stat43 *, struct aoutm68k_stat43 *); 63 #endif 64 #ifdef COMPAT_12 65 static void aoutm68k_stat12_convert(struct stat12 *, struct aoutm68k_stat12 *); 66 #endif 67 static void aoutm68k_stat13_convert(struct stat *, struct aoutm68k_stat *); 68 69 70 #ifdef COMPAT_43 71 int 72 aoutm68k_compat_43_sys_stat(p, v, retval) 73 struct proc *p; 74 void *v; 75 register_t *retval; 76 { 77 struct aoutm68k_compat_43_sys_stat_args *uap = v; 78 caddr_t sg = stackgap_init(p, 0); 79 struct compat_43_sys_stat_args cup; 80 struct aoutm68k_stat43 ast; 81 struct stat43 st; 82 int error; 83 84 SCARG(&cup, ub) = stackgap_alloc(p, &sg, sizeof(st)); 85 #ifdef COMPAT_AOUT_ALTPATH 86 CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); 87 #endif 88 SCARG(&cup, path) = SCARG(uap, path); 89 90 if ((error = compat_43_sys_stat(p, &cup, retval)) != 0 || 91 (error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0) 92 return (error); 93 94 aoutm68k_stat43_convert(&st, &ast); 95 96 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, ub), sizeof(ast))); 97 } 98 99 int 100 aoutm68k_compat_43_sys_fstat(p, v, retval) 101 struct proc *p; 102 void *v; 103 register_t *retval; 104 { 105 struct aoutm68k_compat_43_sys_fstat_args *uap = v; 106 caddr_t sg = stackgap_init(p, 0); 107 struct compat_43_sys_fstat_args cup; 108 struct aoutm68k_stat43 ast; 109 struct stat43 st; 110 int error; 111 112 SCARG(&cup, fd) = SCARG(uap, fd); 113 SCARG(&cup, sb) = stackgap_alloc(p, &sg, sizeof(st)); 114 115 if ((error = compat_43_sys_fstat(p, &cup, retval)) != 0 || 116 (error = copyin(SCARG(&cup, sb), &st, sizeof(st))) != 0) 117 return (error); 118 119 aoutm68k_stat43_convert(&st, &ast); 120 121 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, sb), sizeof(ast))); 122 } 123 124 int 125 aoutm68k_compat_43_sys_lstat(p, v, retval) 126 struct proc *p; 127 void *v; 128 register_t *retval; 129 { 130 struct aoutm68k_compat_43_sys_lstat_args *uap = v; 131 caddr_t sg = stackgap_init(p, 0); 132 struct compat_43_sys_lstat_args cup; 133 struct aoutm68k_stat43 ast; 134 struct stat43 st; 135 int error; 136 137 SCARG(&cup, ub) = stackgap_alloc(p, &sg, sizeof(st)); 138 #ifdef COMPAT_AOUT_ALTPATH 139 CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); 140 #endif 141 SCARG(&cup, path) = SCARG(uap, path); 142 143 if ((error = compat_43_sys_lstat(p, &cup, retval)) != 0 || 144 (error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0) 145 return (error); 146 147 aoutm68k_stat43_convert(&st, &ast); 148 149 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, ub), sizeof(ast))); 150 } 151 #endif /* COMPAT_43 */ 152 153 #ifdef COMPAT_12 154 int 155 aoutm68k_compat_12_sys_stat(p, v, retval) 156 struct proc *p; 157 void *v; 158 register_t *retval; 159 { 160 struct aoutm68k_compat_12_sys_stat_args *uap = v; 161 caddr_t sg = stackgap_init(p, 0); 162 struct compat_12_sys_stat_args cup; 163 struct aoutm68k_stat12 ast; 164 struct stat12 st; 165 int error; 166 167 SCARG(&cup, ub) = stackgap_alloc(p, &sg, sizeof(st)); 168 #ifdef COMPAT_AOUT_ALTPATH 169 CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); 170 #endif 171 SCARG(&cup, path) = SCARG(uap, path); 172 173 if ((error = compat_12_sys_stat(p, &cup, retval)) != 0 || 174 (error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0) 175 return (error); 176 177 aoutm68k_stat12_convert(&st, &ast); 178 179 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, ub), sizeof(ast))); 180 } 181 182 int 183 aoutm68k_compat_12_sys_fstat(p, v, retval) 184 struct proc *p; 185 void *v; 186 register_t *retval; 187 { 188 struct aoutm68k_compat_12_sys_fstat_args *uap = v; 189 caddr_t sg = stackgap_init(p, 0); 190 struct compat_12_sys_fstat_args cup; 191 struct aoutm68k_stat12 ast; 192 struct stat12 st; 193 int error; 194 195 SCARG(&cup, fd) = SCARG(uap, fd); 196 SCARG(&cup, sb) = stackgap_alloc(p, &sg, sizeof(st)); 197 198 if ((error = compat_12_sys_fstat(p, &cup, retval)) != 0 || 199 (error = copyin(SCARG(&cup, sb), &st, sizeof(st))) != 0) 200 return (error); 201 202 aoutm68k_stat12_convert(&st, &ast); 203 204 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, sb), sizeof(ast))); 205 } 206 207 int 208 aoutm68k_compat_12_sys_lstat(p, v, retval) 209 struct proc *p; 210 void *v; 211 register_t *retval; 212 { 213 struct aoutm68k_compat_12_sys_lstat_args *uap = v; 214 caddr_t sg = stackgap_init(p, 0); 215 struct compat_12_sys_lstat_args cup; 216 struct aoutm68k_stat12 ast; 217 struct stat12 st; 218 int error; 219 220 SCARG(&cup, ub) = stackgap_alloc(p, &sg, sizeof(st)); 221 #ifdef COMPAT_AOUT_ALTPATH 222 CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); 223 #endif 224 SCARG(&cup, path) = SCARG(uap, path); 225 226 if ((error = compat_12_sys_lstat(p, &cup, retval)) != 0 || 227 (error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0) 228 return (error); 229 230 aoutm68k_stat12_convert(&st, &ast); 231 232 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, ub), sizeof(ast))); 233 } 234 #endif /* COMPAT_12 */ 235 236 int 237 aoutm68k_sys___stat13(p, v, retval) 238 struct proc *p; 239 void *v; 240 register_t *retval; 241 { 242 struct aoutm68k_sys___stat13_args *uap = v; 243 caddr_t sg = stackgap_init(p, 0); 244 struct sys___stat13_args cup; 245 struct aoutm68k_stat ast; 246 struct stat st; 247 int error; 248 249 SCARG(&cup, ub) = stackgap_alloc(p, &sg, sizeof(st)); 250 #ifdef COMPAT_AOUT_ALTPATH 251 CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); 252 #endif 253 SCARG(&cup, path) = SCARG(uap, path); 254 255 if ((error = sys___stat13(p, &cup, retval)) != 0 || 256 (error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0) 257 return (error); 258 259 aoutm68k_stat13_convert(&st, &ast); 260 261 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, ub), sizeof(ast))); 262 } 263 264 int 265 aoutm68k_sys___fstat13(p, v, retval) 266 struct proc *p; 267 void *v; 268 register_t *retval; 269 { 270 struct aoutm68k_sys___fstat13_args *uap = v; 271 caddr_t sg = stackgap_init(p, 0); 272 struct sys___fstat13_args cup; 273 struct aoutm68k_stat ast; 274 struct stat st; 275 int error; 276 277 SCARG(&cup, fd) = SCARG(uap, fd); 278 SCARG(&cup, sb) = stackgap_alloc(p, &sg, sizeof(st)); 279 280 if ((error = sys___fstat13(p, &cup, retval)) != 0 || 281 (error = copyin(SCARG(&cup, sb), &st, sizeof(st))) != 0) 282 return (error); 283 284 aoutm68k_stat13_convert(&st, &ast); 285 286 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, sb), sizeof(ast))); 287 288 } 289 290 int 291 aoutm68k_sys___lstat13(p, v, retval) 292 struct proc *p; 293 void *v; 294 register_t *retval; 295 { 296 struct aoutm68k_sys___lstat13_args *uap = v; 297 caddr_t sg = stackgap_init(p, 0); 298 struct sys___lstat13_args cup; 299 struct aoutm68k_stat ast; 300 struct stat st; 301 int error; 302 303 SCARG(&cup, ub) = stackgap_alloc(p, &sg, sizeof(st)); 304 #ifdef COMPAT_AOUT_ALTPATH 305 CHECK_ALT_EXIST(p, &sg, SCARG(uap, path)); 306 #endif 307 SCARG(&cup, path) = SCARG(uap, path); 308 309 if ((error = sys___lstat13(p, &cup, retval)) != 0 || 310 (error = copyin(SCARG(&cup, ub), &st, sizeof(st))) != 0) 311 return (error); 312 313 aoutm68k_stat13_convert(&st, &ast); 314 315 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, ub), sizeof(ast))); 316 } 317 318 int 319 aoutm68k_sys_fhstat(p, v, retval) 320 struct proc *p; 321 void *v; 322 register_t *retval; 323 { 324 struct aoutm68k_sys_fhstat_args *uap = v; 325 caddr_t sg = stackgap_init(p, 0); 326 struct sys_fhstat_args cup; 327 struct aoutm68k_stat ast; 328 struct stat st; 329 int error; 330 331 SCARG(&cup, fhp) = SCARG(uap, fhp); 332 SCARG(&cup, sb) = stackgap_alloc(p, &sg, sizeof(st)); 333 334 if ((error = sys_fhstat(p, &cup, retval)) != 0 || 335 (error = copyin(SCARG(&cup, sb), &st, sizeof(st))) != 0) 336 return (error); 337 338 aoutm68k_stat13_convert(&st, &ast); 339 340 return (copyout((caddr_t)&ast, (caddr_t)SCARG(uap, sb), sizeof(ast))); 341 } 342 343 #ifdef COMPAT_43 344 static void 345 aoutm68k_stat43_convert(st, ast) 346 struct stat43 *st; 347 struct aoutm68k_stat43 *ast; 348 { 349 350 memset(ast, 0, sizeof(*ast)); 351 ast->st_dev = st->st_dev; 352 ast->st_ino = st->st_ino; 353 ast->st_mode = st->st_mode; 354 ast->st_nlink = st->st_nlink; 355 ast->st_uid = st->st_uid; 356 ast->st_gid = st->st_gid; 357 ast->st_rdev = st->st_rdev; 358 ast->st_size = st->st_size; 359 ast->st_atimespec.tv_sec = st->st_atimespec.tv_sec; 360 ast->st_atimespec.tv_nsec = st->st_atimespec.tv_nsec; 361 ast->st_mtimespec.tv_sec = st->st_mtimespec.tv_sec; 362 ast->st_mtimespec.tv_nsec = st->st_mtimespec.tv_nsec; 363 ast->st_ctimespec.tv_sec = st->st_ctimespec.tv_sec; 364 ast->st_ctimespec.tv_nsec = st->st_ctimespec.tv_nsec; 365 ast->st_blksize = st->st_blksize; 366 ast->st_blocks = st->st_blocks; 367 ast->st_flags = st->st_flags; 368 ast->st_gen = st->st_gen; 369 } 370 #endif /* COMPAT_43 */ 371 372 #ifdef COMPAT_12 373 static void 374 aoutm68k_stat12_convert(st, ast) 375 struct stat12 *st; 376 struct aoutm68k_stat12 *ast; 377 { 378 379 memset(ast, 0, sizeof(*ast)); 380 ast->st_dev = st->st_dev; 381 ast->st_ino = st->st_ino; 382 ast->st_mode = st->st_mode; 383 ast->st_nlink = st->st_nlink; 384 ast->st_uid = st->st_uid; 385 ast->st_gid = st->st_gid; 386 ast->st_rdev = st->st_rdev; 387 ast->st_atimespec.tv_sec = st->st_atimespec.tv_sec; 388 ast->st_atimespec.tv_nsec = st->st_atimespec.tv_nsec; 389 ast->st_mtimespec.tv_sec = st->st_mtimespec.tv_sec; 390 ast->st_mtimespec.tv_nsec = st->st_mtimespec.tv_nsec; 391 ast->st_ctimespec.tv_sec = st->st_ctimespec.tv_sec; 392 ast->st_ctimespec.tv_nsec = st->st_ctimespec.tv_nsec; 393 ast->st_size = st->st_size; 394 ast->st_blocks = st->st_blocks; 395 ast->st_blksize = st->st_blksize; 396 ast->st_flags = st->st_flags; 397 ast->st_gen = st->st_gen; 398 ast->st_lspare = st->st_lspare; 399 ast->st_qspare[0] = st->st_qspare[0]; 400 ast->st_qspare[1] = st->st_qspare[1]; 401 } 402 #endif /* COMPAT_12 */ 403 404 static void 405 aoutm68k_stat13_convert(st, ast) 406 struct stat *st; 407 struct aoutm68k_stat *ast; 408 { 409 410 memset(ast, 0, sizeof(*ast)); 411 ast->st_dev = st->st_dev; 412 ast->st_ino = st->st_ino; 413 ast->st_mode = st->st_mode; 414 ast->st_nlink = st->st_nlink; 415 ast->st_uid = st->st_uid; 416 ast->st_gid = st->st_gid; 417 ast->st_rdev = st->st_rdev; 418 ast->st_atimespec.tv_sec = st->st_atimespec.tv_sec; 419 ast->st_atimespec.tv_nsec = st->st_atimespec.tv_nsec; 420 ast->st_mtimespec.tv_sec = st->st_mtimespec.tv_sec; 421 ast->st_mtimespec.tv_nsec = st->st_mtimespec.tv_nsec; 422 ast->st_ctimespec.tv_sec = st->st_ctimespec.tv_sec; 423 ast->st_ctimespec.tv_nsec = st->st_ctimespec.tv_nsec; 424 ast->st_size = st->st_size; 425 ast->st_blocks = st->st_blocks; 426 ast->st_blksize = st->st_blksize; 427 ast->st_flags = st->st_flags; 428 ast->st_gen = st->st_gen; 429 ast->st_qspare[0] = st->st_qspare[0]; 430 ast->st_qspare[1] = st->st_qspare[1]; 431 } 432