Rebase to Cygwin/MSYS2 runtime v3.5.6

.github/workflows/build.yaml

@@ -24,7 +24,7 @@ jobs:
           # resulting in errors due to -Werror. Disable them for now.
           export CXXFLAGS="-Wno-error=stringop-truncation -Wno-error=array-bounds -Wno-error=overloaded-virtual -Wno-narrowing -Wno-use-after-free -Wno-error=maybe-uninitialized"
           (cd winsup && ./autogen.sh)
-          ./configure --disable-dependency-tracking --with-msys2-runtime-commit=$GITHUB_SHA
+          ./configure --disable-dependency-tracking --with-msys2-runtime-commit="$GITHUB_SHA"
           make -j8
 
       - name: Install

.github/workflows/cygwin.yml

@@ -162,7 +162,7 @@ jobs:
 
     # upload test logs to facilitate investigation of problems
     - name: Upload test logs
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: testlogs
         path: |

winsup/cygwin/include/cygwin/version.h

@@ -11,7 +11,7 @@ details. */
    changes to the DLL and is mainly informative in nature. */
 
 #define CYGWIN_VERSION_DLL_MAJOR 3005
-#define CYGWIN_VERSION_DLL_MINOR 5
+#define CYGWIN_VERSION_DLL_MINOR 6
 
 /* CYGWIN_VERSION_DLL_COMBINED gives us a single number representing the
    combined DLL major and minor numbers. */

winsup/cygwin/loadavg.cc

@@ -15,17 +15,23 @@
 
   A global load average estimate is maintained in shared memory.  Access to that
   is guarded by a mutex.  This estimate is only updated at most every 5 seconds.
+  The updates are done by any/all callers of the getloadavg() syscall.
 
-  We attempt to count running and runnable processes, but unlike linux we don't
-  count processes in uninterruptible sleep (blocked on I/O).
+  We attempt to count running and runnable tasks (i.e., threads), but unlike
+  Linux we don't count tasks in uninterruptible sleep (blocked on I/O).  There
+  doesn't seem to be a kernel counter for the latter on Windows.
 
-  The number of running processes is estimated as (NumberOfProcessors) * (%
-  Processor Time).  The number of runnable processes is estimated as
-  ProcessorQueueLength.
+  In the following text and code, "PDH" refers to Performance Data Helper, a
+  Windows component that arranges access to kernel counters.
+
+  The number of running tasks is estimated as
+    (the NumberOfProcessors counter) * (the % Processor Time counter).
+  The number of runnable tasks is taken to be the ProcessorQueueLength counter.
 
   Note that PDH will only return data for '% Processor Time' afer the second
   call to PdhCollectQueryData(), as it's computed over an interval, so the first
-  attempt to estimate load will fail and 0.0 will be returned.
+  attempt to estimate load will fail and 0.0 will be returned.  (This nuisance
+  is now worked-around near the end of load_init() below.)
 
   We also assume that '% Processor Time' averaged over the interval since the
   last time getloadavg() was called is a good approximation of the instantaneous
@@ -68,16 +74,27 @@ static bool load_init (void)
     if (status != STATUS_SUCCESS)
       {
 	debug_printf ("PdhAddEnglishCounterW(time), status %y", status);
-	return false;
+
+	/* Windows 10 Pro 21H1, and maybe others, use an alternative name */
+        status = PdhAddEnglishCounterW (query,
+                        L"\\Processor Information(_Total)\\% Processor Time",
+                        0, &counter1);
+        if (status != STATUS_SUCCESS)
+          {
+            debug_printf ("PdhAddEnglishCounterW(alt time), status %y", status);
+            return false;
+          }
       }
+
+    /* Windows 10 Pro 21H1, and maybe others, are missing this counter */
     status = PdhAddEnglishCounterW (query,
 				    L"\\System\\Processor Queue Length",
 				    0, &counter2);
 
     if (status != STATUS_SUCCESS)
       {
 	debug_printf ("PdhAddEnglishCounterW(queue length), status %y", status);
-	return false;
+	; /* Ignore missing counter, just use zero in later calculations */
       }
 
     mutex = CreateMutex(&sec_all_nih, FALSE, "cyg.loadavg.mutex");
@@ -87,6 +104,12 @@ static bool load_init (void)
     }
 
     initialized = true;
