#include <unistd.h>
#include "registry.h"
-/* Win32 priority to UNIX priority Mapping.
-
- For now, I'm just following the spec: any range of priorities is ok.
- There are probably many many issues with this...
-
- FIXME: We don't support pre-Windows 2000 so we should fix the priority
- computation. Here's the description for the current code:
-
- We don't want process's going realtime. Well, they probably could, but
- the issues with avoiding the priority values 17-22 and 27-30 (not
- supported before win2k) make that inefficient.
-
- However to complicate things most unixes use lower is better priorities.
-
- So we map -14 to 15, and 15 to 1 via (16- ((n+16) >> 1)). We then map 1
- to 15 to various process class and thread priority combinations. Then we
- need to look at the threads process priority. As win95, 98 and NT 4
- don't support opening threads cross-process (unless a thread HANDLE is
- passed around) for now, we'll just use the priority class.
-
- The code and logic are present to calculate the priority for thread, if a
- thread handle can be obtained. Alternatively, if the symbols wouldn't be
- resolved until they are used we could support this.
-
- Lastly, because we can't assume that the pid we're given are Windows pids,
- we can't alter non-cygwin started programs. */
+/* Win32 priority to UNIX priority Mapping. */
extern "C"
{
+/* We support prio values from 1 to 32. This is marginally in line with Linux
+ (1 - 99) and matches the POSIX requirement to support at least 32 priority
+ values. */
+
/* max priority for policy */
int
sched_get_priority_max (int policy)
{
- if (policy < 1 || policy > 3)
+ switch (policy)
{
- set_errno (EINVAL);
- return -1;
+ case SCHED_FIFO:
+ case SCHED_RR:
+ case SCHED_OTHER:
+ return 32;
}
- return -14;
+ set_errno (EINVAL);
+ return -1;
}
/* min priority for policy */
int
sched_get_priority_min (int policy)
{
- if (policy < 1 || policy > 3)
+ switch (policy)
{
- set_errno (EINVAL);
- return -1;
+ case SCHED_FIFO:
+ case SCHED_RR:
+ case SCHED_OTHER:
+ return 1;
}
- return 15;
+ set_errno (EINVAL);
+ return -1;
}
/* Check a scheduler parameter struct for valid settings */
-int
+bool
valid_sched_parameters (const struct sched_param *param)
{
- if (param->sched_priority < -14 || param->sched_priority > 15)
- {
- return 0;
- }
- return -1;
-
+ return param->sched_priority >= 1 && param->sched_priority <= 32;
}
/* get sched params for process
- Note, I'm never returning EPERM,
- Always ESRCH. This is by design (If cygwin ever looks at paranoid security
- Walking the pid values is a known hole in some os's)
-*/
+ Note, we're never returning EPERM, always ESRCH. This is by design.
+ Walking the pid values is a known hole in some OSes. */
int
sched_getparam (pid_t pid, struct sched_param *param)
{
pid_t localpid;
- int winpri;
if (!param || pid < 0)
{
set_errno (EINVAL);
localpid = pid ? pid : getpid ();
- DWORD Class;
- int ThreadPriority;
+ DWORD pclass;
HANDLE process;
pinfo p (localpid);
/* get the class */
-
if (!p)
{
set_errno (ESRCH);
return -1;
}
- process = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, p->dwProcessId);
+ process = OpenProcess (PROCESS_QUERY_LIMITED_INFORMATION, FALSE,
+ p->dwProcessId);
if (!process)
{
set_errno (ESRCH);
return -1;
}
- Class = GetPriorityClass (process);
+ pclass = GetPriorityClass (process);
CloseHandle (process);
- if (!Class)
+ if (!pclass)
{
set_errno (ESRCH);
return -1;
}
- ThreadPriority = THREAD_PRIORITY_NORMAL;
-
/* calculate the unix priority. */
-
- switch (Class)
+ switch (pclass)
{
case IDLE_PRIORITY_CLASS:
- switch (ThreadPriority)
- {
- case THREAD_PRIORITY_IDLE:
- winpri = 1;
- break;
- case THREAD_PRIORITY_LOWEST:
- winpri = 2;
- break;
- case THREAD_PRIORITY_BELOW_NORMAL:
- winpri = 3;
- break;
- case THREAD_PRIORITY_NORMAL:
- winpri = 4;
- break;
- case THREAD_PRIORITY_ABOVE_NORMAL:
- winpri = 5;
- break;
- case THREAD_PRIORITY_HIGHEST:
- default:
- winpri = 6;
- break;
- }
+ param->sched_priority = 3;
break;
- case HIGH_PRIORITY_CLASS:
- switch (ThreadPriority)
- {
- case THREAD_PRIORITY_IDLE:
- winpri = 1;
- break;
- case THREAD_PRIORITY_LOWEST:
- winpri = 11;
- break;
- case THREAD_PRIORITY_BELOW_NORMAL:
- winpri = 12;
- break;
- case THREAD_PRIORITY_NORMAL:
- winpri = 13;
- break;
- case THREAD_PRIORITY_ABOVE_NORMAL:
- winpri = 14;
- break;
- case THREAD_PRIORITY_HIGHEST:
- default:
- winpri = 15;
- break;
- }
+ case BELOW_NORMAL_PRIORITY_CLASS:
+ param->sched_priority = 9;
break;
case NORMAL_PRIORITY_CLASS:
default:
- switch (ThreadPriority)
- {
- case THREAD_PRIORITY_IDLE:
- winpri = 1;
- break;
- case THREAD_PRIORITY_LOWEST:
- winpri = 7;
- break;
- case THREAD_PRIORITY_BELOW_NORMAL:
- winpri = 8;
- break;
- case THREAD_PRIORITY_NORMAL:
- winpri = 9;
- break;
- case THREAD_PRIORITY_ABOVE_NORMAL:
- winpri = 10;
- break;
- case THREAD_PRIORITY_HIGHEST:
- default:
- winpri = 11;
- break;
- }
+ param->sched_priority = 15;
+ break;
+ case ABOVE_NORMAL_PRIORITY_CLASS:
+ param->sched_priority = 21;
+ break;
+ case HIGH_PRIORITY_CLASS:
+ param->sched_priority = 27;
+ break;
+ case REALTIME_PRIORITY_CLASS:
+ param->sched_priority = 32;
break;
}
- /* reverse out winpri = (16- ((unixpri+16) >> 1)) */
- /*
- winpri-16 = - (unixpri +16 ) >> 1
-
- -(winpri-16) = unixpri +16 >> 1
- (-(winpri-16)) << 1 = unixpri+16
- ((-(winpri - 16)) << 1) - 16 = unixpri
- */
-
- param->sched_priority = ((-(winpri - 16)) << 1) - 16;
-
return 0;
}
/* get the scheduler for pid
- All process's on WIN32 run with SCHED_FIFO.
- So we just give an answer.
+ All process's on WIN32 run with SCHED_FIFO. So we just give an answer.
(WIN32 uses a multi queue FIFO).
*/
int
sched_setparam (pid_t pid, const struct sched_param *param)
{
pid_t localpid;
- int winpri;
- DWORD Class;
+ int pri;
+ DWORD pclass;
HANDLE process;
if (!param || pid < 0)
return -1;
}
- /* winpri = (16- ((unixpri+16) >> 1)) */
- winpri = 16 - ((param->sched_priority + 16) >> 1);
-
- /* calculate our desired priority class and thread priority */
-
- if (winpri < 7)
- Class = IDLE_PRIORITY_CLASS;
- else if (winpri > 10)
- Class = HIGH_PRIORITY_CLASS;
+ pri = param->sched_priority;
+
+ /* calculate our desired priority class. We only reserve a small area
+ (31/32) for realtime priority. */
+ if (pri <= 6)
+ pclass = IDLE_PRIORITY_CLASS;
+ else if (pri <= 12)
+ pclass = BELOW_NORMAL_PRIORITY_CLASS;
+ else if (pri <= 18)
+ pclass = NORMAL_PRIORITY_CLASS;
+ else if (pri <= 24)
+ pclass = ABOVE_NORMAL_PRIORITY_CLASS;
+ else if (pri <= 30)
+ pclass = HIGH_PRIORITY_CLASS;
else
- Class = NORMAL_PRIORITY_CLASS;
+ pclass = REALTIME_PRIORITY_CLASS;
localpid = pid ? pid : getpid ();
set_errno (ESRCH);
return -1;
}
- process =
- OpenProcess (PROCESS_SET_INFORMATION, FALSE, (DWORD) p->dwProcessId);
+ process = OpenProcess (PROCESS_SET_INFORMATION, FALSE, p->dwProcessId);
if (!process)
{
- set_errno (2); //ESRCH);
+ set_errno (ESRCH);
return -1;
}
- if (!SetPriorityClass (process, Class))
+ if (!SetPriorityClass (process, pclass))
{
CloseHandle (process);
set_errno (EPERM);
return 0;
}
-/* we map -14 to 15, and 15 to 1 via (16- ((n+16) >> 1)). This lines up with
- the allowed values we return elsewhere in the sched* functions. We then
- map in groups of three to allowed thread priority's. The reason for dropping
- accuracy while still returning a wide range of values is to allow more
- flexible code in the future. */
+/* POSIX thread priorities loosely compare to Windows thread base priorities.
+
+ Base priority is a function of process priority class and thread priority.
+ https://msdn.microsoft.com/en-us/library/windows/desktop/ms685100%28v=vs.85%29.aspx
+
+ Note 1:
+
+ We deliberately handle the REALTIME prority class the same as the HIGH
+ priority class. Realtime has it's own range from 16 to 31 so half the
+ arena is reserved for REALTIME. The problem is that this isn't visible
+ nor expected in the POSIX scenario. Therefore we hide this here and
+ fold REALTIME into HIGH.
+
+ Note 2:
+
+ sched_get_thread_priority is only called internally and only for threads
+ of the current process, with no good reason for the caller to fail.
+ Therefore it never returns an error but a valid priority (base value
+ equivalent to process priority class + THREAD_PRIORITY_NORMAL...
+
+ Note 3:
+
+ ...multiplied by 2 to stretch the priorities over the entire range 1 - 32.
+*/
+
+static int
+sched_base_prio_from_win_prio_class (DWORD pclass)
+{
+ int base;
+
+ switch (pclass)
+ {
+ case IDLE_PRIORITY_CLASS:
+ base = 4;
+ break;
+ case BELOW_NORMAL_PRIORITY_CLASS:
+ base = 6;
+ break;
+ case NORMAL_PRIORITY_CLASS:
+ default:
+ base = 8;
+ break;
+ case ABOVE_NORMAL_PRIORITY_CLASS:
+ base = 10;
+ break;
+ case HIGH_PRIORITY_CLASS:
+ case REALTIME_PRIORITY_CLASS: /* See above note 1 */
+ base = 13;
+ break;
+ }
+ return base;
+}
+
+int
+sched_get_thread_priority (HANDLE thread)
+{
+ int tprio;
+ DWORD pclass;
+ int priority;
+
+ tprio = GetThreadPriority (thread);
+ pclass = GetPriorityClass (GetCurrentProcess ());
+ switch (tprio)
+ {
+ case THREAD_PRIORITY_ERROR_RETURN:
+ priority = sched_base_prio_from_win_prio_class (pclass);
+ break;
+ case THREAD_PRIORITY_IDLE:
+ priority = 1;
+ break;
+ case THREAD_PRIORITY_TIME_CRITICAL:
+ priority = 15;
+ break;
+ default:
+ priority = tprio + sched_base_prio_from_win_prio_class (pclass);
+ break;
+ }
+ return priority << 1; /* See above note 3 */
+}
+
int
sched_set_thread_priority (HANDLE thread, int priority)
{
- int real_pri;
- real_pri = 16 - ((priority + 16) >> 1);
- if (real_pri <1 || real_pri > 15)
+ DWORD pclass;
+ int tprio;
+
+ pclass = GetPriorityClass (GetCurrentProcess ());
+ if (!pclass)
+ return EPERM;
+ if (priority < 1 || priority > 32)
return EINVAL;
- if (real_pri < 4)
- real_pri = THREAD_PRIORITY_LOWEST;
- else if (real_pri < 7)
- real_pri = THREAD_PRIORITY_BELOW_NORMAL;
- else if (real_pri < 10)
- real_pri = THREAD_PRIORITY_NORMAL;
- else if (real_pri < 13)
- real_pri = THREAD_PRIORITY_ABOVE_NORMAL;
- else
- real_pri = THREAD_PRIORITY_HIGHEST;
+ priority >>= 1; /* See above note 3 */
+ if (priority < 1)
+ priority = 1;
+ else if (priority > 15)
+ priority = 15;
- if (!SetThreadPriority (thread, real_pri))
+ if (priority == 1)
+ tprio = THREAD_PRIORITY_IDLE;
+ else if (priority == 15)
+ tprio = THREAD_PRIORITY_TIME_CRITICAL;
+ else
+ {
+ tprio = priority - sched_base_prio_from_win_prio_class (pclass);
+ /* Intermediate values only allowed in REALTIME_PRIORITY_CLASS. */
+ if (pclass != REALTIME_PRIORITY_CLASS)
+ {
+ if (tprio < THREAD_PRIORITY_LOWEST)
+ tprio = THREAD_PRIORITY_LOWEST;
+ else if (tprio > THREAD_PRIORITY_HIGHEST)
+ tprio = THREAD_PRIORITY_HIGHEST;
+ }
+ }
+ if (!SetThreadPriority (thread, tprio))
/* invalid handle, no access are the only expected errors. */
return EPERM;
return 0;
git://sourceware.org / newlib-cygwin.git / commitdiff