1. 11 9月, 2014 1 次提交
    • R
      fix places where _BSD_SOURCE failed to yield a superset of _XOPEN_SOURCE · ab8f6a6e
      Rich Felker 提交于
      the vast majority of these failures seem to have been oversights at
      the time _BSD_SOURCE was added, or perhaps shortly afterward. the one
      which may have had some reason behind it is omission of setpgrp from
      the _BSD_SOURCE feature profile, since the standard setpgrp interface
      conflicts with a legacy (pre-POSIX) BSD interface by the same name.
      however, such omission is not aligned with our general policy in this
      area (for example, handling of similar _GNU_SOURCE cases) and should
      not be preserved.
      ab8f6a6e
  2. 08 9月, 2014 3 次提交
    • S
      fix exp10l.c to include float.h · e6403887
      Szabolcs Nagy 提交于
      the previous commit was a no op in exp10l because LDBL_* macros
      were implicitly 0 (the preprocessor does not warn about undefined
      symbols).
      e6403887
    • S
      prune math code on archs with binary64 long double · 0c32c263
      Szabolcs Nagy 提交于
      __polevll, __p1evll and exp10l were provided on archs when long double
      is the same as double. The first two were completely unused and exp10l
      can be a wrapper around exp10.
      0c32c263
    • S
      add new F_OFD_* macros to fcntl.h (open file description locks) · 976bb28f
      Szabolcs Nagy 提交于
      open file description locks are inherited across fork and only auto
      dropped after the last fd of the file description is closed, they can be
      used to synchronize between threads that open separate file descriptions
      for the same file.
      
      new in linux 3.15 commit 0d3f7a2dd2f5cf9642982515e020c1aee2cf7af6
      976bb28f
  3. 07 9月, 2014 7 次提交
    • R
      add C11 thread creation and related thread functions · 23614b0f
      Rich Felker 提交于
      based on patch by Jens Gustedt.
      
      the main difficulty here is handling the difference between start
      function signatures and thread return types for C11 threads versus
      POSIX threads. pointers to void are assumed to be able to represent
      faithfully all values of int. the function pointer for the thread
      start function is cast to an incorrect type for passing through
      pthread_create, but is cast back to its correct type before calling so
      that the behavior of the call is well-defined.
      
      changes to the existing threads implementation were kept minimal to
      reduce the risk of regressions, and duplication of code that carries
      implementation-specific assumptions was avoided for ease and safety of
      future maintenance.
      23614b0f
    • J
      add C11 condition variable functions · 14397cec
      Jens Gustedt 提交于
      Because of the clear separation for private pthread_cond_t these
      interfaces are quite simple and direct.
      14397cec
    • J
      add C11 mutex functions · 8b047293
      Jens Gustedt 提交于
      8b047293
    • J
      add C11 thread functions operating on tss_t and once_flag · e16f70f4
      Jens Gustedt 提交于
      These all have POSIX equivalents, but aside from tss_get, they all
      have minor changes to the signature or return value and thus need to
      exist as separate functions.
      e16f70f4
    • R
      add threads.h and needed per-arch types for mtx_t and cnd_t · b7cf71a1
      Rich Felker 提交于
      based on patch by Jens Gustedt.
      
      mtx_t and cnd_t are defined in such a way that they are formally
      "compatible types" with pthread_mutex_t and pthread_cond_t,
      respectively, when accessed from a different translation unit. this
      makes it possible to implement the C11 functions using the pthread
      functions (which will dereference them with the pthread types) without
      having to use the same types, which would necessitate either namespace
      violations (exposing pthread type names in threads.h) or incompatible
      changes to the C++ name mangling ABI for the pthread types.
      
      for the rest of the types, things are much simpler; using identical
      types is possible without any namespace considerations.
      b7cf71a1
    • J
      use weak symbols for the POSIX functions that will be used by C threads · df7d0dfb
      Jens Gustedt 提交于
      The intent of this is to avoid name space pollution of the C threads
      implementation.
      
      This has two sides to it. First we have to provide symbols that wouldn't
      pollute the name space for the C threads implementation. Second we have
      to clean up some internal uses of POSIX functions such that they don't
      implicitly drag in such symbols.
      df7d0dfb
    • R
      add C11 timespec_get function, with associated time.h changes for C11 · 6eb19505
      Rich Felker 提交于
      based on patch by Jens Gustedt for inclusion with C11 threads
      implementation, but committed separately since it's independent of
      threads.
      6eb19505
  4. 06 9月, 2014 7 次提交
  5. 05 9月, 2014 6 次提交
    • R
      fix case mapping for U+00DF (ß) · 4674809b
      Rich Felker 提交于
      U+00DF ('ß') has had an uppercase form (U+1E9E) available since
      Unicode 5.1, but Unicode lacks the case mappings for it due to
      stability policy. when I added support for the new character in commit
      1a63a9fc, I omitted the mapping in the
      lowercase-to-uppercase direction. this choice was not based on any
      actual information, only assumptions.
      
      this commit adds bidirectional case mappings between U+00DF and
      U+1E9E, and removes the special-case hack that allowed U+00DF to be
      identified as lowecase despite lacking a mapping. aside from strong
      evidence that this is the "right" behavior for real-world usage of
      these characters, several factors informed this decision:
      
      - the other "potentially correct" mapping, to "SS", is not
        representable in the C case-mapping system anyway.
      
      - leaving one letter in lowercase form when transforming a string to
        uppercase is obviously wrong.
      
      - having a character which is nominally lowercase but which is fixed
        under case mapping violates reasonable invariants.
      4674809b
    • R
      make non-waiting paths of sem_[timed]wait and pthread_join cancelable · fff54693
      Rich Felker 提交于
      per POSIX these functions are both cancellation points, so they must
      act on any cancellation request which is pending prior to the call.
      previously, only the code path where actual waiting took place could
      act on cancellation.
      fff54693
    • R
      remove an extra layer of buffer copying in getnameinfo reverse dns · 80e64854
      Rich Felker 提交于
      the outer getnameinfo function already has a properly-sized temporary
      buffer for storing the reverse dns (ptr) result. there is no reason
      for the callback to use a secondary buffer and copy it on success, and
      doing so potentially expanded the impact of the dn_expand bug that was
      fixed in commit 49d2c8c6.
      
      this change reduces the code size by a small amount, and also reduces
      the run-time stack space requirements by about 256 bytes.
      80e64854
    • R
      fix multiple stdio functions' behavior on zero-length operations · 6e2bb7ac
      Rich Felker 提交于
      previously, fgets, fputs, fread, and fwrite completely omitted locking
      and access to the FILE object when their arguments yielded a zero
      length read or write operation independent of the FILE state. this
      optimization was invalid; it wrongly skipped marking the stream as
      byte-oriented (a C conformance bug) and exposed observably missing
      synchronization (a POSIX conformance bug) where one of these functions
      could wrongly complete despite another thread provably holding the
      lock.
      6e2bb7ac
    • R
      suppress null termination when fgets reads EOF with no data · 402611c3
      Rich Felker 提交于
      the C standard requires that "the contents of the array remain
      unchanged" in this case.
      
      this patch also changes the behavior on read errors, but in that case
      "the array contents are indeterminate", so the application cannot
      inspect them anyway.
      402611c3
    • S
      fix dn_expand empty name handling and offsets to 0 · 49d2c8c6
      Szabolcs Nagy 提交于
      Empty name was rejected in dn_expand since commit
      56b57f37
      which is a regression as reported by Natanael Copa.
      
      Furthermore if an offset pointer in a compressed name
      pointed to a terminating 0 byte (instead of a label)
      the returned name was not null terminated.
      49d2c8c6
  6. 27 8月, 2014 2 次提交
  7. 26 8月, 2014 7 次提交
    • R
      add malloc_usable_size function and non-stub malloc.h · 8d998a7b
      Rich Felker 提交于
      this function is needed for some important practical applications of
      ABI compatibility, and may be useful for supporting some non-portable
      software at the source level too.
      
      I was hesitant to add a function which imposes any constraints on
      malloc internals; however, it turns out that any malloc implementation
      which has realloc must already have an efficient way to determine the
      size of existing allocations, so no additional constraint is imposed.
      
      for now, some internal malloc definitions are duplicated in the new
      source file. if/when malloc is refactored to put them in a shared
      internal header file, these could be removed.
      
      since malloc_usable_size is conventionally declared in malloc.h, the
      empty stub version of this file was no longer suitable. it's updated
      to provide the standard allocator functions, nonstandard ones (even if
      stdlib.h would not expose them based on the feature test macros in
      effect), and any malloc-extension functions provided (currently, only
      malloc_usable_size).
      8d998a7b
    • R
      refrain from spinning on locks when there is already a waiter · f5fb20b0
      Rich Felker 提交于
      if there is already a waiter for a lock, spinning on the lock is
      essentially an attempt to steal it from whichever waiter would obtain
      it via any priority rules in place, and is therefore undesirable. in
      the current implementation, there is always an inherent race window at
      unlock during which a newly-arriving thread may steal the lock from
      the existing waiters, but we should aim to keep this window minimal
      rather than enlarging it.
      f5fb20b0
    • R
      97a7512b
    • R
      spin in sem_[timed]wait before performing futex wait · 2ff714c6
      Rich Felker 提交于
      empirically, this increases the maximum rate of wait/post operations
      between two threads by 20-150 times on machines I tested, including
      x86 and arm. conceptually, it makes sense to do some spinning because
      semaphores are intended to be usable as a notification mechanism
      between threads, not just as locks, and low-latency notification is a
      valuable property to have.
      2ff714c6
    • R
      fix build error on arm due to new a_spin code · 8b3d7d0d
      Rich Felker 提交于
      this was broken by commit ea818ea8.
      8b3d7d0d
    • R
      sanitize number of spins in userspace before futex wait · b8a9c90e
      Rich Felker 提交于
      the previous spin limit of 10000 was utterly unreasonable.
      empirically, it could consume up to 200000 cycles, whereas a failed
      futex wait (EAGAIN) typically takes 1000 cycles or less, and even a
      true wait/wake round seems much less expensive.
      
      the new counts (100 for general wait, 200 in barrier) were simply
      chosen to be in the range of what's reasonable without having adverse
      effects on casual micro-benchmark tests I have been running. they may
      still be too high, from a standpoint of not wasting cpu cycles, but at
      least they're a lot better than before. rigorous testing across
      different archs and cpu models should be performed at some point to
      determine whether further adjustments should be made.
      b8a9c90e
    • R
      add working a_spin() atomic for non-x86 targets · ea818ea8
      Rich Felker 提交于
      conceptually, a_spin needs to be at least a compiler barrier, so the
      compiler will not optimize out loops (and the load on each iteration)
      while spinning. it should also be a memory barrier, or the spinning
      thread might keep spinning without noticing stores from other threads,
      thus delaying for longer than it should.
      
      ideally, an optimal a_spin implementation that avoids unnecessary
      cache/memory contention should be chosen for each arch, but for now,
      the easiest thing is to perform a useless a_cas on the calling
      thread's stack.
      ea818ea8
  8. 24 8月, 2014 1 次提交
    • R
      fix false ownership of stdio FILEs due to tid reuse · 5345c9b8
      Rich Felker 提交于
      this is analogous commit fffc5cda
      which fixed the corresponding issue for mutexes.
      
      the robust list can't be used here because the locks do not share a
      common layout with mutexes. at some point it may make sense to simply
      incorporate a mutex object into the FILE structure and use it, but
      that would be a much more invasive change, and it doesn't mesh well
      with the current design that uses a simpler code path for internal
      locking and pulls in the recursive-mutex-like code when the flockfile
      API is used explicitly.
      5345c9b8
  9. 23 8月, 2014 2 次提交
    • R
      fix fallback checks for kernels without private futex support · b8ca9eb5
      Rich Felker 提交于
      for unknown syscall commands, the kernel produces ENOSYS, not EINVAL.
      b8ca9eb5
    • R
      fix use of uninitialized memory with application-provided thread stacks · a6293285
      Rich Felker 提交于
      the subsequent code in pthread_create and the code which copies TLS
      initialization images to the new thread's TLS space assume that the
      memory provided to them is zero-initialized, which is true when it's
      obtained by pthread_create using mmap. however, when the caller
      provides a stack using pthread_attr_setstack, pthread_create cannot
      make any assumptions about the contents. simply zero-filling the
      relevant memory in this case is the simplest and safest fix.
      a6293285
  10. 21 8月, 2014 1 次提交
    • R
      add max_align_t definition for C11 and C++11 · 321f4fa9
      Rich Felker 提交于
      unfortunately this needs to be able to vary by arch, because of a huge
      mess GCC made: the GCC definition, which became the ABI, depends on
      quirks in GCC's definition of __alignof__, which does not match the
      formal alignment of the type.
      
      GCC's __alignof__ unexpectedly exposes the an implementation detail,
      its "preferred alignment" for the type, rather than the formal/ABI
      alignment of the type, which it only actually uses in structures. on
      most archs the two values are the same, but on some (at least i386)
      the preferred alignment is greater than the ABI alignment.
      
      I considered using _Alignas(8) unconditionally, but on at least one
      arch (or1k), the alignment of max_align_t with GCC's definition is
      only 4 (even the "preferred alignment" for these types is only 4).
      321f4fa9
  11. 19 8月, 2014 1 次提交
    • R
      further simplify and optimize new cond var · 4992ace9
      Rich Felker 提交于
      the main idea of the changes made is to have waiters wait directly on
      the "barrier" lock that was used to prevent them from making forward
      progress too early rather than first waiting on the atomic state value
      and then attempting to lock the barrier.
      
      in addition, adjustments to the mutex waiter count are optimized.
      previously, each waking waiter decremented the count (unless it was
      the first) then immediately incremented it again for the next waiter
      (unless it was the last). this was a roundabout was of achieving the
      equivalent of incrementing it once for the first waiter and
      decrementing it once for the last.
      4992ace9
  12. 18 8月, 2014 2 次提交
    • R
      simplify and improve new cond var implementation · 2c4b510b
      Rich Felker 提交于
      previously, wake order could be unpredictable: if a waiter happened to
      leave its futex wait on the state early, e.g. due to EAGAIN while
      restarting after a signal handler, it could acquire the mutex out of
      turn. handling this required ugly O(n) list walking in the unwait
      function and accounting to remove waiters that already woke from the
      list.
      
      with the new changes, the "barrier" locks in each waiter node are only
      unlocked in turn. in addition to simplifying the code, this seems to
      improve performance slightly, probably by reducing the number of
      accesses threads make to each other's stacks.
      
      as an additional benefit, unrecoverable mutex re-locking errors
      (mainly ENOTRECOVERABLE for robust mutexes) no longer need to be
      handled with deadlock; they can be reported to the caller, since the
      unlocking sequence makes it unnecessary to rely on the mutex to
      synchronize access to the waiter list.
      2c4b510b
    • R
      redesign cond var implementation to fix multiple issues · 37195db8
      Rich Felker 提交于
      the immediate issue that was reported by Jens Gustedt and needed to be
      fixed was corruption of the cv/mutex waiter states when switching to
      using a new mutex with the cv after all waiters were unblocked but
      before they finished returning from the wait function.
      
      self-synchronized destruction was also handled poorly and may have had
      race conditions. and the use of sequence numbers for waking waiters
      admitted a theoretical missed-wakeup if the sequence number wrapped
      through the full 32-bit space.
      
      the new implementation is largely documented in the comments in the
      source. the basic principle is to use linked lists initially attached
      to the cv object, but detachable on signal/broadcast, made up of nodes
      residing in automatic storage (stack) on the threads that are waiting.
      this eliminates the need for waiters to access the cv object after
      they are signaled, and allows us to limit wakeup to one waiter at a
      time during broadcasts even when futex requeue cannot be used.
      
      performance is also greatly improved, roughly double some tests.
      
      basically nothing is changed in the process-shared cond var case,
      where this implementation does not work, since processes do not have
      access to one another's local storage.
      37195db8