+
+    /* Do the first data collection (which always fails) here, rather than in
+       get_load(). We wait at least one tick afterward so the collection done
+       in get_load() is guaranteed to have data to work with. */
+    (void) PdhCollectQueryData (query); /* ignore errors */
+    Sleep (15/*ms*/); /* wait for at least one kernel tick to have occurred */
   }
 
   return initialized;
@@ -101,20 +124,19 @@ static bool get_load (double *load)
   if (ret != ERROR_SUCCESS)
     return false;
 
-  /* Estimate the number of running processes as (NumberOfProcessors) * (%
-     Processor Time) */
+  /* Estimate number of running tasks as
+     (NumberOfProcessors) * (% Processor Time) */
   PDH_FMT_COUNTERVALUE fmtvalue1;
   ret = PdhGetFormattedCounterValue (counter1, PDH_FMT_DOUBLE, NULL, &fmtvalue1);
   if (ret != ERROR_SUCCESS)
     return false;
 
   double running = fmtvalue1.doubleValue * wincap.cpu_count () / 100;
 
-  /* Estimate the number of runnable processes using ProcessorQueueLength */
-  PDH_FMT_COUNTERVALUE fmtvalue2;
+  /* Estimate the number of runnable tasks as ProcessorQueueLength */
+  PDH_FMT_COUNTERVALUE fmtvalue2 = { 0 };
   ret = PdhGetFormattedCounterValue (counter2, PDH_FMT_LONG, NULL, &fmtvalue2);
-  if (ret != ERROR_SUCCESS)
-    return false;
+  /* Ignore any error accessing this counter, just treat as if zero was read */
 
   LONG rql = fmtvalue2.longValue;
 

winsup/cygwin/local_includes/path.h

@@ -207,21 +207,33 @@ class path_conv
   {
     return (path_flags & (PATH_REP | PATH_REP_NOAPI)) == PATH_REP;
   }
-  int isdevice () const {return dev.not_device (FH_FS) && dev.not_device (FH_FIFO);}
+
   int isfifo () const {return dev.is_device (FH_FIFO);}
-  int isspecial () const {return dev.not_device (FH_FS);}
   int iscygdrive () const {return dev.is_device (FH_CYGDRIVE);}
-  int is_fs_special () const {return dev.is_fs_special ();}
-
-  int is_lnk_special () const {return (isdevice () && is_fs_special ()
-				       && !issocket ())
-      || isfifo () || is_lnk_symlink ();}
 #ifdef __WITH_AF_UNIX
   int issocket () const {return dev.is_device (FH_LOCAL)
 				|| dev.is_device (FH_UNIX);}
 #else
   int issocket () const {return dev.is_device (FH_LOCAL);}
 #endif /* __WITH_AF_UNIX */
+
+  /* FIXME: This needs a cleanup with better, descriptive names and checking
+     all usages for correctness. */
+
+  /* Any file or device with representation on disk.  This includes local
+     sockets, FIFOs, message queues and devices created with mknod.  It does
+     not include the /proc hierarchy. */
+  int isondisk () const {return dev.isfs ();}
+  /* Any device, virtual or with on-disk representation, and anything under
+     /proc. */
+  int isspecial () const {return dev.not_device (FH_FS);}
+  /* Devices with representation on disk. This includes local sockets, FIFOs,
+     message queues and devices created with mknod.  It does not include
+     the /proc hierarchy. */
+  int is_fs_special () const {return dev.is_fs_special ();}
+  /* Like is_fs_special but excluding local sockets. */
+  int is_lnk_special () const {return is_fs_special () && !issocket ();}
+
   int iscygexec () const {return mount_flags & MOUNT_CYGWIN_EXEC;}
   int isopen () const {return path_flags & PATH_OPEN;}
   int isctty_capable () const {return path_flags & PATH_CTTY;}

winsup/cygwin/path.cc

@@ -1241,7 +1241,10 @@ path_conv::check (const char *src, unsigned opt,
 
 	  /* FIXME: bad hack alert!!!  We need a better solution */
 	  if (!strncmp (path_copy, MQ_PATH, MQ_LEN) && path_copy[MQ_LEN])
-	    dev.parse (FH_MQUEUE);
+	    {
+	      dev.parse (FH_MQUEUE);
+	      dev.setfs (1);
+	    }
 	}
 
       if (opt & PC_NOFULL)
