Attachment #215109 for bug #240043

Lines 62-67 static unsigned linux_osd_jail_slot; Link Here

(-)sys/compat/linux/linux_mib.c (+5 lines)
62		62
63	SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0, "Linux mode");	63	SYSCTL_NODE(_compat, OID_AUTO, linux, CTLFLAG_RW, 0, "Linux mode");
64		64
		65	bool linux_map_sched_prio = true;
		66	SYSCTL_BOOL(_compat_linux, OID_AUTO, map_sched_prio, CTLFLAG_RDTUN,
		67	&linux_map_sched_prio, 0, "Map scheduler priorities to Linux priorities "
		68	"(not POSIX compliant)");
		69
65	static int linux_set_osname(struct thread td, char osname);	70	static int linux_set_osname(struct thread td, char osname);
66	static int linux_set_osrelease(struct thread td, char osrelease);	71	static int linux_set_osrelease(struct thread td, char osrelease);
67	static int linux_set_oss_version(struct thread *td, int oss_version);	72	static int linux_set_oss_version(struct thread *td, int oss_version);

Lines 62-65 int linux_kernver(struct thread *td); Link Here

(-)sys/compat/linux/linux_mib.h (+2 lines)
62		62
63	#define linux_use26(t) (linux_kernver(t) >= LINUX_KERNVER_2006000)	63	#define linux_use26(t) (linux_kernver(t) >= LINUX_KERNVER_2006000)
64		64
		65	extern bool linux_map_sched_prio;
		66
65	#endif /* _LINUX_MIB_H_ */	67	#endif /* _LINUX_MIB_H_ */




	if (error)
		return (error);

	if (linux_map_sched_prio) {
		switch (policy) {
		case SCHED_OTHER:
			if (sched_param.sched_priority != 0)
				return (EINVAL);

			sched_param.sched_priority =
			    PRI_MAX_TIMESHARE - PRI_MIN_TIMESHARE;
			break;
		case SCHED_FIFO:
		case SCHED_RR:
			if (sched_param.sched_priority < 1 ||
			    sched_param.sched_priority >= LINUX_MAX_RT_PRIO)
				return (EINVAL);

			/*
			 * Map [1, LINUX_MAX_RT_PRIO - 1] to
			 * [0, RTP_PRIO_MAX - RTP_PRIO_MIN] (rounding down).
			 */
			sched_param.sched_priority =
			    (sched_param.sched_priority - 1) *
			    (RTP_PRIO_MAX - RTP_PRIO_MIN + 1) /
			    (LINUX_MAX_RT_PRIO - 1);
			break;
		}
	}

	tdt = linux_tdfind(td, args->pid, -1);
	if (tdt == NULL)
		return (ESRCH);

		printf(ARGS(sched_get_priority_max, "%d"), args->policy);
