winsup/cygwin/sched.cc

   1 /* sched.cc: scheduler interface for Cygwin
   2
   3    Written by Robert Collins <rbtcollins@hotmail.com>
   4
   5    This file is part of Cygwin.
   6
   7    This software is a copyrighted work licensed under the terms of the
   8    Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
   9    details. */
  10
  11 #include "winsup.h"
  12 #include "miscfuncs.h"
  13 #include "cygerrno.h"
  14 #include "pinfo.h"
  15 #include "clock.h"
  16 /* for getpid */
  17 #include <unistd.h>
  18 #include <sys/param.h>
  19 #include "registry.h"
  20
  21 /* Win32 priority to UNIX priority Mapping. */
  22
  23 extern "C"
  24 {
  25
  26 /* We support prio values from 1 to 32.  This is marginally in line with Linux
  27    (1 - 99) and matches the POSIX requirement to support at least 32 priority
  28    values. */
  29
  30 /* max priority for policy */
  31 int
  32 sched_get_priority_max (int policy)
  33 {
  34   switch (policy)
  35     {
  36     case SCHED_FIFO:
  37     case SCHED_RR:
  38     case SCHED_OTHER:
  39       return 32;
  40     }
  41   set_errno (EINVAL);
  42   return -1;
  43 }
  44
  45 /* min priority for policy */
  46 int
  47 sched_get_priority_min (int policy)
  48 {
  49   switch (policy)
  50     {
  51     case SCHED_FIFO:
  52     case SCHED_RR:
  53     case SCHED_OTHER:
  54       return 1;
  55     }
  56   set_errno (EINVAL);
  57   return -1;
  58 }
  59
  60 /* Check a scheduler parameter struct for valid settings */
  61 bool
  62 valid_sched_parameters (const struct sched_param *param)
  63 {
  64   return param->sched_priority >= 1 && param->sched_priority <= 32;
  65 }
  66
  67 /* get sched params for process
  68
  69    Note, we're never returning EPERM, always ESRCH. This is by design.
  70    Walking the pid values is a known hole in some OSes. */
  71 int
  72 sched_getparam (pid_t pid, struct sched_param *param)
  73 {
  74   pid_t localpid;
  75   if (!param || pid < 0)
  76     {
  77       set_errno (EINVAL);
  78       return -1;
  79     }
  80
  81   localpid = pid ? pid : getpid ();
  82
  83   DWORD pclass;
  84   HANDLE process;
  85   pinfo p (localpid);
  86
  87   /* get the class */
  88   if (!p)
  89     {
  90       set_errno (ESRCH);
  91       return -1;
  92     }
  93   process = OpenProcess (PROCESS_QUERY_LIMITED_INFORMATION, FALSE,
  94                          p->dwProcessId);
  95   if (!process)
  96     {
  97       set_errno (ESRCH);
  98       return -1;
  99     }
 100   pclass = GetPriorityClass (process);
 101   CloseHandle (process);
 102   if (!pclass)
 103     {
 104       set_errno (ESRCH);
 105       return -1;
 106     }
 107   /* calculate the unix priority. */
 108   switch (pclass)
 109     {
 110     case IDLE_PRIORITY_CLASS:
 111       param->sched_priority = 3;
 112       break;
 113     case BELOW_NORMAL_PRIORITY_CLASS:
 114       param->sched_priority = 9;
 115       break;
 116     case NORMAL_PRIORITY_CLASS:
 117     default:
 118       param->sched_priority = 15;
 119       break;
 120     case ABOVE_NORMAL_PRIORITY_CLASS:
 121       param->sched_priority = 21;
 122       break;
 123     case HIGH_PRIORITY_CLASS:
 124       param->sched_priority = 27;
 125       break;
 126     case REALTIME_PRIORITY_CLASS:
 127       param->sched_priority = 32;
 128       break;
 129     }
 130
 131   return 0;
 132 }
 133
 134 /* get the scheduler for pid
 135
 136    All process's on WIN32 run with SCHED_FIFO.  So we just give an answer.
 137    (WIN32 uses a multi queue FIFO).
 138 */
 139 int
 140 sched_getscheduler (pid_t pid)
 141 {
 142   if (pid < 0)
 143     return ESRCH;
 144   else
 145     return SCHED_FIFO;
 146 }
 147
 148 /* get the time quantum for pid */
 149 int
 150 sched_rr_get_interval (pid_t pid, struct timespec *interval)
 151 {
 152   static const char quantable[2][2][3] =
 153     {{{12, 24, 36}, { 6, 12, 18}},
 154      {{36, 36, 36}, {18, 18, 18}}};
 155   /* FIXME: Clocktickinterval can be 15 ms for multi-processor system. */
 156   static const int clocktickinterval = 10;
 157   static const int quantapertick = 3;
 158
 159   HWND forwin;
 160   DWORD forprocid;
 161   DWORD vfindex, slindex, qindex, prisep;
 162   long nsec;
 163
 164   forwin = GetForegroundWindow ();
 165   if (!forwin)
 166     GetWindowThreadProcessId (forwin, &forprocid);
 167   else
 168     forprocid = 0;
 169
 170   reg_key reg (HKEY_LOCAL_MACHINE, KEY_READ, L"SYSTEM", L"CurrentControlSet",
 171                L"Control", L"PriorityControl", NULL);
 172   if (reg.error ())
 173     {
 174       set_errno (ESRCH);
 175       return -1;
 176     }
 177   prisep = reg.get_dword (L"Win32PrioritySeparation", 2);
 178   pinfo pi (pid ? pid : myself->pid);
 179   if (!pi)
 180     {
 181       set_errno (ESRCH);
 182       return -1;
 183     }
 184
 185   if (pi->dwProcessId == forprocid)
 186     {
 187       qindex = prisep & 3;
 188       qindex = qindex == 3 ? 2 : qindex;
 189     }
 190   else
 191     qindex = 0;
 192   vfindex = ((prisep >> 2) & 3) % 3;
 193   if (vfindex == 0)
 194     vfindex = wincap.is_server () || (prisep & 3) == 0 ? 1 : 0;
 195   else
 196     vfindex -= 1;
 197   slindex = ((prisep >> 4) & 3) % 3;
 198   if (slindex == 0)
 199     slindex = wincap.is_server () ? 1 : 0;
 200   else
 201     slindex -= 1;
 202
 203   nsec = quantable[vfindex][slindex][qindex] / quantapertick
 204          * clocktickinterval * (NSPERSEC / MSPERSEC);
 205   interval->tv_sec = nsec / NSPERSEC;
 206   interval->tv_nsec = nsec % NSPERSEC;
 207
 208   return 0;
 209 }
 210
 211 /* set the scheduling parameters */
 212 int
 213 sched_setparam (pid_t pid, const struct sched_param *param)
 214 {
 215   pid_t localpid;
 216   int pri;
 217   DWORD pclass;
 218   HANDLE process;
 219
 220   if (!param || pid < 0)
 221     {
 222       set_errno (EINVAL);
 223       return -1;
 224     }
 225
 226   if (!valid_sched_parameters (param))
 227     {
 228       set_errno (EINVAL);
 229       return -1;
 230     }
 231
 232   pri = param->sched_priority;
 233
 234   /* calculate our desired priority class.  We only reserve a small area
 235      (31/32) for realtime priority. */
 236   if (pri <= 6)
 237     pclass = IDLE_PRIORITY_CLASS;
 238   else if (pri <= 12)
 239     pclass = BELOW_NORMAL_PRIORITY_CLASS;
 240   else if (pri <= 18)
 241     pclass = NORMAL_PRIORITY_CLASS;
 242   else if (pri <= 24)
 243     pclass = ABOVE_NORMAL_PRIORITY_CLASS;
 244   else if (pri <= 30)
 245     pclass = HIGH_PRIORITY_CLASS;
 246   else
 247     pclass = REALTIME_PRIORITY_CLASS;
 248
 249   localpid = pid ? pid : getpid ();
 250
 251   pinfo p (localpid);
 252
 253   /* set the class */
 254
 255   if (!p)
 256     {
 257       set_errno (ESRCH);
 258       return -1;
 259     }
 260   process = OpenProcess (PROCESS_SET_INFORMATION, FALSE, p->dwProcessId);
 261   if (!process)
 262     {
 263       set_errno (ESRCH);
 264       return -1;
 265     }
 266   if (!SetPriorityClass (process, pclass))
 267     {
 268       CloseHandle (process);
 269       set_errno (EPERM);
 270       return -1;
 271     }
 272   CloseHandle (process);
 273
 274   return 0;
 275 }
 276
 277 /* POSIX thread priorities loosely compare to Windows thread base priorities.
 278
 279    Base priority is a function of process priority class and thread priority.
 280    https://msdn.microsoft.com/en-us/library/windows/desktop/ms685100%28v=vs.85%29.aspx
 281
 282    Note 1:
 283
 284      We deliberately handle the REALTIME prority class the same as the HIGH
 285      priority class.  Realtime has it's own range from 16 to 31 so half the
 286      arena is reserved for REALTIME.  The problem is that this isn't visible
 287      nor expected in the POSIX scenario.  Therefore we hide this here and
 288      fold REALTIME into HIGH.
 289
 290    Note 2:
 291
 292      sched_get_thread_priority is only called internally and only for threads
 293      of the current process, with no good reason for the caller to fail.
 294      Therefore it never returns an error but a valid priority (base value
 295      equivalent to process priority class + THREAD_PRIORITY_NORMAL...
 296
 297    Note 3:
 298
 299      ...multiplied by 2 to stretch the priorities over the entire range 1 - 32.
 300 */
 301
 302 static int
 303 sched_base_prio_from_win_prio_class (DWORD pclass)
 304 {
 305   int base;
 306
 307   switch (pclass)
 308     {
 309     case IDLE_PRIORITY_CLASS:
 310       base = 4;
 311       break;
 312     case BELOW_NORMAL_PRIORITY_CLASS:
 313       base = 6;
 314       break;
 315     case NORMAL_PRIORITY_CLASS:
 316     default:
 317       base = 8;
 318       break;
 319     case ABOVE_NORMAL_PRIORITY_CLASS:
 320       base = 10;
 321       break;
 322     case HIGH_PRIORITY_CLASS:
 323     case REALTIME_PRIORITY_CLASS: /* See above note 1 */
 324       base = 13;
 325       break;
 326     }
 327   return base;
 328 }
 329
 330 int
 331 sched_get_thread_priority (HANDLE thread)
 332 {
 333   int tprio;
 334   DWORD pclass;
 335   int priority;
 336
 337   tprio = GetThreadPriority (thread);
 338   pclass = GetPriorityClass (GetCurrentProcess ());
 339   switch (tprio)
 340     {
 341     case THREAD_PRIORITY_ERROR_RETURN:
 342       priority = sched_base_prio_from_win_prio_class (pclass);
 343       break;
 344     case THREAD_PRIORITY_IDLE:
 345       priority = 1;
 346       break;
 347     case THREAD_PRIORITY_TIME_CRITICAL:
 348       priority = 15;
 349       break;
 350     default:
 351       priority = tprio + sched_base_prio_from_win_prio_class (pclass);
 352       break;
 353     }
 354   return priority << 1; /* See above note 3 */
 355 }
 356
 357 int
 358 sched_set_thread_priority (HANDLE thread, int priority)
 359 {
 360   DWORD pclass;
 361   int tprio;
 362
 363   pclass = GetPriorityClass (GetCurrentProcess ());
 364   if (!pclass)
 365     return EPERM;
 366   if (priority < 1 || priority > 32)
 367     return EINVAL;
 368
 369   priority >>= 1; /* See above note 3 */
 370   if (priority < 1)
 371     priority = 1;
 372   else if (priority > 15)
 373     priority = 15;
 374
 375   if (priority == 1)
 376     tprio = THREAD_PRIORITY_IDLE;
 377   else if (priority == 15)
 378     tprio = THREAD_PRIORITY_TIME_CRITICAL;
 379   else
 380     {
 381       tprio = priority - sched_base_prio_from_win_prio_class (pclass);
 382       /* Intermediate values only allowed in REALTIME_PRIORITY_CLASS. */
 383       if (pclass != REALTIME_PRIORITY_CLASS)
 384         {
 385           if (tprio < THREAD_PRIORITY_LOWEST)
 386             tprio = THREAD_PRIORITY_LOWEST;
 387           else if (tprio > THREAD_PRIORITY_HIGHEST)
 388             tprio = THREAD_PRIORITY_HIGHEST;
 389         }
 390     }
 391   if (!SetThreadPriority (thread, tprio))
 392     /* invalid handle, no access are the only expected errors. */
 393     return EPERM;
 394   return 0;
 395 }
 396
 397 /* set the scheduler */
 398 int
 399 sched_setscheduler (pid_t pid, int policy,
 400                     const struct sched_param *param)
 401 {
 402   /* on win32, you can't change the scheduler. Doh! */
 403   set_errno (ENOSYS);
 404   return -1;
 405 }
 406
 407 /* yield the cpu */
 408 int
 409 sched_yield ()
 410 {
 411   SwitchToThread ();
 412   return 0;
 413 }
 414 EXPORT_ALIAS (sched_yield, pthread_yield)
 415
 416 int
 417 sched_getcpu ()
 418 {
 419   PROCESSOR_NUMBER pnum;
 420
 421   GetCurrentProcessorNumberEx (&pnum);
 422   return pnum.Group * __get_cpus_per_group () + pnum.Number;
 423 }
 424
 425 /* construct an affinity mask with just the 'count' lower-order bits set */
 426 static __cpu_mask
 427 groupmask (int count)
 428 {
 429   if (count >= (int) (NBBY * sizeof (__cpu_mask)))
 430     return ~(__cpu_mask) 0;
 431   else
 432     return ((__cpu_mask) 1 << count) - 1;
 433 }
 434
 435 /* return the affinity mask of the indicated group from the given cpu set */
 436 static __cpu_mask
 437 getgroup (size_t sizeof_set, const cpu_set_t *set, int groupnum)
 438 {
 439   int groupsize = __get_cpus_per_group ();
 440   int bitindex = groupnum * groupsize;
 441
 442   int setsize = NBBY * sizeof_set; // bit size of whole cpu set
 443   if (bitindex + groupsize > setsize)
 444     return (__cpu_mask) 0;
 445
 446   int wordsize = NBBY * sizeof (cpu_set_t);
 447   int wordindex = bitindex / wordsize;
 448
 449   __cpu_mask result = set->__bits[wordindex];
 450   int offset = bitindex % wordsize;
 451   if (offset)
 452     {
 453       result >>= offset;
 454       offset = wordsize - offset;
 455     }
 456   else
 457     offset = wordsize;
 458
 459   if (offset < groupsize)
 460     result |= (set->__bits[wordindex + 1] << offset);
 461   if (groupsize < wordsize)
 462     result &= groupmask (groupsize);
 463
 464   return result;
 465 }
 466
 467 /* set the given affinity mask for indicated group within the given cpu set */
 468 static __cpu_mask
 469 setgroup (size_t sizeof_set, cpu_set_t *set, int groupnum, __cpu_mask aff)
 470 {
 471   int groupsize = __get_cpus_per_group ();
 472   int bitindex = groupnum * groupsize;
 473
 474   int setsize = NBBY * sizeof_set; // bit size of whole cpu set
 475   if (bitindex + groupsize > setsize)
 476     return (__cpu_mask) 0;
 477
 478   int wordsize = NBBY * sizeof (cpu_set_t);
 479   int wordindex = bitindex / wordsize;
 480   int offset = bitindex % wordsize;
 481   __cpu_mask mask = groupmask (groupsize);
 482   aff &= mask;
 483
 484   set->__bits[wordindex] &= ~(mask << offset);
 485   set->__bits[wordindex] |= aff << offset;
 486
 487   if ((bitindex + groupsize - 1) / wordsize != wordindex)
 488     {
 489       offset = wordsize - offset;
 490       set->__bits[wordindex + 1] &= ~(mask >> offset);
 491       set->__bits[wordindex + 1] |= aff >> offset;
 492     }
 493
 494   return aff;
 495 }
 496
 497 /* figure out which processor group the set bits indicate; can only be one */
 498 static int
 499 whichgroup (size_t sizeof_set, const cpu_set_t *set)
 500 {
 501   int res = -1;
 502   int maxgroup = min (__get_group_count (),
 503                       (NBBY * sizeof_set) / __get_cpus_per_group ());
 504
 505   for (int i = 0; i < maxgroup; ++i)
 506     if (getgroup (sizeof_set, set, i))
 507       {
 508         if (res >= 0)
 509           return -1; // error return if more than one group indicated
 510         else
 511           res = i; // remember first group found
 512       }
 513
 514   return res;
 515 }
 516
 517 int
 518 sched_get_thread_affinity (HANDLE thread, size_t sizeof_set, cpu_set_t *set)
 519 {
 520   GROUP_AFFINITY ga;
 521   int status = 0;
 522
 523   if (thread)
 524     {
 525       memset (set, 0, sizeof_set);
 526       if (!GetThreadGroupAffinity (thread, &ga))
 527         {
 528           status = geterrno_from_win_error (GetLastError (), EPERM);
 529           goto done;
 530         }
 531       setgroup (sizeof_set, set, ga.Group, ga.Mask);
 532     }
 533   else
 534     status = ESRCH;
 535
 536 done:
 537   return status;
 538 }
 539
 540 int
 541 __sched_getaffinity_sys (pid_t pid, size_t sizeof_set, cpu_set_t *set)
 542 {
 543   /* Emulate Linux raw sched_getaffinity syscall for benefit of taskset(1) */
 544   HANDLE process = 0;
 545   int status = 0;
 546
 547   pinfo p (pid ? pid : getpid ());
 548   if (p)
 549     {
 550       process = pid && pid != myself->pid ?
 551                 OpenProcess (PROCESS_QUERY_LIMITED_INFORMATION, FALSE,
 552                              p->dwProcessId) : GetCurrentProcess ();
 553       KAFFINITY procmask;
 554       KAFFINITY sysmask;
 555       USHORT groupcount = __CPU_GROUPMAX;
 556       USHORT grouparray[__CPU_GROUPMAX];
 557
 558       if (!GetProcessAffinityMask (process, &procmask, &sysmask))
 559         {
 560           status = geterrno_from_win_error (GetLastError (), EPERM);
 561           goto done;
 562         }
 563       memset (set, 0, sizeof_set);
 564       if (!GetProcessGroupAffinity (process, &groupcount, grouparray))
 565         {
 566           status = geterrno_from_win_error (GetLastError (), EPERM);
 567           goto done;
 568         }
 569
 570       KAFFINITY miscmask = groupmask (__get_cpus_per_group ());
 571       for (int i = 0; i < groupcount; i++)
 572         setgroup (sizeof_set, set, grouparray[i], miscmask);
 573     }
 574   else
 575     status = ESRCH;
 576
 577 done:
 578   if (process && process != GetCurrentProcess ())
 579     CloseHandle (process);
 580
 581   if (status)
 582     {
 583       set_errno (status);
 584       return -1;
 585     }
 586
 587   /* On successful return, we would ordinarily return 0, but instead we
 588      emulate the behavior of the raw sched_getaffinity syscall on Linux. */
 589   return min (sizeof_set, sizeof (cpu_set_t));
 590 }
 591
 592 int
 593 sched_getaffinity (pid_t pid, size_t sizeof_set, cpu_set_t *set)
 594 {
 595   /* Emulate the Linux glibc interface of sched_getaffinity() by calling
 596      the raw syscall emulation and mapping positive results to 0. */
 597   int status = __sched_getaffinity_sys (pid, sizeof_set, set);
 598   return status > 0 ? 0 : status;
 599 }
 600
 601 int
 602 sched_set_thread_affinity (HANDLE thread, size_t sizeof_set, const cpu_set_t *set)
 603 {
 604   GROUP_AFFINITY ga;
 605   int group = whichgroup (sizeof_set, set);
 606   int status = 0;
 607
 608   if (thread)
 609     {
 610       if (group < 0)
 611         {
 612           status = EINVAL;
 613           goto done;
 614         }
 615       memset (&ga, 0, sizeof (ga));
 616       ga.Mask = getgroup (sizeof_set, set, group);
 617       ga.Group = group;
 618       if (!SetThreadGroupAffinity (thread, &ga, NULL))
 619         {
 620           status = geterrno_from_win_error (GetLastError (), EPERM);
 621           goto done;
 622         }
 623     }
 624   else
 625     status = ESRCH;
 626
 627 done:
 628   return status;
 629 }
 630
 631 int
 632 sched_setaffinity (pid_t pid, size_t sizeof_set, const cpu_set_t *set)
 633 {
 634   USHORT groupcount = __CPU_GROUPMAX;
 635   USHORT grouparray[__CPU_GROUPMAX];
 636   int group = whichgroup (sizeof_set, set);
 637   HANDLE process = 0;
 638   int status = 0;
 639
 640   pinfo p (pid ? pid : getpid ());
 641   if (p)
 642     {
 643       process = pid && pid != myself->pid ?
 644                 OpenProcess (PROCESS_SET_INFORMATION, FALSE,
 645                              p->dwProcessId) : GetCurrentProcess ();
 646       if (!GetProcessGroupAffinity (process, &groupcount, grouparray))
 647         {
 648           status = geterrno_from_win_error (GetLastError (), EPERM);
 649           goto done;
 650         }
 651       if (group < 0)
 652         {
 653           status = EINVAL;
 654           goto done;
 655         }
 656       if (groupcount == 1 && grouparray[0] == group)
 657         {
 658           if (!SetProcessAffinityMask (process, getgroup (sizeof_set, set, group)))
 659             status = geterrno_from_win_error (GetLastError (), EPERM);
 660           goto done;
 661         }
 662
 663       /* If we get here, the user is trying to add the process to another
 664          group or move it from current group to another group.  These ops
 665          are not allowed by Windows.  One has to move one or more of the
 666          process' threads to the new group(s) one by one.  Here, we bail.
 667       */
 668       status = EINVAL;
 669       goto done;
 670     }
 671   else
 672     status = ESRCH;
 673
 674 done:
 675   if (process && process != GetCurrentProcess ())
 676     CloseHandle (process);
 677
 678   if (status)
 679     {
 680       set_errno (status);
 681       return -1;
 682     }
 683
 684   return 0;
 685 }
 686
 687 cpu_set_t *
 688 __cpuset_alloc (int num)
 689 {
 690   return (cpu_set_t *) malloc (CPU_ALLOC_SIZE(num));
 691 }
 692
 693 void
 694 __cpuset_free (cpu_set_t *set)
 695 {
 696   free (set);
 697 }
 698
 699 } /* extern C */