@@ -2153,8 +2156,7 @@ symlink_worker (const char *oldpath, path_conv &win32_newpath, bool isdevice)
       syscall_printf ("symlink (%s, %S) wsym_type %d", oldpath,
 		      win32_newpath.get_nt_native_path (), wsym_type);
 
-      if ((!isdevice && win32_newpath.exists ())
-	  || (win32_newpath.isdevice () && !win32_newpath.is_fs_special ()))
+      if (win32_newpath.exists() && (!isdevice || !win32_newpath.isondisk ()))
 	{
 	  set_errno (EEXIST);
 	  __leave;
@@ -2343,7 +2345,7 @@ symlink_worker (const char *oldpath, path_conv &win32_newpath, bool isdevice)
 		  set_errno (src_path.error);
 		  __leave;
 		}
-	      if (!src_path.isdevice () && !src_path.is_fs_special ())
+	      if (!src_path.isspecial ())
 	        {
 		  /* MSYS copy file instead make symlink */
 

winsup/cygwin/posix_ipc.cc

@@ -225,11 +225,14 @@ mq_getattr (mqd_t mqd, struct mq_attr *mqstat)
   int ret = -1;
 
   cygheap_fdget fd ((int) mqd, true);
-  fhandler_mqueue *fh = fd->is_mqueue ();
-  if (!fh)
-    set_errno (EBADF);
-  else
-    ret = fh->mq_getattr (mqstat);
+  if (fd >= 0)
+    {
+      fhandler_mqueue *fh = fd->is_mqueue ();
+      if (!fh)
+        set_errno (EBADF);
+      else
+        ret = fh->mq_getattr (mqstat);
+    }
   return ret;
 }
 
@@ -239,11 +242,14 @@ mq_setattr (mqd_t mqd, const struct mq_attr *mqstat, struct mq_attr *omqstat)
   int ret = -1;
 
   cygheap_fdget fd ((int) mqd, true);
-  fhandler_mqueue *fh = fd->is_mqueue ();
-  if (!fh)
-    set_errno (EBADF);
-  else
-    ret = fh->mq_setattr (mqstat, omqstat);
+  if (fd >= 0)
+    {
+      fhandler_mqueue *fh = fd->is_mqueue ();
+      if (!fh)
+        set_errno (EBADF);
+      else
+        ret = fh->mq_setattr (mqstat, omqstat);
+    }
   return ret;
 }
 
@@ -253,11 +259,14 @@ mq_notify (mqd_t mqd, const struct sigevent *notification)
   int ret = -1;
 
   cygheap_fdget fd ((int) mqd, true);
-  fhandler_mqueue *fh = fd->is_mqueue ();
-  if (!fh)
-    set_errno (EBADF);
-  else
-    ret = fh->mq_notify (notification);
+  if (fd >= 0)
+    {
+      fhandler_mqueue *fh = fd->is_mqueue ();
+      if (!fh)
+        set_errno (EBADF);
+      else
+        ret = fh->mq_notify (notification);
+    }
   return ret;
 }
 
@@ -268,11 +277,14 @@ mq_timedsend (mqd_t mqd, const char *ptr, size_t len, unsigned int prio,
   int ret = -1;
 
   cygheap_fdget fd ((int) mqd, true);
-  fhandler_mqueue *fh = fd->is_mqueue ();
-  if (!fh)
-    set_errno (EBADF);
-  else
-    ret = fh->mq_timedsend (ptr, len, prio, abstime);
+  if (fd >= 0)
+    {
+      fhandler_mqueue *fh = fd->is_mqueue ();
+      if (!fh)
+        set_errno (EBADF);
+      else
+        ret = fh->mq_timedsend (ptr, len, prio, abstime);
+    }
   return ret;
 }
 
@@ -289,11 +301,14 @@ mq_timedreceive (mqd_t mqd, char *ptr, size_t maxlen, unsigned int *priop,
   int ret = -1;
 
   cygheap_fdget fd ((int) mqd, true);
-  fhandler_mqueue *fh = fd->is_mqueue ();
-  if (!fh)
-    set_errno (EBADF);
-  else
-    ret = fh->mq_timedrecv (ptr, maxlen, priop, abstime);
+  if (fd >= 0)
+    {
+      fhandler_mqueue *fh = fd->is_mqueue ();
+      if (!fh)
+        set_errno (EBADF);
+      else
+        ret = fh->mq_timedrecv (ptr, maxlen, priop, abstime);
+    }
   return ret;
 }
 
