No, xe does not.

The subsystem that was made just to claim POSIX compatibility was the subsystem that preceded Interix. Interix was developed outwith Microsoft, and replaced the old POSIX subsystem. It was Windows NT's second POSIX subsystem, and it very much is not just a sop for the sake of checking a requirements checkbox.

It's a fairly usable POSIX environment, with a large toolset, proper terminal emulations, pseudo-terminals, interoperability with non-POSIX processes including visibility with (an enhanced) ps and the ability to send signals to Win32 processes, an actual init and inetd, and an X server.

Stephen Walli has stated that it started as a fork of 4.4BSD-Lite.

* https://news.ycombinator.com/item?id=11560510

* https://news.ycombinator.com/item?id=11416392

yes, an Arch port to WSL was written

Whether I have to do porting work in practice (which I do, a lot) matters a lot more than what a consortium from 1996 says.

The fact is, Darwin gives me trouble a lot more than Linux does when using POSIX APIs. If there were a comprehensive, up to date POSIX test suite, Darwin would fail it.

  IMPLEMENTATION NOTES
    The pselect() function is implemented in the C library as a wrapper
    around select().

That means it's not actually compliant. pselect needs to _atomically_ unblock signals so that if any signal handlers are invoked pselect returns EINTR error. User code can't emulate the correct semantics because there's a race between unblocking (i.e. changing the signal mask), checking for signal arrival, and calling select. It's _impossible_ to fix this race without resort to pselect, or by use of system extensions like kqueue on BSD/macOS[1] or signalfd on Linux, which can be tricky. On Solaris you just have to use pselect, or resort to the so-called "pipe trick".

So the fact that pselect is a wrapper around select admits that it's not conformant. It's basically useless; worse, it's dangerous because application code calling pselect expecting there won't be a race.

You can see the race with this code, which on 10.10.5 still fails. What should happen is that it exits immediately with OK. What actually happens on macOS is that its pselect wrapper unblocks the signal, which is immediately delivered. But by then we've already checked that interrupted was still 0. It then calls select, which will timeout because it won't be interrupted--the signal was already delivered. On every other platform implementing pselect (which all do it correctly), pselect will always return EINTR because the signal unmasking and delivery happens in the kernel _after_ entering select.

  #include <errno.h>
  #include <signal.h>
  #include <stdio.h>
  #include <sys/select.h>
  #include <unistd.h>
  #include <err.h>
  
  static int interrupted;
  
  static void
  interrupt(int signo)
  {
    interrupted = signo;
  }
  
  int
  main(void)
  {
    struct timespec timeout = { 3, 0 };
    sigset_t empty, block;
    int n;
  
    sigemptyset(&empty);
    sigemptyset(&block);
  
    sigaddset(&block, SIGHUP);
    sigprocmask(SIG_BLOCK, &block, NULL);
  
    signal(SIGHUP, &interrupt);
    raise(SIGHUP);
  
    while (!interrupted) {
      /*
       * If pselect does not atomically unblock signals, pselect
       * will never be interrupted and we'll lose the signal until
       * something else wakes us up AND we remember to check even
       * though we never saw EINTR.
       */
      n = pselect(0, NULL, NULL, NULL, &timeout, &empty);
      if (n == -1 && errno != EINTR) {
        err(1, "pselect");
      } else if (n == 0) {
        errx(1, "timed out");
      }
    }
  
    if (interrupted != SIGHUP)
      errx(1, "wrong signal (got %d, expected %d)",
          interrupted, SIGHUP);
  
    puts("OK");
    
    return 0;  
  }

[1] FWIW, here's a correct implementation of pselect for macOS using kqueue. (https://github.com/wahern/cqueues/blob/snap-20160812/src/cqu...) The only caveat is that creating a kqueue descriptor might fail, and you don't normally expect pselect to fail with EMFILE or ENFILE; it might even make it non-compliant. Except for that caveat, it's a compliant implementation of pselect AFAICT.

See my reply to RJIb8RBYxzAMX9u, elsethread. It's misleading. The interface conforms, but the implementation is not compliant At least for all the version of macOS I've tested (I haven't tested 10.12, yet) the very problem pselect was created to address exists. When I said that the manual page admits it's non-compliant, I was referring to the section that said pselect was implemented as a wrapper around select; but you can't correctly implement pselect as a simple wrapper around select.

But see my link in the other reply to a correct implementation I wrote that relies on kqueue. I even submitted it to Apple years ago along with the bug report.