pthread.

According to musl's source, the `ioctl` [function
signature][musl-ioctl-h] takes an `int` as the request argument (i.e. an
`i32`) which is reflected in this crate's [ioctl
binding][musl-ioctl-rs]. It looks like when the ioctl constants were
added that [glibc's default][glibc-ioctl-h] of a `c_ulong` type was used
for the musl values as well, rather than a `c_int` type. This change
updates these constants to a `c_int` so that they match the expected
function call type.

Here is a minimal reproduction of the issue. Given this Rust program:

```rust
extern crate libc;

use libc::{ioctl, winsize, STDOUT_FILENO, TIOCGWINSZ};

fn main() {
    let mut wsize = winsize {
        ws_row: 0,
        ws_col: 0,
        ws_xpixel: 0,
        ws_ypixel: 0,
    };
    unsafe {
        ioctl(STDOUT_FILENO, TIOCGWINSZ, &mut wsize);
    }
    println!("Sizes: {{ rows: {}, cols: {}, xpixel: {}, ypixel: {} }}",
             wsize.ws_row,
             wsize.ws_col,
             wsize.ws_xpixel,
             wsize.ws_ypixel);
}
```

When run against the `x86_64-unknwon-linux-gnu` and
`x86_64-unknown-linux-musl` targets, we see the difference in behavior:

```
> cargo clean

> cargo run --target=x86_64-unknown-linux-gnu
   Compiling libc v0.2.11
   Compiling libc-musl-ioctl v0.1.0 (file:///src/libc-musl-ioctl)
     Running `target/x86_64-unknown-linux-gnu/debug/libc-musl-ioctl`
Sizes: { rows: 28, cols: 211, xpixel: 0, ypixel: 0 }

> cargo clean

> cargo run --target=x86_64-unknown-linux-musl
   Compiling libc v0.2.11
   Compiling libc-musl-ioctl v0.1.0 (file:///src/libc-musl-ioctl)
src/main.rs:13:30: 13:40 error: mismatched types:
 expected `i32`,
    found `u64` [E0308]
src/main.rs:13         ioctl(STDOUT_FILENO, TIOCGWINSZ, &mut wsize);
                                            ^~~~~~~~~~
src/main.rs:13:30: 13:40 help: run `rustc --explain E0308` to see a detailed explanation
error: aborting due to previous error
Could not compile `libc-musl-ioctl`.

To learn more, run the command again with --verbose.
```

Working against this fix:

```
> cargo clean

> cargo run --target=x86_64-unknown-linux-gnu
    Updating git repository `https://github.com/fnichol/rust-lang-libc.git`
   Compiling libc v0.2.11 (https://github.com/fnichol/rust-lang-libc.git?branch=fix-musl-ioctl-constants#3285f387)
   Compiling libc-musl-ioctl v0.1.0 (file:///src/libc-musl-ioctl)
     Running `target/x86_64-unknown-linux-gnu/debug/libc-musl-ioctl`
Sizes: { rows: 28, cols: 211, xpixel: 0, ypixel: 0 }

> cargo clean

> cargo run --target=x86_64-unknown-linux-musl
   Compiling libc v0.2.11 (https://github.com/fnichol/rust-lang-libc.git?branch=fix-musl-ioctl-constants#3285f387)
   Compiling libc-musl-ioctl v0.1.0 (file:///src/libc-musl-ioctl)
     Running `target/x86_64-unknown-linux-musl/debug/libc-musl-ioctl`
Sizes: { rows: 28, cols: 211, xpixel: 0, ypixel: 0 }
```

[musl-ioctl-rs]:
https://doc.rust-lang.org/libc/x86_64-unknown-linux-musl/libc/fn.ioctl.html

[musl-ioctl-h]:
https://git.musl-libc.org/cgit/musl/tree/include/sys/ioctl.h

[glibc-ioctl-h]:
http://bazaar.launchpad.net/~vcs-imports/glibc/master/view/head:/include/sys/ioctl.h

Sadly Android's bionic lacks this functionality.

Adding program_invocation_short_name for Linux (Musl and glibc).

Adding __progname for Android. This is a little different, but
is a safer alternative to using argv[0], which may not exist, and
includes Android's default application name (currently '<unknown>').

Adding these functions and externs means it is possible for all
but Windows applications to safely discover their
name, rather than rely on argv[0] parsing, /proc/self/exe, etc.

This is the maximum size of guaranteed-atomic writes to a pipe.

This is because Android bionic doesn't support `LOG_NFEATURES`.

Removed CODE, as its definition and name varies too wildy and I
have no current code using it to test permutations with.

Moved LOG_NFACILITIES down, as Mac OS X defines this value
differently.

Added Mac OS X specific LOG_* facilities.

Added FreeBSD / DragonFly BSD specific LOG_* facilities.

Moved LOG_PERROR down, as all platforms bar Solaris define this.

Moved LOG_CRON down, as Solaris defines this with a different value.

Moved LOG_AUTHPRIV and LOG_FTP down, as all platforms bar Solaris
define these.

Looks like Solaris is suffering from the bit rot of commercial Unix...

As with `getrlimit` and `setrlimit`, the glibc wrappers have a non-`int`
for the `resource` argument, eg:

    extern int prlimit (__pid_t __pid, enum __rlimit_resource __resource,
                        const struct rlimit *__new_limit,
                        struct rlimit *__old_limit) __THROW;

A bunch of definitions were duplicated across, eg, android and linux.
This commit pulls these up to higher levels where they can be shared.

These targets will be similar to the x86_64-unknown-linux-musl
target, in that they'll use MUSL libc to allow fully static binaries
to be generated. To remain consistent with the naming of existing
ARM targets, as well as with the standard naming of MUSL toolchains,
we'll use `musleabi` and `musleabihf` as the target environment
names (analogous to `gnueabi` and `gnueabihf`).

Most of these changes just extend the special casing for x86_64 MUSL
targets to the ARM ones as well.

Signed-off-by: NODA, Kai <nodakai@gmail.com>

There are many constants defined by langinfo, but we have the
new types, locale_t and nl_item.

We also have several functions, not all of which exist for every
platform:

nl_langinfo
nl_langinfo_l
newlocale
duplocale
freelocale
uselocale
querylocale

Signed-off-by: NODA, Kai <nodakai@gmail.com>

The functions were added for Apple in #202. Adding them to other
platforms was pending an amendment to RFC 1291 to expand the scope of
libc to include libutil. The amendment was merged as
  https://github.com/rust-lang/rfcs/pull/1529

Linux-likes have more locale categories than the BSDs (except for
musl). We define the common set of categories at the
src/unix/notbsd/mod.rs level, and leave the rest to the
platform-specific modules.

We have lconv struct, setlocale(), and localeconv(). Constants live
under notbsd for now.

Also move F_DUPFD_CLOEXEC up a level as it is available on Android.

This commit leaves file sealing related fcntls and bitflag constants
out, as they are defined in `linux/fcntl.h` rather than `fcntl.h`. They
can be included once an approach for verification has been figured out.
See #235 for more detail.

These flags are available on Android.

They have different types and should be visually separated for ease of
reading.

The flags are available in Android, and should be defined higher up.

The addition of sockaddr_nl seems to be a fairly recent
addition to bionic, although it would appear that its lack
of presence in previous versions is more of an oversight than
anything else.

https://github.com/android/platform_bionic/blob/831c8a52498d3c7be204a00847275f6e9163626f/libc/kernel/uapi/linux/netlink.h#L54



This change is motivated by failures to build nix under Android.

Signed-off-by: Paul Osborne <osbpau@gmail.com>

This commit changes most uses of cfg_if as follows:
- fallthrough `else` usage is avoided for architecture or OS specific
  items
- a comment is added in the final `else` clause to signal intent someone
  modifying

It is safer to omit items than include ones for the wrong platform or
architecture.

The associated `perf_event_attr` struct is not included as it contains
unions and a bitfield making it unrepresentable in Rust. Additionally,
it is not entirely stable, and has changed size several times.

This is how MetadaExt expects these fields to be named.

See https://github.com/rust-lang/rust/blob/c116ae35cf49b55bd8d82e31f1ba030cf7e63867/src/libstd/os/linux/fs.rs#L107-L121