@@ -309,14 +324,14 @@ mq_close (mqd_t mqd)
   __try
     {
       cygheap_fdget fd ((int) mqd, true);
-      if (!fd->is_mqueue ())
-	{
-	  set_errno (EBADF);
-	  __leave;
-	}
-
-      if (mq_notify (mqd, NULL))	/* unregister calling process */
-	__leave;
+      if (fd < 0 || !fd->is_mqueue ())
+        {
+          set_errno (EBADF);
+          __leave;
+        }
+
+      if (mq_notify (mqd, NULL))        /* unregister calling process */
+        __leave;
 
       fd->isclosed (true);
       fd->close ();

winsup/cygwin/release/3.5.6

@@ -0,0 +1,24 @@
+Fixes:
+------
+
+- Fix a regression in 3.5.5 when checking for execute permissions in
+  execve(2) and access(2).
+  Addresses: https://cygwin.com/pipermail/cygwin/2024-December/256972.html
+
+- Fix a regression since 3.5.0 which fails to use POSIX semantics in
+  unlink/rename on NTFS.
+
+- Add fd validation where needed in mq_* functions.
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-January/257090.html
+
+- Fix regression in 3.5.5 which causes process hangs.
+  Addresses: https://cygwin.com/pipermail/cygwin/2024-December/256954.html
+  Addresses: https://cygwin.com/pipermail/cygwin/2024-December/256971.html
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-January/257058.html
+  Addresses: https://cygwin.com/pipermail/cygwin/2024-December/256987.html
+
+- Minor updates to load average calculations.
+  Addresses: https://cygwin.com/pipermail/cygwin/2024-August/256361.html
+
+- Fix mq_unlink().
+  Addresses: https://cygwin.com/pipermail/cygwin/2025-January/257119.html

winsup/cygwin/sec/base.cc

@@ -603,25 +603,38 @@ check_access (security_descriptor &sd, GENERIC_MAPPING &mapping,
 int
 check_file_access (path_conv &pc, int flags, bool effective)
 {
-  int ret = -1;
   ACCESS_MASK desired = 0;
+  OBJECT_ATTRIBUTES attr;
+  IO_STATUS_BLOCK io;
+  NTSTATUS status;
+  HANDLE h = NULL;
+  ULONG opts = 0;
+  int ret = -1;
+
   if (flags & R_OK)
     desired |= FILE_READ_DATA;
   if (flags & W_OK)
     desired |= FILE_WRITE_DATA;
   if (flags & X_OK)
     desired |= FILE_EXECUTE;
 
+  /* For R_OK and W_OK we check with FILE_OPEN_FOR_BACKUP_INTENT since
+     we want to enable the full power of backup/restore privileges.
+     For X_OK, drop the FILE_OPEN_FOR_BACKUP_INTENT flag.  If the caller
+     holds SE_BACKUP_PRIVILEGE, FILE_OPEN_FOR_BACKUP_INTENT opens the file,
+     no matter what access is requested.
+     For directories, FILE_OPEN_FOR_BACKUP_INTENT flag is always required. */
+  if (!(flags & X_OK) || pc.isdir ())
+    opts = FILE_OPEN_FOR_BACKUP_INTENT;
+  else /* For a regular file to be executable, it must also be readable. */
+    desired |= FILE_READ_DATA;
+
   if (!effective)
     cygheap->user.deimpersonate ();
 
-  OBJECT_ATTRIBUTES attr;
   pc.init_reopen_attr (attr, pc.handle ());
-  NTSTATUS status;
-  IO_STATUS_BLOCK io;
-  HANDLE h;
-  status = NtOpenFile (&h, desired, &attr, &io, FILE_SHARE_VALID_FLAGS,
-		       FILE_OPEN_FOR_BACKUP_INTENT);
+
+  status = NtOpenFile (&h, desired, &attr, &io, FILE_SHARE_VALID_FLAGS, opts);
   if (NT_SUCCESS (status))
     {
       NtClose (h);