tile: fix copyright header blocks in just-committed files

I accidentally committed versions not following the conventions.
powerpc: remove linux lowlevellock.h

This patch remove the powerpc specific lowlevellock.h and adjust some
implementation that rely on __lll_[rel/acq]_instr defines.
Move some chown / lchown / fchown definitions to syscalls.list (bug 14138).

Continuing the move of syscall definitions to syscalls.list, where the
removal of support for old kernel versions has made this possible,
this patch moves various definitions of chown, lchown and fchown.

In most cases the need for special syscalls.list entries (rather than
existing generic ones) is because these architectures use chown32,
lchown32 and fchown32 as syscall names.  Some architectures also have
symbol versioning compatibility for older versions of chown having
been equivalent to lchown.

In the case of powerpc, chown.c (providing the chown@@GLIBC_2.1
default version) is replaced by a syscalls.list entry (for powerpc32;
powerpc64 has no need for this because of its more recent minimum
symbol version, so can just use the entry in
sysdeps/unix/syscalls.list), but lchown.S is left as-is because it
provides the compat version of chown as an actual alias for __lchown,
which is not yet supported by syscalls.list.  This file can be removed
once such aliases are supported in syscalls.list.

	[BZ #14138]
	* sysdeps/unix/sysv/linux/arm/fchown.c: Remove file.
	* sysdeps/unix/sysv/linux/arm/lchown.c: Likewise.
	* sysdeps/unix/sysv/linux/m68k/fchown.c: Likewise.
	* sysdeps/unix/sysv/linux/m68k/lchown.c: Likewise.
	* sysdeps/unix/sysv/linux/powerpc/chown.c: Likewise.
	* sysdeps/unix/sysv/linux/arm/syscalls.list (lchown): Add syscall.
	(fchown): Likewise.
	* sysdeps/unix/sysv/linux/m68k/syscalls.list (lchown): Likewise.
	(fchown): Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/syscalls.list (chown):
	Likewise.
Support and use mixed compat/non-compat aliases in syscalls.list.

This patch enables syscalls.list entries to specify both compat and
non-compat symbol versions for the same syscall definition, making use
of this for setrlimit / chown / lchown where the inability to specify
such aliases showed up in the course of work on bug 14138.

The change to make-syscalls.sh is minimal: adding a SHARED conditional
on the compat_symbol calls.  It remains the case that if a compat
symbol version is specified, the syscall is only built for the shared
library at all if an explicit symbol version is given for a non-compat
symbol (so it's necessary to specify "lchown@@GLIBC_2.0
chown@GLIBC_2.0" rather than just "lchown chown@GLIBC_2.0").  It also
remains the case, as already commented in make-syscalls.sh, that no
SHLIB_COMPAT conditionals are generated, so there would be problems if
the same syscalls.list file, with compat symbols, were used for both
configurations that should have those symbols and configurations for
which they should be conditioned out with SHLIB_COMPAT.

Tested for x86.

	* sysdeps/unix/make-syscalls.sh (emit_weak_aliases): Condition
	compat_symbol calls on [SHARED].
	* sysdeps/unix/sysv/linux/powerpc/lchown.S: Remove file.
	* sysdeps/unix/sysv/linux/i386/syscalls.list (oldsetrlimit):
	Remove.
	(setrlimit): Add setrlimit@GLIBC_2.0 alias.
	* sysdeps/unix/sysv/linux/m68k/m680x0/syscalls.list
	(oldsetrlimit): Remove.
	(setrlimit): Add setrlimit@GLIBC_2.0 alias.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/syscalls.list
	(lchown): New syscall entry.
	(oldsetrlimit): Remove.
	(setrlimit): Add setrlimit@GLIBC_2.0 alias.
	* sysdeps/unix/sysv/linux/s390/s390-32/syscalls.list
	(oldsetrlimit): Remove.
	(setrlimit): Add setrlimit@GLIBC_2.0 alias.
Use inline syscalls for non-cancellable versions

This patch uses inline calls (through INLINE_SYSCALL macro) to define
the non-cancellable functions macros to avoid use of the
syscall_nocancel entrypoint.
Function declaration cleanup

This patch changes the some function declaration from K&R style to
default ANSI C.
nptl: Fix testcases for new pthread cancellation mechanism

With upcoming fix for BZ#12683, pthread cancellation does not act for:

1. If syscall is blocked but with some side effects already having taken
   place (e.g. a partial read or write)
2. After the syscall has returned.

It is because program need to act on such cases (for instance, to avoid
leak of allocated resources our handling partial read/write).

This patches fixes the NPTL testcase that assumes the old behavior and
also remove the tst-cancel-wrappers.sh test (which checks for symbols
that does not exist anymore).
nptl: x86_64: remove assembly implementation

This patch removes the x86_64 assembly implementation for
pthread_cond_timedwait, pthread_cond_wait, sem_timedwait, and sem_wait
for upcoming BZ#12683 fix.  The fix require that cancellable futex calls
to be called through __syscall_cancel.

Although it not strictly require, the remove of the x86_64 specific
implementation follows the rationale:

1. The adjustments required to this fix is extensive (parameters
   save, functions calls, etc.) and there is little gain in keep an
   alternate implementation for x86_64 in term of maintanability.
2. There is no pthread_cond benchmark that shows these implementations
   are more 'optimized' that what current compilers can produce using
   generic C code.
3. The changes required also can change the exact gains this optimized is
   intended to provide.
Rewrite cancellation macros

This patch changes the way cancellation entrypoints are defined to
instead call the macro SYSCALL_CANCEL.  An usual cnacellation definition
is defined as:

  if (SINGLE_THREAD_P)
    return INLINE_SYSCALL (syscall, NARGS, args...)

  int oldtype = LIBC_CANCEL_ASYNC ();

  return INLINE_SYSCALL (syscall, NARGS, args...)

  LIBC_CANCEL_RESET (oldtype);

And it is rewrited as just:

  SYSCALL_CANCEL (syscall, args...)

The idea is to remove LIBC_CANCEL_ASYNC/LIBC_CANCEL_RESET explicit
usage.
nptl: Fix Race conditions in pthread cancellation

This patches fixes some race conditions in NPTL cancellation code by
redefining how cancellable syscalls are defined and handled.  Current
approach is to enable asynchronous cancellation prior to making the syscall
and restore the previous cancellation type once the syscall returns.

As decribed in BZ#12683, this approach shows 2 important problems:

1. Cancellation can act after the syscall has returned from kernel, but
   before userspace saves the return value.  It might result in a resource
   leak if the syscall allocated a resource or a side effect (partial
   read/write), and there is no way to program handle it with cancellation
   handlers.

2. If a signal is handled while the thread is blocked at a cancellable
   syscall, the entire signal handler runs with asynchronous cancellation
   enabled.  This can lead to issues if the signal handler call functions
   which are async-signal-safe but not async-cancel-safe.

For cancellation to work correctly, there are 5 points at which the
cancellation signal could arrive:

1. Before the final testcancel before the syscall is made.
2. Between the testcancel and the syscall.
3. While the syscall is blocked and no side effects have yet taken place.
4. While the syscall is blocked but with some side effects already having
   taken place (e.g. a partial read or write).
5. After the syscall has returned.

And GLIBC wants to act on cancellation in cases 1, 2, and 3 but not in case
4 or 5.  The proposed solution follows:

* Handling case 1 is trivial: do a conditional branch based on whether the
  thread has received a cancellation request;
* Case 2 can be caught by the signal handler determining that the saved
  program counter (from the ucontext_t) is in some address range beginning
  just before the "testcancel" and ending with the syscall instruction.
* In this case, except for certain syscalls that ALWAYS fail with EINTR
  even for non-interrupting signals, the kernel will reset the program
  counter to point at the syscall instruction during signal handling, so
  that the syscall is restarted when the signal handler returns. So, from
  the signal handler's standpoint, this looks the same as case 2, and thus
  it's taken care of.
* In this case, the kernel cannot restart the syscall; when it's
  interrupted by a signal, the kernel must cause the syscall to return
  with whatever partial result it obtained (e.g. partial read or write).
* In this case, the saved program counter points just after the syscall
  instruction, so the signal handler won't act on cancellation.
  This one is equal to 4. since the program counter is past the syscall
  instruction already.

Another case that needs handling is syscalls that fail with EINTR even
when the signal handler is non-interrupting. In this case, the syscall
wrapper code can just check the cancellation flag when the errno result
is EINTR, and act on cancellation if it's set.

The proposed GLIBC adjustments are:

1. Remove the enable_asynccancel/disable_asynccancel function usage in
   syscall definition and instead make them call a common symbol that will
   check if cancellation is enabled, call the arch-specific cancellable
   entry-point and cancel the thread when required.
2. Provide a arch-specific symbol that contains global markers. These
   markers will be used in SIGCANCEL handler to check if the interruption
   has been called in a valid syscall and if the syscalls has been
   completed or not.
3. Rewrite SIGCANCEL asynchronous handler to check for both cancelling type
   and if current IP from signal handler falls between the global markes
   and act accordingly.
4. Adjust nptl/pthread_cancel.c to send an signal instead of acting
   directly. This avoid synchronization issues about updating the
   cancellation status and also focus the logic on signal handler and
   cancellation syscall code.
5. Adjust pthread code to replace CANCEL_ASYNC/CANCEL_RESET calls to
   appropriated cancelable futex syscalls.
6. Adjust libc code to replace LIBC_CANCEL_ASYNC/LIBC_CANCEL_RESET to
   appropriated cancelable syscalls.
7. Adjust 'lowlevellock.h' arch-specific implementations to provide
   cancelable futex calls (used in libpthread code).

This patch adds the proposed changes to NPTL and the changes required
for powerpc64.
nptl: x86_64: Fix Race conditions in pthread cancellation (BZ#12683)

This patches adds the x86_64 modification required for the BZ#12683 fix.
It basically removes the enable_asynccancel/disable_asynccancel function
usage on code used on x86_64, provide a arch-specific symbol that
contains global markers to be used in SIGCANCEL handler, and remove
x86_64 assembly pthread conditional and semaphore code to use default
one (that already contains the cancel call fixes).
nptl: ppc32: Fix Race conditions in pthread cancellation (BZ#12683)

This patches adds the ppc32 modification required for the BZ#12683
fix.  It basically removes the enable_asynccancel/disable_asynccancel
function usage on code used on ppc32.