#endif

	if (linux_map_sched_prio) {
		switch (args->policy) {
		case LINUX_SCHED_OTHER:
			td->td_retval[0] = 0;
			return (0);
		case LINUX_SCHED_FIFO:
		case LINUX_SCHED_RR:
			td->td_retval[0] = LINUX_MAX_RT_PRIO - 1;
			return (0);
		default:
			return (EINVAL);
		}
	}

	switch (args->policy) {
	case LINUX_SCHED_OTHER:
		bsd.policy = SCHED_OTHER;

		printf(ARGS(sched_get_priority_min, "%d"), args->policy);
#endif

	if (linux_map_sched_prio) {
		switch (args->policy) {
		case LINUX_SCHED_OTHER:
			td->td_retval[0] = 0;
			return (0);
		case LINUX_SCHED_FIFO:
		case LINUX_SCHED_RR:
			td->td_retval[0] = 1;
			return (0);
		default:
			return (EINVAL);
		}
	}

	switch (args->policy) {
	case LINUX_SCHED_OTHER:
		bsd.policy = SCHED_OTHER;

{
	struct sched_param sched_param;
	struct thread *tdt;
	int error, policy;

#ifdef DEBUG
	if (ldebug(sched_setparam))

	if (tdt == NULL)
		return (ESRCH);

	if (linux_map_sched_prio) {
		error = kern_sched_getscheduler(td, tdt, &policy);
		if (error)
			goto out;

		switch (policy) {
		case SCHED_OTHER:
			if (sched_param.sched_priority != 0) {
				error = EINVAL;
				goto out;
			}
			sched_param.sched_priority =
			    PRI_MAX_TIMESHARE - PRI_MIN_TIMESHARE;
			break;
		case SCHED_FIFO:
		case SCHED_RR:
			if (sched_param.sched_priority < 1 ||
			    sched_param.sched_priority >= LINUX_MAX_RT_PRIO) {
				error = EINVAL;
				goto out;
			}
			/*
			 * Map [1, LINUX_MAX_RT_PRIO - 1] to
			 * [0, RTP_PRIO_MAX - RTP_PRIO_MIN] (rounding down).
			 */
			sched_param.sched_priority =
			    (sched_param.sched_priority - 1) *
			    (RTP_PRIO_MAX - RTP_PRIO_MIN + 1) /
			    (LINUX_MAX_RT_PRIO - 1);
			break;
		}
	}

	error = kern_sched_setparam(td, tdt, &sched_param);
out:	PROC_UNLOCK(tdt->td_proc);
	return (error);
}


{
	struct sched_param sched_param;
	struct thread *tdt;
	int error, policy;

#ifdef DEBUG
	if (ldebug(sched_getparam))

		return (ESRCH);

	error = kern_sched_getparam(td, tdt, &sched_param);
	if (error) {
		PROC_UNLOCK(tdt->td_proc);
		return (error);
	}

	if (linux_map_sched_prio) {
		error = kern_sched_getscheduler(td, tdt, &policy);
		PROC_UNLOCK(tdt->td_proc);
		if (error)
			return (error);

		switch (policy) {
		case SCHED_OTHER:
			sched_param.sched_priority = 0;
			break;
		case SCHED_FIFO:
		case SCHED_RR:
			/*
			 * Map [0, RTP_PRIO_MAX - RTP_PRIO_MIN] to
			 * [1, LINUX_MAX_RT_PRIO - 1] (rounding up).
			 */
			sched_param.sched_priority =
			    (sched_param.sched_priority *
			    (LINUX_MAX_RT_PRIO - 1) +
			    (RTP_PRIO_MAX - RTP_PRIO_MIN - 1)) /
			    (RTP_PRIO_MAX - RTP_PRIO_MIN) + 1;
			break;
		}
	} else
		PROC_UNLOCK(tdt->td_proc);

	error = copyout(&sched_param, uap->param, sizeof(sched_param));
	return (error);
}


Lines 105-110 extern const char *linux_kplatform; Link Here

(-)sys/compat/linux/linux_misc.h (+2 lines)
105	#define LINUX_SCHED_FIFO 1	105	#define LINUX_SCHED_FIFO 1
106	#define LINUX_SCHED_RR 2	106	#define LINUX_SCHED_RR 2
107		107
		108	#define LINUX_MAX_RT_PRIO 100
		109
108	struct l_new_utsname {	110	struct l_new_utsname {
109	char sysname[LINUX_MAX_UTSNAME];	111	char sysname[LINUX_MAX_UTSNAME];
110	char nodename[LINUX_MAX_UTSNAME];	112	char nodename[LINUX_MAX_UTSNAME];

Return to bug 240043

Lines 1558-1563 linux_sched_setscheduler(struct thread *td, Link Here

(-)sys/compat/linux/linux_misc.c (-7 / +123 lines)
1558	if (error)	1558	if (error)
1559	return (error);	1559	return (error);
1560		1560
		1561	if (linux_map_sched_prio) {
		1562	switch (policy) {
		1563	case SCHED_OTHER:
		1564	if (sched_param.sched_priority != 0)
		1565	return (EINVAL);
		1566
		1567	sched_param.sched_priority =
		1568	PRI_MAX_TIMESHARE - PRI_MIN_TIMESHARE;
		1569	break;
		1570	case SCHED_FIFO:
		1571	case SCHED_RR:
		1572	if (sched_param.sched_priority < 1 \|\|
		1573	sched_param.sched_priority >= LINUX_MAX_RT_PRIO)
		1574	return (EINVAL);
		1575
		1576	/*
		1577	* Map [1, LINUX_MAX_RT_PRIO - 1] to
		1578	* [0, RTP_PRIO_MAX - RTP_PRIO_MIN] (rounding down).
		1579	*/
		1580	sched_param.sched_priority =
		1581	(sched_param.sched_priority - 1) *
		1582	(RTP_PRIO_MAX - RTP_PRIO_MIN + 1) /
		1583	(LINUX_MAX_RT_PRIO - 1);
		1584	break;
		1585	}
		1586	}
		1587
1561	tdt = linux_tdfind(td, args->pid, -1);	1588	tdt = linux_tdfind(td, args->pid, -1);
1562	if (tdt == NULL)	1589	if (tdt == NULL)
1563	return (ESRCH);	1590	return (ESRCH);
Lines 1611-1616 linux_sched_get_priority_max(struct thread *td, Link Here
1611	printf(ARGS(sched_get_priority_max, "%d"), args->policy);	1638	printf(ARGS(sched_get_priority_max, "%d"), args->policy);
1612	#endif	1639	#endif
1613		1640
		1641	if (linux_map_sched_prio) {
		1642	switch (args->policy) {
		1643	case LINUX_SCHED_OTHER:
		1644	td->td_retval[0] = 0;
		1645	return (0);
		1646	case LINUX_SCHED_FIFO:
		1647	case LINUX_SCHED_RR:
		1648	td->td_retval[0] = LINUX_MAX_RT_PRIO - 1;
		1649	return (0);
		1650	default:
		1651	return (EINVAL);
		1652	}
		1653	}
		1654
1614	switch (args->policy) {	1655	switch (args->policy) {
1615	case LINUX_SCHED_OTHER:	1656	case LINUX_SCHED_OTHER:
1616	bsd.policy = SCHED_OTHER;	1657	bsd.policy = SCHED_OTHER;
Lines 1638-1643 linux_sched_get_priority_min(struct thread *td, Link Here
1638	printf(ARGS(sched_get_priority_min, "%d"), args->policy);	1679	printf(ARGS(sched_get_priority_min, "%d"), args->policy);
1639	#endif	1680	#endif
1640		1681
		1682	if (linux_map_sched_prio) {
		1683	switch (args->policy) {
		1684	case LINUX_SCHED_OTHER:
		1685	td->td_retval[0] = 0;
		1686	return (0);
		1687	case LINUX_SCHED_FIFO:
		1688	case LINUX_SCHED_RR:
		1689	td->td_retval[0] = 1;
		1690	return (0);
		1691	default:
		1692	return (EINVAL);
		1693	}
		1694	}
		1695
1641	switch (args->policy) {	1696	switch (args->policy) {
1642	case LINUX_SCHED_OTHER:	1697	case LINUX_SCHED_OTHER:
1643	bsd.policy = SCHED_OTHER;	1698	bsd.policy = SCHED_OTHER;
Lines 2095-2101 linux_sched_setparam(struct thread *td, Link Here
2095	{	2150	{
2096	struct sched_param sched_param;	2151	struct sched_param sched_param;
2097	struct thread *tdt;	2152	struct thread *tdt;
2098	int error;	2153	int error, policy;
2099		2154
2100	#ifdef DEBUG	2155	#ifdef DEBUG
2101	if (ldebug(sched_setparam))	2156	if (ldebug(sched_setparam))
Lines 2110-2117 linux_sched_setparam(struct thread *td, Link Here
2110	if (tdt == NULL)	2165	if (tdt == NULL)
2111	return (ESRCH);	2166	return (ESRCH);
2112		2167
		2168	if (linux_map_sched_prio) {
		2169	error = kern_sched_getscheduler(td, tdt, &policy);
		2170	if (error)
		2171	goto out;
		2172
		2173	switch (policy) {
		2174	case SCHED_OTHER:
		2175	if (sched_param.sched_priority != 0) {
		2176	error = EINVAL;
		2177	goto out;
		2178	}
		2179	sched_param.sched_priority =
		2180	PRI_MAX_TIMESHARE - PRI_MIN_TIMESHARE;
		2181	break;
		2182	case SCHED_FIFO:
		2183	case SCHED_RR:
		2184	if (sched_param.sched_priority < 1 \|\|
		2185	sched_param.sched_priority >= LINUX_MAX_RT_PRIO) {
		2186	error = EINVAL;
		2187	goto out;
		2188	}
		2189	/*
		2190	* Map [1, LINUX_MAX_RT_PRIO - 1] to
		2191	* [0, RTP_PRIO_MAX - RTP_PRIO_MIN] (rounding down).
		2192	*/
		2193	sched_param.sched_priority =
		2194	(sched_param.sched_priority - 1) *
		2195	(RTP_PRIO_MAX - RTP_PRIO_MIN + 1) /
		2196	(LINUX_MAX_RT_PRIO - 1);
		2197	break;
		2198	}
		2199	}
		2200
2113	error = kern_sched_setparam(td, tdt, &sched_param);	2201	error = kern_sched_setparam(td, tdt, &sched_param);
2114	PROC_UNLOCK(tdt->td_proc);	2202	out: PROC_UNLOCK(tdt->td_proc);
2115	return (error);	2203	return (error);
2116	}	2204	}
2117		2205
Lines 2121-2127 linux_sched_getparam(struct thread *td, Link Here
2121	{	2209	{
2122	struct sched_param sched_param;	2210	struct sched_param sched_param;
2123	struct thread *tdt;	2211	struct thread *tdt;
2124	int error;	2212	int error, policy;
2125		2213
2126	#ifdef DEBUG	2214	#ifdef DEBUG
2127	if (ldebug(sched_getparam))	2215	if (ldebug(sched_getparam))
Lines 2133-2142 linux_sched_getparam(struct thread *td, Link Here
2133	return (ESRCH);	2221	return (ESRCH);
2134		2222
2135	error = kern_sched_getparam(td, tdt, &sched_param);	2223	error = kern_sched_getparam(td, tdt, &sched_param);
2136	PROC_UNLOCK(tdt->td_proc);	2224	if (error) {
2137	if (error == 0)	2225	PROC_UNLOCK(tdt->td_proc);
2138	error = copyout(&sched_param, uap->param,	2226	return (error);
2139	sizeof(sched_param));	2227	}
		2228
		2229	if (linux_map_sched_prio) {
		2230	error = kern_sched_getscheduler(td, tdt, &policy);
		2231	PROC_UNLOCK(tdt->td_proc);
		2232	if (error)
		2233	return (error);
		2234
		2235	switch (policy) {
		2236	case SCHED_OTHER:
		2237	sched_param.sched_priority = 0;
		2238	break;
		2239	case SCHED_FIFO:
		2240	case SCHED_RR:
		2241	/*
		2242	* Map [0, RTP_PRIO_MAX - RTP_PRIO_MIN] to
		2243	* [1, LINUX_MAX_RT_PRIO - 1] (rounding up).
		2244	*/
		2245	sched_param.sched_priority =
		2246	(sched_param.sched_priority *
		2247	(LINUX_MAX_RT_PRIO - 1) +
		2248	(RTP_PRIO_MAX - RTP_PRIO_MIN - 1)) /
		2249	(RTP_PRIO_MAX - RTP_PRIO_MIN) + 1;
		2250	break;
		2251	}
		2252	} else
		2253	PROC_UNLOCK(tdt->td_proc);
		2254
		2255	error = copyout(&sched_param, uap->param, sizeof(sched_param));
2140	return (error);	2256	return (error);
2141	}	2257	}
2142		2258