Home | History | Annotate | Line # | Download | only in common
linux_misc_notalpha.c revision 1.106
      1 /*	$NetBSD: linux_misc_notalpha.c,v 1.106 2009/06/02 13:00:23 njoly Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1995, 1998, 2008 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Frank van der Linden and Eric Haszlakiewicz; by Jason R. Thorpe
      9  * of the Numerical Aerospace Simulation Facility, NASA Ames Research Center.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  *
     20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     30  * POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 #include <sys/cdefs.h>
     34 __KERNEL_RCSID(0, "$NetBSD: linux_misc_notalpha.c,v 1.106 2009/06/02 13:00:23 njoly Exp $");
     35 
     36 #include <sys/param.h>
     37 #include <sys/systm.h>
     38 #include <sys/kernel.h>
     39 #include <sys/mman.h>
     40 #include <sys/mount.h>
     41 #include <sys/malloc.h>
     42 #include <sys/mbuf.h>
     43 #include <sys/namei.h>
     44 #include <sys/proc.h>
     45 #include <sys/prot.h>
     46 #include <sys/ptrace.h>
     47 #include <sys/resource.h>
     48 #include <sys/resourcevar.h>
     49 #include <sys/time.h>
     50 #include <sys/vfs_syscalls.h>
     51 #include <sys/wait.h>
     52 #include <sys/kauth.h>
     53 
     54 #include <sys/syscallargs.h>
     55 
     56 #include <compat/linux/common/linux_types.h>
     57 #include <compat/linux/common/linux_fcntl.h>
     58 #include <compat/linux/common/linux_misc.h>
     59 #include <compat/linux/common/linux_mmap.h>
     60 #include <compat/linux/common/linux_signal.h>
     61 #include <compat/linux/common/linux_util.h>
     62 #include <compat/linux/common/linux_ipc.h>
     63 #include <compat/linux/common/linux_sem.h>
     64 
     65 #include <compat/linux/linux_syscallargs.h>
     66 
     67 /*
     68  * This file contains routines which are used
     69  * on every linux architechture except the Alpha.
     70  */
     71 
     72 /* Used on: arm, i386, m68k, mips, ppc, sparc, sparc64 */
     73 /* Not used on: alpha */
     74 
     75 #ifdef DEBUG_LINUX
     76 #define DPRINTF(a)	uprintf a
     77 #else
     78 #define DPRINTF(a)
     79 #endif
     80 
     81 #ifndef COMPAT_LINUX32
     82 #if !defined(__m68k__) && !defined(__amd64__)
     83 static void bsd_to_linux_statfs64(const struct statvfs *,
     84 	struct linux_statfs64  *);
     85 #endif
     86 
     87 /*
     88  * Alarm. This is a libc call which uses setitimer(2) in NetBSD.
     89  * Fiddle with the timers to make it work.
     90  *
     91  * XXX This shouldn't be dicking about with the ptimer stuff directly.
     92  */
     93 int
     94 linux_sys_alarm(struct lwp *l, const struct linux_sys_alarm_args *uap, register_t *retval)
     95 {
     96 	/* {
     97 		syscallarg(unsigned int) secs;
     98 	} */
     99 	struct proc *p = l->l_proc;
    100 	struct timespec now;
    101 	struct itimerspec *itp, it;
    102 	struct ptimer *ptp, *spare;
    103 	extern kmutex_t timer_lock;
    104 	struct ptimers *pts;
    105 
    106 	if ((pts = p->p_timers) == NULL)
    107 		pts = timers_alloc(p);
    108 	spare = NULL;
    109 
    110  retry:
    111 	mutex_spin_enter(&timer_lock);
    112 	if (pts && pts->pts_timers[ITIMER_REAL])
    113 		itp = &pts->pts_timers[ITIMER_REAL]->pt_time;
    114 	else
    115 		itp = NULL;
    116 	/*
    117 	 * Clear any pending timer alarms.
    118 	 */
    119 	if (itp) {
    120 		callout_stop(&pts->pts_timers[ITIMER_REAL]->pt_ch);
    121 		timespecclear(&itp->it_interval);
    122 		getnanotime(&now);
    123 		if (timespecisset(&itp->it_value) &&
    124 		    timespeccmp(&itp->it_value, &now, >))
    125 			timespecsub(&itp->it_value, &now, &itp->it_value);
    126 		/*
    127 		 * Return how many seconds were left (rounded up)
    128 		 */
    129 		retval[0] = itp->it_value.tv_sec;
    130 		if (itp->it_value.tv_nsec)
    131 			retval[0]++;
    132 	} else {
    133 		retval[0] = 0;
    134 	}
    135 
    136 	/*
    137 	 * alarm(0) just resets the timer.
    138 	 */
    139 	if (SCARG(uap, secs) == 0) {
    140 		if (itp)
    141 			timespecclear(&itp->it_value);
    142 		mutex_spin_exit(&timer_lock);
    143 		return 0;
    144 	}
    145 
    146 	/*
    147 	 * Check the new alarm time for sanity, and set it.
    148 	 */
    149 	timespecclear(&it.it_interval);
    150 	it.it_value.tv_sec = SCARG(uap, secs);
    151 	it.it_value.tv_nsec = 0;
    152 	if (itimespecfix(&it.it_value) || itimespecfix(&it.it_interval)) {
    153 		mutex_spin_exit(&timer_lock);
    154 		return (EINVAL);
    155 	}
    156 
    157 	ptp = pts->pts_timers[ITIMER_REAL];
    158 	if (ptp == NULL) {
    159 		if (spare == NULL) {
    160 			mutex_spin_exit(&timer_lock);
    161 			spare = pool_get(&ptimer_pool, PR_WAITOK);
    162 			goto retry;
    163 		}
    164 		ptp = spare;
    165 		spare = NULL;
    166 		ptp->pt_ev.sigev_notify = SIGEV_SIGNAL;
    167 		ptp->pt_ev.sigev_signo = SIGALRM;
    168 		ptp->pt_overruns = 0;
    169 		ptp->pt_proc = p;
    170 		ptp->pt_type = CLOCK_REALTIME;
    171 		ptp->pt_entry = CLOCK_REALTIME;
    172 		ptp->pt_active = 0;
    173 		ptp->pt_queued = 0;
    174 		callout_init(&ptp->pt_ch, CALLOUT_MPSAFE);
    175 		pts->pts_timers[ITIMER_REAL] = ptp;
    176 	}
    177 
    178 	if (timespecisset(&it.it_value)) {
    179 		/*
    180 		 * Don't need to check tvhzto() return value, here.
    181 		 * callout_reset() does it for us.
    182 		 */
    183 		getnanotime(&now);
    184 		timespecadd(&it.it_value, &now, &it.it_value);
    185 		callout_reset(&ptp->pt_ch, tshzto(&it.it_value),
    186 		    realtimerexpire, ptp);
    187 	}
    188 	ptp->pt_time = it;
    189 	mutex_spin_exit(&timer_lock);
    190 
    191 	return 0;
    192 }
    193 #endif /* !COMPAT_LINUX32 */
    194 
    195 #if !defined(__amd64__)
    196 int
    197 linux_sys_nice(struct lwp *l, const struct linux_sys_nice_args *uap, register_t *retval)
    198 {
    199 	/* {
    200 		syscallarg(int) incr;
    201 	} */
    202 	struct proc *p = l->l_proc;
    203 	struct sys_setpriority_args bsa;
    204 	int error;
    205 
    206 	SCARG(&bsa, which) = PRIO_PROCESS;
    207 	SCARG(&bsa, who) = 0;
    208 	SCARG(&bsa, prio) = p->p_nice - NZERO + SCARG(uap, incr);
    209 
    210 	error = sys_setpriority(l, &bsa, retval);
    211 	return (error) ? EPERM : 0;
    212 }
    213 #endif /* !__amd64__ */
    214 
    215 #ifndef COMPAT_LINUX32
    216 #ifndef __amd64__
    217 /*
    218  * The old Linux readdir was only able to read one entry at a time,
    219  * even though it had a 'count' argument. In fact, the emulation
    220  * of the old call was better than the original, because it did handle
    221  * the count arg properly. Don't bother with it anymore now, and use
    222  * it to distinguish between old and new. The difference is that the
    223  * newer one actually does multiple entries, and the reclen field
    224  * really is the reclen, not the namelength.
    225  */
    226 int
    227 linux_sys_readdir(struct lwp *l, const struct linux_sys_readdir_args *uap, register_t *retval)
    228 {
    229 	/* {
    230 		syscallarg(int) fd;
    231 		syscallarg(struct linux_dirent *) dent;
    232 		syscallarg(unsigned int) count;
    233 	} */
    234 	int error;
    235 	struct linux_sys_getdents_args da;
    236 
    237 	SCARG(&da, fd) = SCARG(uap, fd);
    238 	SCARG(&da, dent) = SCARG(uap, dent);
    239 	SCARG(&da, count) = 1;
    240 
    241 	error = linux_sys_getdents(l, &da, retval);
    242 	if (error == 0 && *retval > 1)
    243 		*retval = 1;
    244 
    245 	return error;
    246 }
    247 #endif /* !amd64 */
    248 
    249 /*
    250  * I wonder why Linux has gettimeofday() _and_ time().. Still, we
    251  * need to deal with it.
    252  */
    253 int
    254 linux_sys_time(struct lwp *l, const struct linux_sys_time_args *uap, register_t *retval)
    255 {
    256 	/* {
    257 		syscallarg(linux_time_t) *t;
    258 	} */
    259 	struct timeval atv;
    260 	linux_time_t tt;
    261 	int error;
    262 
    263 	microtime(&atv);
    264 
    265 	tt = atv.tv_sec;
    266 	if (SCARG(uap, t) && (error = copyout(&tt, SCARG(uap, t), sizeof tt)))
    267 		return error;
    268 
    269 	retval[0] = tt;
    270 	return 0;
    271 }
    272 
    273 /*
    274  * utime(). Do conversion to things that utimes() understands,
    275  * and pass it on.
    276  */
    277 int
    278 linux_sys_utime(struct lwp *l, const struct linux_sys_utime_args *uap, register_t *retval)
    279 {
    280 	/* {
    281 		syscallarg(const char *) path;
    282 		syscallarg(struct linux_utimbuf *)times;
    283 	} */
    284 	int error;
    285 	struct timeval tv[2], *tvp;
    286 	struct linux_utimbuf lut;
    287 
    288 	if (SCARG(uap, times) != NULL) {
    289 		if ((error = copyin(SCARG(uap, times), &lut, sizeof lut)))
    290 			return error;
    291 		tv[0].tv_usec = tv[1].tv_usec = 0;
    292 		tv[0].tv_sec = lut.l_actime;
    293 		tv[1].tv_sec = lut.l_modtime;
    294 		tvp = tv;
    295 	} else
    296 		tvp = NULL;
    297 
    298 	return do_sys_utimes(l, NULL, SCARG(uap, path), FOLLOW,
    299 			   tvp,  UIO_SYSSPACE);
    300 }
    301 
    302 #ifndef __amd64__
    303 /*
    304  * waitpid(2).  Just forward on to linux_sys_wait4 with a NULL rusage.
    305  */
    306 int
    307 linux_sys_waitpid(struct lwp *l, const struct linux_sys_waitpid_args *uap, register_t *retval)
    308 {
    309 	/* {
    310 		syscallarg(int) pid;
    311 		syscallarg(int *) status;
    312 		syscallarg(int) options;
    313 	} */
    314 	struct linux_sys_wait4_args linux_w4a;
    315 
    316 	SCARG(&linux_w4a, pid) = SCARG(uap, pid);
    317 	SCARG(&linux_w4a, status) = SCARG(uap, status);
    318 	SCARG(&linux_w4a, options) = SCARG(uap, options);
    319 	SCARG(&linux_w4a, rusage) = NULL;
    320 
    321 	return linux_sys_wait4(l, &linux_w4a, retval);
    322 }
    323 #endif /* !amd64 */
    324 
    325 int
    326 linux_sys_setresgid(struct lwp *l, const struct linux_sys_setresgid_args *uap, register_t *retval)
    327 {
    328 	/* {
    329 		syscallarg(gid_t) rgid;
    330 		syscallarg(gid_t) egid;
    331 		syscallarg(gid_t) sgid;
    332 	} */
    333 
    334 	/*
    335 	 * Note: These checks are a little different than the NetBSD
    336 	 * setregid(2) call performs.  This precisely follows the
    337 	 * behavior of the Linux kernel.
    338 	 */
    339 	return do_setresgid(l, SCARG(uap,rgid), SCARG(uap, egid),
    340 			    SCARG(uap, sgid),
    341 			    ID_R_EQ_R | ID_R_EQ_E | ID_R_EQ_S |
    342 			    ID_E_EQ_R | ID_E_EQ_E | ID_E_EQ_S |
    343 			    ID_S_EQ_R | ID_S_EQ_E | ID_S_EQ_S );
    344 }
    345 
    346 int
    347 linux_sys_getresgid(struct lwp *l, const struct linux_sys_getresgid_args *uap, register_t *retval)
    348 {
    349 	/* {
    350 		syscallarg(gid_t *) rgid;
    351 		syscallarg(gid_t *) egid;
    352 		syscallarg(gid_t *) sgid;
    353 	} */
    354 	kauth_cred_t pc = l->l_cred;
    355 	int error;
    356 	gid_t gid;
    357 
    358 	/*
    359 	 * Linux copies these values out to userspace like so:
    360 	 *
    361 	 *	1. Copy out rgid.
    362 	 *	2. If that succeeds, copy out egid.
    363 	 *	3. If both of those succeed, copy out sgid.
    364 	 */
    365 	gid = kauth_cred_getgid(pc);
    366 	if ((error = copyout(&gid, SCARG(uap, rgid), sizeof(gid_t))) != 0)
    367 		return (error);
    368 
    369 	gid = kauth_cred_getegid(pc);
    370 	if ((error = copyout(&gid, SCARG(uap, egid), sizeof(gid_t))) != 0)
    371 		return (error);
    372 
    373 	gid = kauth_cred_getsvgid(pc);
    374 
    375 	return (copyout(&gid, SCARG(uap, sgid), sizeof(gid_t)));
    376 }
    377 
    378 #ifndef __amd64__
    379 /*
    380  * I wonder why Linux has settimeofday() _and_ stime().. Still, we
    381  * need to deal with it.
    382  */
    383 int
    384 linux_sys_stime(struct lwp *l, const struct linux_sys_stime_args *uap, register_t *retval)
    385 {
    386 	/* {
    387 		syscallarg(linux_time_t) *t;
    388 	} */
    389 	struct timespec ats;
    390 	linux_time_t tt;
    391 	int error;
    392 
    393 	if ((error = copyin(SCARG(uap, t), &tt, sizeof tt)) != 0)
    394 		return error;
    395 
    396 	ats.tv_sec = tt;
    397 	ats.tv_nsec = 0;
    398 
    399 	if ((error = settime(l->l_proc, &ats)))
    400 		return (error);
    401 
    402 	return 0;
    403 }
    404 #endif /* !amd64 */
    405 
    406 #if !defined(__m68k__) && !defined(__amd64__)
    407 /*
    408  * Convert NetBSD statvfs structure to Linux statfs64 structure.
    409  * See comments in bsd_to_linux_statfs() for further background.
    410  * We can safely pass correct bsize and frsize here, since Linux glibc
    411  * statvfs() doesn't use statfs64().
    412  */
    413 static void
    414 bsd_to_linux_statfs64(const struct statvfs *bsp, struct linux_statfs64 *lsp)
    415 {
    416 	int i, div;
    417 
    418 	for (i = 0; i < linux_fstypes_cnt; i++) {
    419 		if (strcmp(bsp->f_fstypename, linux_fstypes[i].bsd) == 0) {
    420 			lsp->l_ftype = linux_fstypes[i].linux;
    421 			break;
    422 		}
    423 	}
    424 
    425 	if (i == linux_fstypes_cnt) {
    426 		DPRINTF(("unhandled fstype in linux emulation: %s\n",
    427 		    bsp->f_fstypename));
    428 		lsp->l_ftype = LINUX_DEFAULT_SUPER_MAGIC;
    429 	}
    430 
    431 	div = bsp->f_frsize ? (bsp->f_bsize / bsp->f_frsize) : 1;
    432 	if (div == 0)
    433 		div = 1;
    434 	lsp->l_fbsize = bsp->f_bsize;
    435 	lsp->l_ffrsize = bsp->f_frsize;
    436 	lsp->l_fblocks = bsp->f_blocks / div;
    437 	lsp->l_fbfree = bsp->f_bfree / div;
    438 	lsp->l_fbavail = bsp->f_bavail / div;
    439 	lsp->l_ffiles = bsp->f_files;
    440 	lsp->l_fffree = bsp->f_ffree / div;
    441 	/* Linux sets the fsid to 0..., we don't */
    442 	lsp->l_ffsid.val[0] = bsp->f_fsidx.__fsid_val[0];
    443 	lsp->l_ffsid.val[1] = bsp->f_fsidx.__fsid_val[1];
    444 	lsp->l_fnamelen = bsp->f_namemax;
    445 	(void)memset(lsp->l_fspare, 0, sizeof(lsp->l_fspare));
    446 }
    447 
    448 /*
    449  * Implement the fs stat functions. Straightforward.
    450  */
    451 int
    452 linux_sys_statfs64(struct lwp *l, const struct linux_sys_statfs64_args *uap, register_t *retval)
    453 {
    454 	/* {
    455 		syscallarg(const char *) path;
    456 		syscallarg(size_t) sz;
    457 		syscallarg(struct linux_statfs64 *) sp;
    458 	} */
    459 	struct statvfs *sb;
    460 	struct linux_statfs64 ltmp;
    461 	int error;
    462 
    463 	if (SCARG(uap, sz) != sizeof ltmp)
    464 		return (EINVAL);
    465 
    466 	sb = STATVFSBUF_GET();
    467 	error = do_sys_pstatvfs(l, SCARG(uap, path), ST_WAIT, sb);
    468 	if (error == 0) {
    469 		bsd_to_linux_statfs64(sb, &ltmp);
    470 		error = copyout(&ltmp, SCARG(uap, sp), sizeof ltmp);
    471 	}
    472 	STATVFSBUF_PUT(sb);
    473 	return error;
    474 }
    475 
    476 int
    477 linux_sys_fstatfs64(struct lwp *l, const struct linux_sys_fstatfs64_args *uap, register_t *retval)
    478 {
    479 	/* {
    480 		syscallarg(int) fd;
    481 		syscallarg(size_t) sz;
    482 		syscallarg(struct linux_statfs64 *) sp;
    483 	} */
    484 	struct statvfs *sb;
    485 	struct linux_statfs64 ltmp;
    486 	int error;
    487 
    488 	if (SCARG(uap, sz) != sizeof ltmp)
    489 		return (EINVAL);
    490 
    491 	sb = STATVFSBUF_GET();
    492 	error = do_sys_fstatvfs(l, SCARG(uap, fd), ST_WAIT, sb);
    493 	if (error == 0) {
    494 		bsd_to_linux_statfs64(sb, &ltmp);
    495 		error = copyout(&ltmp, SCARG(uap, sp), sizeof ltmp);
    496 	}
    497 	STATVFSBUF_PUT(sb);
    498 	return error;
    499 }
    500 #endif /* !__m68k__ && !__amd64__ */
    501 #endif /* !COMPAT_LINUX32 */
    502