==================== Changes in man-pages-2.00 ====================

Released: 2004-12-16

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alberto Bertogli <albertogli@telpin.com.ar>
Anand Kumria <wildfire@progsoc.org>
Andrey Kiselev <dron@ak4719.spb.edu>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Chris Green <cmg@dok.org>
Branden Robinson <branden@debian.org>
Emmanuel Colbus <emmanuel.colbus@ensimag.imag.fr>
Enrico Zini <enrico@debian.org>
Eric Estievenart <eric.estievenart@free.fr>
Fabian Kreutz <kreutz@dbs.uni-hannover.de>
Florian Weimer <fw@deneb.enyo.de>
Jan Kuznik <kuznik@gepro.cz>
Joey (Martin) Schulze <joey@infodrom.org>
Johannes Berg <johannes@sipsolutions.de>
John V. Belmonte <jbelmonte@debian.org>
Karel Kulhavy <clock@twibright.com>
Luis Javier Merino Morán <ljmerino@pandasoftware.es>
Martin Pool <mbp@sourcefrog.net>
Richard Kreckel <Richard.Kreckel@ginac.de>
Vasya Pupkin <ptushnik@gmail.com>

Apologies if I missed anyone!

Global changes
--------------

Various pages
    Fabian Kreutz
        Many math pages had their synopses compressed, as per suggestion
        from Fabian Kreutz.

Various pages
    Fabian Kreutz / aeb
        Many minor content and formatting bug fixes were made to the math
        pages, following suggestions from Fabian Kreutz (who recently
        translated many of the 1.70 math pages into German) and
        Andries Brouwer.

Various pages
    mtk
        For consistency, all instances of "super-user" were changed
        to the more common "superuser".

Various pages
    Vasya Pupkin / mtk
        After a note from Vasya Pupkin, I added <errno.h> to the SYNOPSIS
        of several Section 2 pages using the _syscallN() macros.

        In addition:
            -- erroneous semicolons at the end of _syscallN() were removed
               on various pages.

            -- types such as "uint" in syscallN() declarations were changed
               to "unsigned int", etc.

            -- various other minor breakages in the synopses were fixed.

        The affected pages are:

                getdents.2
                gettid.2
                llseek.2
                mmap2.2
                modify_ldt.2
                pivot_root.2
                quotactl.2
                readdir.2
                sysctl.2
                syslog.2
                tkill.2

Typographical or grammatical errors have been corrected in several
other places.

Changes to individual pages
---------------------------

bind.2
    Florian Weimer
        Added 'const' to declaration of 'my_addr' in prototype.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=239762.

fcntl.2
    Martin Pool
        Added O_NOATIME to list of flags that can be changed via F_SETFL.
    mtk/aeb
        Noted F_GETOWN bug after suggestion from aeb.
        See also:
        http://marc.theaimsgroup.com/?l=linux-kernel&m=108380640603164&w=2

getrlimit.2
    mtk
        Material on getrusage.2 has been separated out into its own page.
        Rewrote discussion on RLIMIT_MEMLOCK to incorporate kernel
        2.6.9 changes.
        Added note on RLIMIT_CPU error in older kernels.
        Added RLIMIT_SIGPENDING.
        Also made a few other minor changes.

getrusage.2
    mtk
        This page is new(ish) -- it was created by splitting
        getrlimit.2.

        Repaired note on SIGCHLD behavior to note that the
        POSIX non-conformance has been fixed in 2.6.9.

kill.2
    Modified after suggestion from Emmanuel Colbus
        Changed wording of sentence under NOTES describing
        when signals can be sent to init(1).

mlock.2
munlock.2
mlockall.2
munlockall.2
        These have been consolidated into a single mlock.2 page.
        In the process, much duplication was eliminated
        and new information was added about RLIMIT_MEMLOCK
        and the changes in memory locking in kernel 2.6.9,

mmap.2
    mtk
        Added cross-ref to setrlimit(2) concerning memory locking limits.
    Eric Estievenart
        Note that MAP_FIXED replaces existing mappings

msgctl.2
    mtk
        Substantial language and formatting clean-ups.
        Added msqid_ds and ipc_perm structure definitions.

msgget.2
    mtk
        Substantial language and formatting clean-ups.
        Added notes on /proc files.

msgop.2
    mtk
        Substantial language and formatting clean-ups.
        Added notes on /proc files.

open.2
    Martin Pool
        Added O_NOATIME (new in Linux 2.6.8)
    mtk
        Reordered list of 'flags' description alphabetically

personality.2
    2004-11-03 applied patch from Martin Schulze

semctl.2
    mtk
        Substantial language and formatting clean-ups.
        Rewrote semun text.
        Added semid_ds and ipc_perm structure definitions.

semget.2
    mtk
        Substantial language and formatting clean-ups.
        Added notes on /proc files.
        Rewrote BUGS note about semget()'s failure to initialize
        semaphore values.

semop.2
    mtk
        Substantial language and formatting clean-ups.
        Added notes on /proc files.

shmctl.2
    mtk
        Substantial language and formatting clean-ups.
        Updated shmid_ds structure definitions.
        Added information on SHM_DEST and SHM_LOCKED flags.
        Noted that CAP_IPC_LOCK is not required for SHM_UNLOCK
        since kernel 2.6.9.
        Added notes on 2.6.9 RLIMIT_MEMLOCK changes.
        Added RLIMIT_SIGPENDING (new in Linux 2.6.8)

shmget.2
    mtk
        Substantial language and formatting clean-ups.
        Added notes on /proc files.

shmop.2
    mtk
        Substantial language and formatting clean-ups.
        Changed wording and placement of sentence regarding attachment
        of segments marked for destruction.

sigaction.2
    mtk
        Added mention of SIGCONT under SA_NOCLDSTOP.
        Added SA_NOCLDWAIT.
        Updated discussion for POSIX.1-2001 and SIGCHLD and sa_flags.
        Noted that CLD_CONTINUED is supported since Linux 2.6.9.
        Added SI_TKILL (new in Linux 2.4.19).
        Other minor changes.

signal.2
    mtk
        Removed text on ignoring SIGCHLD; replaced with pointer
        to sigaction.2.

sigwaitinfo.2
    After bug report from Andrey Kiselev
        Fixed prototype: "timeout" --> "*timeout"
        as per: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=222145

stat.2
    Enrico Zini
        Added text to clarify that S_IS*() macros should be applied to
        st_mode field.
        as per: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=249698

swapon.2
    After Debian bug report from Anand Kumria
        Added "no swap space signature" to EINVAL error.
    mtk
        Added EINVAL error for swapoff() ("not currently a swap area").
        Added EBUSY error for swapon().
        A few formatting fixes.

times.2
    mtk
        In Linux 2.6, the return value of times changed; it is no
        longer time since boot, but rather:

            boot_time + 2^32 / HZ - 300

        Repaired note on SIGCHLD behavior to note that the
        POSIX non-conformance has been fixed in 2.6.9.
        Some formatting fixes.

undocumented.2
    After bug report from Johannes Berg
        Changed
            .TH UNIMPLEMENTED
        to:
            .TH UNDOCUMENTED
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=220741

wait.2
    mtk
        Added waitid(2).
        Added WCONTINUED and WIFCONTINUED (new in 2.6.10).
        Added text on SA_NOCLDSTOP.
        Updated discussion of SA_NOCLDWAIT to reflect 2.6 behavior.
        Much other text rewritten.

wait4.2
    mtk
        Rewrote this page, removing much duplicated information,
        and replacing with pointers to wait.2.
    Luis Javier Merino Morán / mtk
        CONFORMING TO said "SVr4, POSIX".  Changed to "4.3BSD"

waitid.2
    mtk
        New link to wait.2

assert.3
    After bug report from Branden Robinson
        The assert() failure message goes to stderr not stdout.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=284814

ctime.3
    mtk
        Noted that 0 in tm_mday is interpreted to mean the last day
        of the preceding month.

getnameinfo.3
    http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=229618
        getnameinfo() does not set errno, it returns a non-zero
        value indicating the error.
    mtk
        added EAI_OVERFLOW error

killpg.3
    mtk
        Minor changes to SEE ALSO and CONFORMING TO.

lseek64.3
    aeb
        New page by Andries Brouwer

tzset.3
    Richard Kreckel
        Change "NULL" to "empty" when talking about the value of TZ.
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=601

printf.3
    After bug report from Jan Kuznik
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=205736
        Fixed bad realloc() use in snprintf() example

realpath.3
    mtk
        Added discussion of resolved_path == NULL.

random.4
    After bug report from John V. Belmonte
        Updated init and quit scripts to reflect kernel 2.4/2.6 reality
        (Scripts taken from drivers/char/random.c)
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=247779

proc.5
    mtk
        Updated description of /proc/loadavg to include
        nr_running(), nr_threads, last_pid.

        rtsig-max and rtsig-nr went away in 2.6.8

        updated statm, and fixed error in order of list

boot.7
    applied patch from Martin Schulze

capabilities.7
    mtk
        Added O_NOATIME for CAP_FOWNER

netdevice.7
    Karel Kulhavy and AEB
        Formatting fix after note from Karel Kulhavy and AEB, plus a
        few wording fixes.

signal.7
    mtk
        /proc/sys/kernel/rtsig-* were superseded by RLIMIT_SIGPENDING
        in kernel 2.6.8.

tcp.7
    mtk/aeb
        Updated details of interaction of TCP_CORK and TCP_NODELAY.

==================== Changes in man-pages-2.01 ====================

Released: 2004-12-20

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Carsten Hey <c.hey@web.de>
Johannes Berg <johannes@sipsolutions.de>
Joshua Kwan <joshk@triplehelix.org>
Marek Habersack <grendel@debian.org>
Martin Schulze <joey@infodrom.org>
Matthew Dempsky <jivera@flame.org>
Matthew Gregan <kinetik@orcon.net.nz>
Pedro Zorzenon Neto <pzn@terra.com.br>
Tony Crawford <tony@klosterdorf.de>

Apologies if I missed anyone!

Global changes
--------------

accept.2
close.2
send.2
setsid.2
socket.2
closedir.3
initgroups.3
mkstemp.3
opendir.3
readdir.3
telldir.3
    Matthew Dempsky, mtk
        triggered by http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=283179
        The wording describing how errno is set was fixed up in these pages.

Typographical or grammatical errors have been corrected in several
other places.

Changes to individual pages
---------------------------

sendfile.2
    mtk
        Adjusted descriptions of argument file types to be closer to
        2.6 reality.
        Wording and formatting changes.

ctan.3
ctanh.3
    Tony Crawford
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=270817
        Formulae on the pages should be T = S / C not T = C / S.

errno.3
    Martin Schulze, mtk
        Removed errno declaration from prototype, added notes
        on historical need for this declaration.
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=174175

aio_return.3
    as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=224953
        Changed erroneous "aio_return(2)" to "aio_return(3)".

posix_openpt.3
    mtk
        New by mtk

ptsname.3
    mtk
        Added description of ptsname_r().
        Added ERRORS.

ptsname_r.3
    mtk
        New link to ptsname.3.

shm_open.3
    Matthew Gregan
        add <fcntl.h> to synopsis
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=271243

strcasecmp.3
    Marek Habersack
            .SH "CONFORMING TO"
            -BSD 4.4
            +BSD 4.4, SUSv3
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=234443

strfry.3
    Joshua Kwan
        Added _GNU_SOURCE to prototype
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=213538

strftime.3
    Cartsen Hey
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=276248

        Changed range for "%S" from 0..61 to 0..60.

        SUSv3 says 0..60.  I think the manual page probably says
        0..61, because that's what SUSv2 said.
        (Some other implementations' man pages also say 0..61 --
        e.g., Solaris 8 & 9, Tru64 5.1B; FreeBSD 5.1 says 0..60.)

        The glibc manual currently says 0..60.

        Given that SUSv3 says 0..60, I've changed the
        manual page to also say this:

            -The second as a decimal number (range 00 to 61).
            +The second as a decimal number (range 00 to 60).
            +(The range is up to 60 to allow for occasional leap seconds.)

sysconf.3
    Johannes Berg
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=226974
        -.BR POSIX2_FORT_RUN " - " _SC_2_FORT_DEV
        +.BR POSIX2_FORT_DEV " - " _SC_2_FORT_DEV

system.3
    Pedro Zorzenon
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=242638
        Noted use of _XOPEN_SOURCE to get macros from <stdlib.h>
        for wait(2).

    mtk
        Changed name of argument from 'string' to 'command' (like POSIX).

        Noted that glibc does nowadays explicitly check for the existence
        of the shell if 'command' is NULL, rather than the older behavior
        of assuming the shell exists and always returning 1 if
        'command' is NULL.

        Other wording and formatting clean-ups.

undocumented.3
    Remove some functions names that *are* documented.


==================== Changes in man-pages-2.02 ====================

Released: 2005-04-14

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Branden Robinson <branden@debian.org>
Colin Watson <cjwatson@debian.org>
David Lloyd <dmlloyd@tds.net>
Gordon Jin <gordon.jin@intel.com>
Heikki Orsila <shd@modeemi.cs.tut.fi>
Jamie Lokier <jamie@shareable.org>
Johan Walles
Kai Makisara <Kai.Makisara@kolumbus.fi>
Marko Kohtala <marko.kohtala@gmail.com>
Martin Pool <mbp@sourcefrog.net>
Martin (Joey) Schulze <joey@infodrom.org>
Matthias Lang <matthias@corelatus.se>
Michael Haardt <michael@moria.de>
Michael Mühlebach <michael@anduin.ch>
Mike Frysinger <vapier@gentoo.org>
Sasa Stevanovic <mg94c18@alas.matf.bg.ac.yu>
Serguei Leontiev <leo@sai.msu.ru>

Apologies if I missed anyone!

Global changes
--------------

ctime.3
tzselect.8
zdump.8
zic.8
    Martin (Joey) Schulze
        Removed SEE ALSO reference to nonexistent newctime(3).
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=236884

Typographical or grammatical errors have been corrected in several
other places.

Changes to individual pages
---------------------------

clone.2
    mtk
        Noted the PID caching behavior of NPTL's getpid()
        wrapper under BUGS.

        Added futex(2), set_thread_area(2), set_tid_address(2),
        tkill(2) under SEE ALSO.

epoll_ctl.2
epoll_create.2
    Marko Kohtala  / mtk
        Improved various error descriptions.

epoll_wait.2
    David Lloyd / Mike Frysinger, Marko Kohtala
        Added EINTR to errors.

fcntl.2
    Jamie Lokier / mtk
        Improved discussion of F_SETOWN and F_SETSIG with respect to
        multi-threaded programs.
        Generally cleaned up the discussion of F_SETOWN.

        Updated CONFORMING TO to note that F_GETOWN and F_SETOWN are
        now in POSIX.

link.2
    mtk
        Noted discrepancy between Linux and POSIX.1 when oldpath
        is a symbolic link.
        See: http://bugs.linuxbase.org/show_bug.cgi?id=367
        and: http://www.opengroup.org/austin/mailarchives/ag/msg08152.html

    Michael Haardt / mtk
        Clarified EXDEV error description: it isn't possible to link
        across mount points, even if the mount points refer to the same
        file system.

mincore.2
    mtk, after note from Gordon Jin
        Updated ERRORS.

pipe.2
    As per message from Serguei Leontiev
        Removed SVr2, AT&T, and BSD from CONFORMING TO, since
        a pipe on those systems is actually bidirectional.
        (Pipes are implemented as STREAMS on the former, and
        sockets on the latter.)

posix_fadvise.2
    mtk
        Noted kernel version where posix_fadvise() appeared and
        noted bug in handling of 'len' in kernels < 2.6.6.

rename.2
    Michael Haardt
        Clarified EXDEV error description: it isn't possible to rename
        a file across mount points, even if the mount points refer to
        the same file system.

semop.2
    mtk
        Noted kernel version numbers for semtimedop().

setitimer.2
    Matthias Lang, mtk
        Noted MAX_SEC_IN_JIFFIES ceiling.
        Added note about treatment of out-of-range tv_usec values.

sigqueue.2
    Johan Walles, Martin (Joey) Schulze
        Added sigqueue.2 to SEE ALSO.

times.2
    mtk
        Added notes on non-standard behavior: Linux allows 'buf' to
        be NULL, but POSIX.1 doesn't specify this and it's non-portable.

uselib.2
    Andries Brouwer
        Improved DESCRIPTION; clarified distinction between
        EACCES and ENOEXEC.

bcopy.3
    Heikki Orsila
        bcopy() handles overlapping case, but memcpy() does not,
        so for consistency memmove() should be also mentioned.

getmntent_r.3
    Martin (Joey) Schulze
        New link to man3/getmntent.3.

memcpy.3
    Small wording change after suggestion from Sasa Stevanovic.

strcasestr.3
    mtk
        Created as link to strstr.3.

strftime.3
    mtk
        Noted that SUSv2 allowed a range of 00 to 61 for %S specifier.

strstr.3
    mtk
        Added description of strcasestr().

random.4
    aeb
        Improved description of read from /dev/urandom.

st.4
    Kai Makisara
        Substantial updates.

man.7
    Martin Schulze
    Branden Robinson
    Colin Watson
        Mention the .URL macro more verbosely.


==================== Changes in man-pages-2.03 ====================

Released: 2005-06-02

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Joey (Martin) Schulze <joey@infodrom.org>
Johannes Nicolai <johannes.nicolai@hpi.uni-potsdam.de>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Klaus Ethgen <Klaus@Ethgen.de>
Pavel Heimlich <tropikhajma@seznam.cz>
Ross Boylan <RossBoylan@stanfordalumni.org>
Vincent Fourmond <vincent.fourmond@9online.fr>

Apologies if I missed anyone!

Global changes
--------------

console.4
console_ioctl.4
mouse.4
tty.4
vcs.4
    Pavel Heimlich
        Change `ttys(4)' to `ttyS(4)'.

Typographical or grammatical errors have been corrected in several
places.

Changes to individual pages
---------------------------

clone.2
    mtk
        Substantially enhanced discussion of CLONE_THREAD.

        Added CLONE_SYSVSEM, CLONE_UNTRACED, CLONE_STOPPED.

        Other minor fixes.

execve.2
    aeb
        Noted effect of ptracing when execing a set-UID program.

fcntl.2
    Johannes Nicolai / mtk
        Noted F_SETOWN bug for socket file descriptor in Linux 2.4
        and earlier.

        Added text on permissions required to send signal to owner.

flock.2
    mtk
        Noted that lock conversions are not atomic.

getrusage.2
    mtk
        ru_nswap has never contained useful information.
        Kernel 2.6.6 clarified that with a patch
        ("[PATCH] eliminate nswap and cnswap").  See also:
        http://www.ussg.iu.edu/hypermail/linux/kernel/0404.1/0720.html

kill.2
    mtk
        Clarified wording of the 'pid == -1' case.

mount.2
    mtk
        Added MNT_EXPIRE, plus a few other tidy-ups.

sched_setaffinity.2
    mtk
        Added text to note that sched_setaffinity() will migrate the
        affected process to one of the specified CPUs if necessary.

        Added a NOTE to point out that the affinity mask is actually a
        per-thread attribute that can be adjusted independently for
        each thread in a thread group.

shmctl.2
    mtk
        Noted aberrant Linux behavior with respect to new attaches to a
        segment that has already been marked for deletion.

        Noted changes in permissions required for SHM_LOCK/SHM_UNLOCK.

wait.2
    mtk
        Noted that the __W* flags can't be used with waitid().

confstr.3
    mtk
        Added _CS_GNU_LIBC_VERSION and _CS_GNU_LIBPTHREAD_VERSION.

hosts.5
    Ross Boylan / Martin Schulze
        various changes as per
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=304242

proc.5
    mtk
        Minor changes to discussion of /proc/PID/stat signal fields.
        Added 'rt_priority' and 'policy' to /proc/PID/stat.

capabilities.7
    mtk
        1,$s/inherited/inheritable/g

regex.7
    Vincent Fourmond / Joey (Martin) Schulze
        Removed discussion of `[[:<:]]' and `[[:>:]]' since they do
        not seem to be in the glibc implementation.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=295666

tzselect.8
    Joey (Martin) Schulze / Klaus Ethgen
        The default zoneinfo directory is now /usr/share/zoneinfo.
        (was: /usr/local/etc/zoneinfo)
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=267471


==================== Changes in man-pages-2.04 ====================

Released: 2005-06-21

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Baurjan Ismagulov <ibr@ata.cs.hun.edu.tr>
Dave Love <d.love@dl.ac.uk>
Dieter Brueggemann <dieter.brueggemann@entitec.de>
Geoff Clare <gclare@gclare.org.uk>
Guido Trotter <ultrotter@debian.org>
kabloom <kabloom@ucdavis.edu>
Kevin Ryde <user42@zip.com.au>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Mike Furr <mfurr@debian.org>
Olivier Croquette <ocroquette@free.fr>
Olivier Guilyardi <ylf@xung.org>
Peter Cordes <peter@llama.nslug.ns.ca>
Philipp Spitzer <philipp@toastfreeware.priv.at>
Tanaka Akira <akr@m17n.org>
Thierry Excoffier <exco@bat710.univ-lyon1.fr>
Thomas Hood <jdthood@yahoo.co.uk>
Vincent Lefevre <vincent@vinc17.org>
Walter Harms <walter.harms@informatik.uni-oldenburg.de>

Apologies if I missed anyone!

Global changes
--------------

Various pages
    mtk
        For consistency across pages:

            1,$s/nonzero/non-zero/g

Typographical or grammatical errors have been corrected in several
places.


New pages
---------

pthreads.7
    mtk
        An overview of the Linux implementations of POSIX threads.


Changes to individual pages
---------------------------

_exit.2
    mtk
        Various minor changes.

epoll_ctl.2
    Mike Furr
        BUGS: In kernels < 2.6.9, EPOLL_CTL_DEL required a non-NULL
        'event', even though this argument is ignored.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=306517

flock.2
    mtk / Kevin Ryde
        Clarified semantics of relationship between flock() locks
        and open file entries and file descriptors.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=291121

getitimer.2
    Olivier Croquette, Thierry Excoffier
        Noted the existence of the short sleep bug (up to 1 jiffy).

getrlimit.2
    mtk
        RLIMIT_RSS only has affect "in 2.4.x", not "in 2.4 and later".

getrusage.2
    Geoff Clare
        Since Linux 2.6, the ru_nvcsw and ru_nivcsw fields are used.

nice.2
    mtk / Guido Trotter
        Rewrote description of return value.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=296183

open.2
    Walter Harms
        O_DIRECT needs _GNU_SOURCE.
    mtk
        O_ASYNC works for pipes and FIFOs in Linux 2.6.
        Various minor fixes.

atexit.3
    mtk
        Various minor changes.

exit.3
    mtk
        Various minor changes.

getopt.3
    mtk / Philipp Spitzer
        Fix description of return value.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=308359

hsearch.3
    mtk
        Changed (char *) to (void *) in example.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=313607

log1p.3
    Justin Pryzby
        Make log(3) SEE ALSO log1p(3),
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=309578

makecontext.3
    Tanaka Akira
        Fix description of RETURN VALUE for makecontext(),
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=311800

on_exit.3
    mtk
        Various minor changes.

rand.3
    kabloom
        Small fix to a code example,
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=194842

realpath.3
    mtk / Thomas Hood
        When specifying resolved_path as NULL, realpath()
        will (still) only allocate up to PATH_MAX bytes.
        Plus other minor changes.
        See also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=239424

rcmd.3
    Dave Love
        The required header file for these functions on Linux is <netdb.h>,
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=311680

scanf.3
    Olivier Guilyardi
        Arg for %p is a pointer to _a pointer to_ void,
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=263109

stdin.3
    Vincent Lefevre
        freopen() can change the descriptors associated with
        stdin/stdout/stderr, as per
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=295859

strerror.3
    Baurjan Ismagulov
        strerror_r(3) requires #define _XOPEN_SOURCE 600,
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=290880

sysconf.3
    Peter Cordes / mtk
        Fix typo: "_SC_2_DEV" should be "_SC_2_C_DEV".

proc.5
    mtk
        Added pointers under /proc/sys/net to tcp.7 and ip.7.

ip.7
    mtk
        Various wording and formatting fixes.
        Reordered /proc/sys/net/ipv4/ip_* file descriptions alphabetically.

tcp.7
    Dieter Brueggemann / mtk
        Fixes to the discussion of SIOCATMARK and tcp_stdurg.
    mtk
        Various wording and formatting fixes.
        Incorporated some new /proc/sys/net/ipv4/tcp_* file descriptions
        from the 2.6.12 source file Documentation/networking/ip-sysctl.txt.


==================== Changes in man-pages-2.05 ====================

Released: 2005-06-27

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

A Costa <agcosta@gis.net>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Bas Zoetekouw <bas@debian.org>
Dan Jacobson <jidanni@jidanni.org>
Delian Krustev <krustev@krustev.net>
Dora Anna Volgyesi <volgyesi@elte.hu>
Martin (Joey) Schulze <joey@infodrom.org>
Ove Kaaven <ovek@arcticnet.no>

Apologies if I missed anyone!

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.  (Special thanks to A Costa.)


Changes to individual pages
---------------------------

_exit.2
    mtk / aeb
        Reversed 2.04 introduction of the term "process termination
        function".

close.2
    mtk
        Clarified what type of lock close() affects.
        Minor formatting changes.

dup.2
    mtk
        Consistent use of terms "open file description",
        "file status flags", and "file descriptor flags".
        Removed mention of lock sharing -- it was not accurate.
        Minor formatting fixes.

fcntl.2
    mtk
        Consistent use of terms "open file description",
        "file status flags", and "file descriptor flags".
        Some rewriting of discussion of file descriptor flags
        Under F_DUPFD, replaced some text duplicated in dup.2
        with a cross ref to dup.2
        Minor wording and formatting fixes.

fpclassify.3
    mtk / Martin (Joey) Schulze / Bas Zoetekouw
        The return value of isinf() changed in glibc 2.02
        to differentiate positive and negative infinity.
        See: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=285765

getgid.2
getuid.2
    Delian Krustev
        Remove confusing text describing real and effective IDs.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=285852

getitimer.2
    mtk
        The short sleep bug (up to 1 jiffy) that was newly noted in
        man-pages-2.04 has just been fixed in 2.6.12.

getpriority.2
    mtk
        Changed range documented in main text from -20..20 to -20..19.
        Noted that the range is -20..20 on some systems.

open.2
    mtk / aeb
        Clarification of term "open file description" along with
        explanation of what information it maintains.
        Other wording improvements.
        Various minor wording changes.

atexit.3
    mtk / aeb
        Reversed 2.04 introduction of the term "process termination
        function".
    mtk
        Noted use of atexit() for establishing function to be invoked on
        shared library unload.
        Noted that atexit()-registered functions are not invoked on
        abnormal termination.
        Formatting fixes.

exit.3
    mtk / aeb
        Reversed 2.04 introduction of the term "process termination
        function".
    mtk
        Minor rewording and formatting changes.

getloadavg.3
    mtk
        Added #define _BSD_SOURCE to prototype.

log2.3
    Martin (Joey) Schulze
        Add ERANGE error.

readdir.3
    mtk
        Added definition of Linux dirent structure.
        Some formatting cleanups.

strtod.3
    Dora Anna Volgyesi / mtk
        strtold() and strtof() need _ISOC99_SOURCE or _XOPEN_SOURCE=600
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=246668

tdestroy.3
    mtk
        New link to tsearch.3.

tsearch.3
    mtk
        Added tdestroy to .TH line.

mem.4
    mtk
        Change "chown root:mem /dev/mem" to "chown root:kmem /dev/mem".

null.4
    mtk
        Change "chown root:mem /dev/null /dev/zero" to
        "chown root:root /dev/null /dev/zero".

vcs.4
    Dan Jacobson / Martin (Joey) Schulze
        Replaced "selection(1)" by "gpm(8)" under SEE ALSO
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=253515

signal.7
    Ove Kaaven
        SA_SIGACTION should be SA_SIGINFO
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=305369

urn.7
    mtk
        New link to uri.7


==================== Changes in man-pages-2.06 ====================

Released: 2005-07-15

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Bhavesh P Davda <bhavesh@avaya.com>
Clau Weber <claus@jambit.com>
Dov Murik <dov@dv-networks.com>
David Lloyd <dlloyd@microbits.com.au>
Frederik Deweerdt <frederik.deweerdt@gmail.com>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Lars Wirzenius <liw@iki.fi>
Martin Pool <mbp@sourcefrog.net>
Mike Frysinger <vapier@gentoo.org>
Petter Reinholdtsen <pere@hungry.com>
Steven Murdoch <Steven.Murdoch@cl.cam.ac.uk>
Walter Harms <walter.harms@informatik.uni-oldenburg.de>

Apologies if I missed anyone!

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.

Many uses of hyphens and dashes were corrected.


New pages
---------

canonicalize_file_name.3
    Walter Harms / mtk

Removed Pages
-------------

sstk.2
    mtk
        AFAIK, this system call has never actually done anything (other
        than be a stub) on any Unix.

Changes to individual pages
---------------------------

accept.2
    mtk
        Various wording and formatting fixes.

bind.2
    mtk
        Minor formatting changes

clone.2
    mtk
        Various minor wording improvements; some formatting fixes

connect.2
    mtk
        Various wording and formatting fixes.

epoll_create.2
    Bhavesh P Davda
        s/positive/non-negative/      [for file descriptor]

getrlimit.2
    mtk
        Documented RLIMIT_MSGQUEUE limit.
        RLIMIT_RSS ceased to have any effect in 2.4 in kernel 2.4.30.
        (It already didn't have any effect in 2.2.x and 2.6.x.)
        s/MADVISE_WILLNEED/MADV_WILLNEED/

listen.2
    mtk
        Removed historic comment on BSD backlog ceiling.
        Minor wording and formatting changes.

semop.2
    mtk
        Added BUG: in some circumstances, a process that is
        waiting for a semaphore to become zero is not woken
        up when the value does actually reach zero.
        http://marc.theaimsgroup.com/?l=linux-kernel&m=110260821123863&w=2
        http://marc.theaimsgroup.com/?l=linux-kernel&m=110261701025794&w=2

socket.2
    mtk
        Various minor wording improvements

umask.2
    mtk
        Added mkdir(2) to discussion, made term "file mode creation
        mask" clearer.
        Various, mostly small, wording changes

errno.3
    Martin Pool
        Change description for ESTALE
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=237344

fgetgrent.3
getgrent.3
getgrent_r.3
    David Lloyd
        Added SEE ALSO putgrent(3)
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=211336

getgrent.3
getgrnam.3
getpwent.3
getpwnam.3
    Lars Wirzenius / mtk
        Replace mention of /etc/{passwd,group} by references to
        "passwd/group database", and LDAP and NIS.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=316117
    mtk
        Miscellaneous wording improvements
        Consistent DESCRIPTION and ERRORS wording across these pages.

getnameinfo.3
    mtk
        Relocate misplaced text describing gai_strerror().

getnetent.3
    Petter Reinholdtsen
        s/endservent/endnetent/
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=316517

getspnam.3
    Lars Wirzenius / mtk
        Replace mention of /etc/shadow by references to
        "shadow password database", and LDAP and NIS.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=316117
    mtk, Claus Weber
        Miscellaneous wording improvements
        Consistent DESCRIPTION wording vis-a-vis getpwnam.3 etc.

hsearch.3
    Frederik Deweerdt
        Fix hsearch_r() prototype

scanf.3
    Justin Pryzby / mtk
        Fix description of RETURN VALUE
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=317037
    mtk
        various parts substantially rewritten; added description of
        %n$ form; various text incorporated from the GNU C library
        documentation ((C) The Free Software Foundation).

shm_open.3
    mtk
        Modified details of how user and group ownership of a new
        object are set.
        Various minor wording and formatting cleanups.

elf.5
    Mike Frysinger
        tweaked the short description to include definition of 'ELF'
        add ELFOSABI_NONE to the ELFOSABI_ list
        tweak/add more machines to EM_ list for ehdr->e_machine
        fix indenting to be consistent
        tweak the display of the ELF_ST_* macros
        document the Elf_Dyn structure

proc.5
    mtk
        Updated discussion of /proc/stat.
        Added text on the /proc/sys/fs/mqueue/* files.

ip.7
    Steven Murdoch
        Change protocol in UDP prototype.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=182635

tcp.7
    Dov Murik
        The first sentence under NOTES about SO_KEEPALIVE and SIGPIPE
        makes no grammatical sense (and possibly also no technical sense).
        It has been removed.


==================== Changes in man-pages-2.07 ====================

Released: 2005-07-19

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Mike Frysinger <vapier@gentoo.org>

Apologies if I missed anyone!

Global changes
--------------

Various pages
    mtk
        The terms "set-user-ID" and "set-group-ID" are now used
        consistently (no abbreviations) across all manual pages.

Various pages
    mtk
        Consistent use of "saved set-user-ID" and "saved set-group-ID"
        (no more "saved user ID", "saved effective UID",
        saved group ID", etc.)

Various pages
    mtk
        Global fixes in textual descriptions:

            uid --> UID
            gid --> GID
            pid --> PID
            id --> ID

Various pages
    mtk
        Consistent use of st_atime, st_ctime, st_mtime, with
        explanatory text, instead of atime/ctime/mtime.

Various pages
    mtk
        Classical BSD versions are now always named x.yBSD (formerly
        there was a mix of x.yBSD and BSD x.y).

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

setresuid.2
    mtk
        Some rewording.

stat.2
    Mike Frysinger
        Improve description of st_dev and st_rdev.
    mtk
        Various wording and formatting improvements.

truncate.2
    mtk
        Some formatting fixes


==================== Changes in man-pages-2.08 ====================

Released: 2005-09-21

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Adrian Bunk <bunk@stusta.de>
Alain PORTAL <aportal@univ-montp2.fr>
Andrew Pimlott <andrew@pimlott.net>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Baurzhan Ismagulov <ibr@radix50.net>
Bernhard R. Link <brlink@debian.org>
Bodo Stroesser <bstroesser@fujitsu-siemens.com>
David N. Welton <davidw@eidetix.com>
Dov Murik <dov@dv-networks.com>
Heikki Orsila <shd@modeemi.cs.tut.fi>
Hasso Tepper <hasso@estpak.ee>
Hrvoje Niksic <hniksic@xemacs.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Ludovic Courtes <ludovic.courtes@laas.fr>
Mike Frysinger <vapier@gentoo.org>
Nicolas François <nicolas.francois@centraliens.net>
Norbert Buchmuller <norbi.spam@nix.hu>
Paul Brook <paul@nowt.org>
Ramiro Aceves <ea1abz@gmail.com>
Tommy Pettersson <ptp@lysator.liu.se>
Walter Harms <walter.harms@informatik.uni-oldenburg.de>

Apologies if I missed anyone!

Global changes
--------------

Various pages
    mtk
        RFC references are now always written as "RFC\ nnn"
        (not "RFC nnn" or "RFCnnn").

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

du.1
    Mike Frysinger
        To get an effect like "-h", BLOCKSIZE must start with "human",
        not "HUMAN".

time.1
    Mike Frysinger
        s/standard output/standard error/

clone.2
    Paul Brook / mtk
        Fix small error in description of CLONE_PARENT_SETTID

connect.2
    Heikki Orsila
        Add EINTR error
        See http://lkml.org/lkml/2005/7/12/254

getpriority.2
    mtk
        Expanded discussion of relationship between user and kernel
        representations of the nice value.

        Added discussion of RLIMIT_NICE and a cross reference to
        getrlimit.2 under the description of the EACCES error.

        Noted 2.6.12 change in credentials checking for setpriority().

getrlimit.2
    mtk
        Added description of RLIMIT_RTPRIO

        Added description of RLIMIT_NICE

mmap.2
    mtk
        Noted bug in MAP_POPULATE for kernels before 2.6.7.

mremap.2
    mtk
        Added _GNU_SOURCE to prototype.
        Rewrote description of MREMAP_MAYMOVE.
        Rewrote description of EAGAIN error.
        Added discussion of resizing of memory locks.
        Added entries to SEE ALSO.
        Some formatting fixes.

msgctl.2
    mtk
        Added IPC_INFO, MSG_INFO, MSG_STAT descriptions.

nanosleep.2
    Baurzhan Ismagulov
        Add to prototype: define _POSIX_C_SOURCE 199309
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=314435

nice.2
    mtk
        Added sentence noting that range of the nice value is described
        in getpriority.2.
        Added cross-reference to setrlimit(2) for discussion on
        RLIMIT_NICE.

outb.2
    David N. Welton / Justin Pryzby / mtk
        Clarified the order of value and port arguments;
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=263756

pause.2
    mtk
        Added SEE ALSO for sigsuspend.2
        Some formatting fixes.

poll.2
    Tommy Pettersson
        nfds should be prototyped as nfds_t
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=322934

    mtk
        Some wording and formatting improvements.

prctl.2
    mtk
        Since kernel 2.6.13 PR_SET_DUMPABLE can also have the value 2.

rand.3
    Hrvoje Niksic / mtk
        Remove misleading text describing FreeBSD's sranddev() function.
        As per debian bug 328629

readv.2
    mtk / Walter harms
        Added LINUX NOTES on trickery performed by glibc when
        vector size exceeds IOV_MAX.

        Formatting clean-ups.

remap_file_pages.2
    mtk
        Added text to note that start and size are both rounded downward.

sched_setparam.2
    mtk
        Modified discussion of privileges; added pointer to
        sched_setscheduler.2 for a discussion of privileges and
        resource limits.

sched_setscheduler.2
    mtk
        Modified discussion of privileges; added discussion of RLIMIT_RTPRIO.

semctl.2
    mtk
        Added IPC_INFO, SEM_INFO, SEM_STAT descriptions.

shmctl.2
    mtk
        Added IPC_INFO, SHM_INFO, SHM_STAT descriptions.

sigaction.2
    mtk
        Split sigpending(), sigprocmask(), and sigsuspend() out
        into separate new pages.

        Other minor changes

    mtk
        NOTES: described SA_NODEFER / sa_mask bug which was present in
                all kernels up to and including 2.6.13.
        See http://marc.theaimsgroup.com/?l=linux-kernel&m=112360948603171&w=2
        and http://marc.theaimsgroup.com/?l=linux-kernel&m=112362164911432&w=2
        List:       linux-kernel
        Subject:    Signal handling possibly wrong
        From:       Bodo Stroesser
        Date:       2005-08-09 17:44:06

signal.2
    mtk
        Updated SEE ALSO to reflect splitting of sigaction.2 into
        sigaction.2, sigsuspend.2, sigpending.2, sigprocmask.2

sigpending.2
    mtk
        New page created by splitting out from sigaction.2
        Changed CONFORMING TO.

sigprocmask.2
    mtk
        New page created by splitting out from sigaction.2
        Added text on effect of NULL for 'set' argument.
        Added text noting effect of ignoring SIGBUS, SIGFPE, SIGILL,
                and SIGSEGV.
        Noted that sigprocmask() can't be used in multithreaded process.
        Fixed EINVAL error diagnostic.
        Changed CONFORMING TO.

sigsuspend.2
    mtk
        New page created by splitting out from sigaction.2
        Added NOTES on usage.
        Added new text to DESCRIPTION.
        Changed CONFORMING TO.

stat.2
    Mike Frysinger
        Improve st_blocks description.

carg.3
    Ramiro Aceves / aeb
        Change:
                One has carg(z) = atan(creal(z) / cimag(z))
        to:
                One has tan(carg(z)) = cimag(z) / creal(z)

        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=326720

cmsg.3
    mtk
        s/SOL_TCP/IPPROTO_TCP/          (POSIX standard name)

dlopen.3
    Alain Portal
        s/-nostartupfiles/-nostartfiles/

getaddrinfo.3
    mtk
        Nowadays (since 2.3.4) glibc only sets the first ai_canonname
        field if AI_CANONNAME was specified (the current behavior
        is all that SUSv3 requires).

        1,$s/PF_/AF_/g

        Added descriptions of AI_ALL, AI_ADDRCONFIG, AI_V4MAPPED,
        and AI_NUMERICSERV.

        Some wording and formatting fixes.

getpwnam.3
    Bernhard R. Link / mtk
        Add NOTES text describing relationship of pw_dir and HOME and
        pointing out that applications should preferentially inspect HOME.

inet.3
    Mike Frysinger
        Mention "little endian" and "big endian".
        Added note about octal and hex interpretation of
             numbers-and-dots notation.

rpc.3
    mtk / Ludovic Courtes
        Commented out references to rpc_secure(3) -- we don't currently
        have such a page in the man-pages set.
        In response to http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=325115

setenv.3
    mtk
        glibc 2.3.4 fixed the "name contains '='" bug.

strnlen.3
    Mike Frysinger
        Added "#define _GNU_SOURCE" to prototype.

initrd.4
    Norbert Buchmuller / mtk
        Added text noting that the use or real-root-dev for changing
        the root device is obsolete, in favor of pivot root.
        (However, the page still needs to be rewritten to actually
        describe the pivot_root method...)
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=323621

proc.5
    mtk
        Improve text describing /proc/sys/fs/mqueue/* files.

        Describe /proc/sys/fs/suid_dumpable (new in 2.6.13).

        Added placeholder mention of /proc/zoneinfo (new in 2.6.13).
        More needs to be said about this file.

        Repaired earlier cut and paste mistake which resulted
        in part of the text of this page being duplicated.

utmp.5
    Mike Frysinger
        Added text on biarch details for ut_session and ut_tv.

capabilities.7
    mtk
        Added CAP_AUDIT_CONTROL and CAP_AUDIT_WRITE.

ip.7
    mtk / Andrew Pimlott
        Add a couple of words to make it clear that port is a 16-bit number.
        Reformat long source lines (no text changed).

        s/SOL_IP/IPPROTO_IP/            (POSIX standard name)

    Hasso Tepper
        Fix discussion of IPC_RECVTTL / IP_TTL.

signal.7
    mtk
        Updated SEE ALSO to reflect splitting of sigaction.2 into
        sigaction.2, sigsuspend.2, sigpending.2, sigprocmask.2.

socket.7
    mtk
        Clarified details of use of SO_PEERCRED.

tcp.7
    mtk
        s/SOL_TCP/IPPROTO_TCP/          (POSIX standard name)
        s/SOL_IP/IPPROTO_IP/            (POSIX standard name)

udp.7
    mtk
        Added description of UDP_CORK socket option.

        s/SOL_UDP/IPPROTO_UDP/          (POSIX standard name)
        s/SOL_IP/IPPROTO_IP/            (POSIX standard name)


==================== Changes in man-pages-2.09 ====================

Released: 2005-10-13

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Justin Pryzby <pryzbyj@justinpryzby.com>
Peter Chubb <peterc@gelato.unsw.edu.au>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Tomas Pospisek <tpo_deb@sourcepole.ch>
Trond Myklebust <trond.myklebust@fys.uio.no>

Apologies if I missed anyone!

Global changes
--------------

ptsname.3
getpt.3
unlockpt.3
openpty.3
posix_openpt.3
grantpt.3
pts.4
tty_ioctl.4
    mtk
        Added SEE ALSO for new pty.7 page.

Typographical or grammatical errors have been corrected in several
places.


New pages
---------

pty.7
    mtk
        Overview of Unix 98 and BSD pseudo-terminals.


Changes to individual pages
---------------------------

ldd.1
    mtk
        Remove "-V" option (fix from Fedora man-pages-2.07-7).

fcntl.2
    Peter Chubb / Trond Myklebust / mtk
        Since kernel 2.6.10, a read lease can only be placed on a
        file descriptor that is opened read-only.
        See the following LKML thread of Aug 2005
        ("fcntl(F GETLEASE) semantics??"):
        http://marc.theaimsgroup.com/?l=linux-kernel&m=112371777712197&w=2
        http://marc.theaimsgroup.com/?l=linux-kernel&m=112374818213000&w=2
        http://marc.theaimsgroup.com/?l=linux-kernel&m=112376335305284&w=2
        http://marc.theaimsgroup.com/?l=linux-kernel&m=112377294030092&w=2

mprotect.2
    mtk
        Add new text to ENOMEM error.

mremap.2
    mtk
        Added description of MREMAP_FIXED and 'new_address' argument
        under NOTES.
        Revised text of EINVAL error.

read.2
    Samuel Thibault / mtk
        read() can fail with EINVAL when using O_DIRECT
    mtk
        Added open(2) to SEE ALSO.

shmget.2
    mtk
        s/int/size_t/ for type of 'size' argument (fix from
        Fedora man-pages-2.07-7).

write.2
    Samuel Thibault / mtk
        write() can fail with EINVAL when using O_DIRECT

atanh.3
    mtk
        Fix: s/acosh/atanh/ (fix from Fedora man-pages-2.07-7).

fopen.3
    mtk
        Improved "a+" description (fix from Fedora man-pages-2.07-7).

getrpcent.3
    mtk
        s/getrpcent/setrpcent/ (fix from Fedora man-pages-2.07-7).

stdio.3
    mtk / Justin Pryzby
        Removed references to fropen() and fwopen(), which are
        BSDisms that don't appear in glibc.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=331174

strftime.3
    mtk
        Typo fix: %Ry ==> %Ey [SUSv3 mentions...] (fix from
        Fedora man-pages-2.07-7).

nsswitch.conf.5
    mtk
        s/network/networks/ (fix from Fedora man-pages-2.07-7).

proc.5
    mtk
        Added description of /proc/sys/vm/legacy_va_layout.

socket.7
    mtk
        Update description of SO_RCVLOWAT and SO_SNDLOWAT.
        (fix derived from Fedora man-pages-2.07-7).


==================== Changes in man-pages-2.10 ====================

Released: 2005-10-19

Global changes
--------------

The changes in this release consist *solely* of formatting fixes, with
the aim bringing greater consistency to the manual pages according to
the following rules:

-- Function name references should *always* be followed by
   parentheses, "()" (possibly containing a manual page section
   number).

-- The parentheses following a function name should *not* be
   formatted.  Thus, for example, instead of:

       .B name()

   one should write:

       .BR name ()

Much of the change was automated using two scripts:
add_parens_for_own_funcs.sh and unformat_parens.sh.
For the (possible) benefit of downstream manual page maintainers and
translators, I have placed these scripts in a new subdirectory 'scripts'.

NOTE THE FOLLOWING POINTS WELL:

-- These scripts provide a computer-assisted solution to the above
   two goals.  However, they are not perfect, and their output should
   be scanned by a human.  (To see what changes the two scripts
   *would* make, without making them, use the "-n" command line option.)

-- The scripts do not fix all instances that violate the above rules:
   some manual fixes are required.  Two further scripts are provided
   to help find remaining instances of function names without
   following "()": find_dots_no_parens.sh and find_slashes_no_parens.sh.

The following changes were made:

-- add_parens_for_own_funcs.sh was applied to the pages in Sections
   2 and 3.

-- unformat_parens.sh was applied to pages in Sections 2, 3, 4, and 7
   (the only sections where such changes were required).

-- further changes (not so very many) were performed by hand.
   (found places to fix with the assistance of find_dots_no_parens.sh
   and find_slashes_no_parens.sh).


==================== Changes in man-pages-2.11 ====================

Released: 2005-10-24

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain PORTAL <aportal@univ-montp2.fr>

Apologies if I missed anyone!

Global changes
--------------

Various pages
    mtk
        Most instances of the constant "NULL" are not formatted (bolded) in
        man pages, but a few are.  For consistency, formatting on "NULL" has
        been removed where it occurred.

        Many minor formatting fixes were made.

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

getrlimit.2
    mtk
        Added EINVAL error for rlim_cur > rlim_max when calling setrlimit().

path_resolution.2
    mtk
        Repaired discussion of capabilities and file system UID, which
        mistakenly had involved exec() in the discussion.

prctl.2
    mtk
        Removed text saying there is no library interface.  There
        is nowadays.

mkfifo.3
    mtk
        Minor change to RETURN VALUE text.

sk98lin.4
    Alain Portal
        Formatting fixes.

capabilities.7
    mtk
        Minor changes.


==================== Changes in man-pages-2.12 ====================

Released: 2005-10-31

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Akihiro MOTOKI <amotoki@dd.iij4u.or.jp>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Brian M. Carlson <sandals@crustytoothpaste.ath.cx>
herbert <herbert@gondor.apana.org.au>
Martin Landers <martin.landers@treibgut.net>
Michael Benedict <benedict@starbak.net>

Apologies if I missed anyone!

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

mlock.2
    mtk
        Reworded text around PAGESIZE, noting also that
        sysconf(_SC_PAGESIZE) can be used.

path_resolution.2
    mtk / aeb
        Removed words "as well" (added in 2.11) from the phrase
        "and it gets these last five capabilities if its fsuid is 0 as well"
        since there are (unusual) situations in which fsuid can be 0 while
        the effective UID is not.

        Reworked (cut down) discussion of capabilities, moving part of
        it into capabilities.7

setresuid.2
    mtk
        Add text to note that setresuid() always modifies the file
        system UID, and setresgid() likewise always modifies the file
        system GID.

shmget.2
    mtk
        Added (brief) description of SHM_HUGETLB.

sigaltstack.2
    mtk / Martin Landers
        Noted that ss_sp is automatically aligned by the kernel.

byteorder.3
    Brian M. Carlson  / herbert
        Change <netinet/in.h> to <arpa/inet.h> in prototype; add text
        explaining that some systems need the former header.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=265244

capabilities.7
    mtk
        Reworked part of the discussion of exec() and capabilities.
        Added sub-section "Effect of User ID Changes on Capabilities".
        Reworked discussion of CAP_SYS_ADMIN and file-max.


==================== Changes in man-pages-2.13 ====================

Released: 2005-11-03

This release consists entirely of formatting and typographical fixes.

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.

Various pages
    mtk
        Function and page cross references that were italicized were
        made bold (which is how the majority of function and page
        cross references were already done).

Various pages
    mtk
        Instances of things like "NULL-terminated string" were changed to
        "null-terminated string".

Various pages
    mtk
        Pathnames, structures, arguments, and <header-files> that were
        bold were changed to italics.

Various pages
    mtk
        Instances of the constant "NULL" that were bold-faced were made
        unformatted (which is how most instances of "NULL" were already
        formatted.)


==================== Changes in man-pages-2.14 ====================

Released: 2005-11-17

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Angelo <ang3l0@katamail.com>
Avery Pennarun <apenwarr@nit.ca>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Martin (Joey) Schulze <joey@infodrom.org>
Stefan Brüns <stefan.bruens@rwth-aachen.de>
Volker Reichelt <reichelt@igpm.rwth-aachen.de>

Apologies if I missed anyone!

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.

New pages
---------

rexec.3
    mtk / Justin Pryzby
        This page is taken as is from the FreeBSD 5.4 distribution.
        (Not checked against Linux reality, but likely things are
        the same.)
        See also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=336875

Changes to individual pages
---------------------------

arch_prctl.2
    mtk
        Updated discussion about lack of prototype in glibc.

execve.2
    mtk
        Improved description of E2BIG error: it relates to the sum
        of the bytes in both environment and argument list.

fcntl.2
    mtk
        Clarified parts of the discussion of file leases,
        noting effect of open(O_NONBLOCK), interruption
        by signal handler, or termination by signal in
        lease breaker.  In response to
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=339037

stat.2
    mtk / Stefan Brüns
        Added LINUX NOTES describing nanosecond timestamps.

frexp.3
    Volker Reichelt / mtk
        Fixed to point out that frexp() returns a number whose
        *absolute* value is >= 0.5 and < 1.  Amended the example
        program to demonstrate this.

open.2
    mtk / Avery Pennarun
        Add EWOULDBLOCK error for file leases.
        In response to
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=339037

putenv.3
    mtk
        Although the glibc implementation returns -1 on error (and some
        other man pages (e.g., the BSDs) also document that value for
        error returns), SUSv3 merely says "non-zero" (and this is
        what manual pages on many implementations also say).

posix_memalign.3
    mtk
        Formerly, the page said that all systems declare memalign() in
        <malloc.h>.  In fact, many declare it in <stdlib.h>.

strtok.3
    mtk
        Almost a complete rewrite after Angelo pointed out
        that the existing page was deficient.

sd.4
    Martin Schulze
        Remove SEE ALSO for nonexistent scsi.4.

proc.5
    mtk
        Updated discussion of /proc/sys/kernel/pid_max.

signal.7
    mtk
        Added pthreads.7 to SEE ALSO.

ld.so.8
    mtk
        Fix typo: s/LD_DEBUG_OUTPUT/LD_PROFILE_OUTPUT/


==================== Changes in man-pages-2.15 ====================

Released: 2005-11-30

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
James Vega <jamessan@debian.org>
Malcolm Scott <mas90@io.malc.org.uk>
Senthil Kumar <senthilkumar_sen@hotpop.com>

Apologies if I missed anyone!

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.

New pages
---------

sigvec.3 -- for details, see below.

sigset.3 -- for details, see below.

Changes to individual pages
---------------------------

kill.2
    mtk
        Added text describing the 2.6.[0-7] EPERM bug that occurred
        when sending signals to a process group.

sigaction.2
    mtk
        Noted that si_signo is unused on Linux.

sigpending.2
    mtk
        Added BUGS noting wrapper function problem that existed
        in glibc versions <= 2.2.1.

sigpause.2
    mtk
        Moved to section 3; see also sigpause.3 below.

sigsetops.3
    mtk
        Added a GLIBC NOTES section describing sigisemptyset(),
        sigandset(), and sigorset().

sigvec.2
sigblock.2
    mtk
        These pages have been deleted, and replaced by a new sigvec.3
        man page that more fully describes the BSD signal API.

siggetmask.2
sigmask.2
sigsetmask.2
    mtk
        These links to the now-deleted sigblock.2 have been also been
        deleted.  They are replaced by corresponding links in Section 3:
        sigmask.3, sigsetmask.3, siggetmask.3.

sigvec.3
    mtk
        This new page is provides a fuller description of the
        BSD signal API than was provided in the now-deleted sigvec.2
        and sigblock.2.

sigblock.3
siggetmask.3
sigmask.3
sigsetmask.3
    mtk
        Created as links to sigvec.3.

sigpause.3
    mtk
        Moved here from Section 2.

        Some minor wording fixes; clarified System V origins of
        X/Open flavor of this function.

sigset.3
    mtk
        New page describing the System V signal API: sigset(), sighold(),
        sigrelse(), sigignore().

strftime.3
    James Vega
        Add further text clarifying that %+ specifier is not supported in
        glibc2.
    mtk
        Added GLIBC NOTES section describing optional 'flag' and 'width'
        components of conversion specifiers.
        Some wording changes to bring terminology closer to SUSv3.
        Added an example program.

vm86old.2
    mtk / aeb
        Add as new link to vm86.2.

intro.7
    mtk
        Added a few words to reflect the fact that several of the section
        7 pages provide overviews of various topics.

signal.7
    mtk
        Added some SEE ALSO entries.

socket.7
    Senthil Kumar / mtk
        Added text noting that select()/poll() do not respect SO_RCVLOWAT.

udp.7
    Malcolm Scott
        s/tcp_socket/udp_socket/ in example
        Fixes http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=340927


==================== Changes in man-pages-2.16 ====================

Released: 2005-12-02

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alan Stern <stern@rowland.harvard.edu>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Urs Thuermann <urs@isnogud.escape.de>

Apologies if I missed anyone!

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

HOWTOHELP
    Urs Thuermann
        Added instructions for finding maintainer in Debian package.

poll.2
    mtk
        Added NOTES about INFTIM constant provided on some other
        implementations.

shmop.2
    Alan Stern
        The -1 error return of shmat() should be cast "(void *)".

strftime.3
    aeb
        Remove junk text (actually intended as source code comment
        in page).

ip.7
    Urs Thuermann
        Fix a typo: s/SOCK_RAW/SOCK_PACKET/

packet.7
    Urs Thuermann
        Clarification: s%SOCK_PACKET%PF_INET/SOCK_PACKET%


==================== Changes in man-pages-2.17 ====================

Released: 2005-12-13

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Justin Pryzby <justinpryzby@users.sourceforge.net>
Michael Haardt <michael@moria.de>
Urs Thuermann <urs@isnogud.escape.de>
Walter Harms <walter.harms@informatik.uni-oldenburg.de>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


New pages
---------

fmemopen.3
    Walter Harms / mtk
        New documentation for the glibc-specific fmemopen() and
        open_memstream().  Based on glibc info page.

pipe.7
    mtk (with prompting and suggestions for improvements by
    Michael Haardt)
        New page providing overview of pipes and FIFOs.


Changes to individual pages
---------------------------

HOWTOHELP
    mtk
        Added notes on how to write example programs for manual pages.

fork.2
    mtk
        Added pointers to examples of fork() in wait.2 and pipe.2.

pipe.2
    mtk
        Added an example program.
        Added SEE ALSO for new pipe.7 page.

wait.2
    mtk
        Added example program demonstrating use of fork() and waitpid().

carg.3
    Justin Pryzby
        Delete line that should have been deleted when applying
        2.08 fix for this page.

getaddrinfo.3
    mtk
        Rearranged EAI_* list alphabetically.

inet.3
    mtk
        Added GLIBC NOTES describing feature test macros required
        to expose declaration of inet_aton().

open_memstream.3
    mtk
        New link to new fmemopen.3.

fifo.4
    mtk
        Added SEE ALSO for new pipe.7 page.

environ.5
    mtk
        Removed BROWSER, since it seems not in fact to be common.

socket.7
    Urs Thuermann
        Added documentation of SO_TIMESTAMP.

tcp.7
    mtk
        Noted 200 millisecond ceiling imposed on TCP_CORK.

udp.7
    mtk
        Rearranged options into something approximating alphabetical order.


==================== Changes in man-pages-2.18 ====================

Released: 2005-12-15

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Justin Pryzby <justinpryzby@users.sf.net>
Karsten Sperling <karsten.sperling@stud.uni-karlsruhe.de>
Martin (Joey) Schulze <joey@infodrom.org>
Mike Frysinger <vapier@gentoo.org>
Stefan Puiu <stefanpuiuro@yahoo.com>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

bind.2
    mtk
        Added mention of AF_INET6 address family.
        Added discussion of sockaddr structure and an example in the
        Unix domain.

recv.2
    mtk
        Put 'flags' list in alphabetical order.

send.2
    mtk
        Added cross-reference from discussion of MSG_MORE to UDP_CORK
        in udp(7).

        Put 'flags' list in alphabetical order.

err.3
    mtk
        Added CONFORMING TO section noting that these are
        non-standard BSDisms.

errno.3
    Justin Pryzby
        Added SEE ALSO for err.3.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=306867

gethostbyname.3
    Martin (Joey) Schulze / mtk
        Added references to nsswitch.conf(5); remove cross references
        to resolv+(8).
        See also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=308397

perror.3
    Justin Pryzby
        Added SEE ALSO for err.3 .
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=306867

resolver.3
    mtk / Martin (Joey) Schulze
        Remove cross references to resolv+(8); add cross references to
        resolv.conf(5).
        See also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=214892

        Added SEE ALSO entry for resolver(5);
        see http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=251122

strerror.3
    mtk / Stefan Puiu
        Rewrote and extended the discussion of the two flavors of
        strerror_r(), and added some additional information on
        strerror().
    Justin Pryzby
        Added SEE ALSO for err.3, as per
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=306867


elf.5
    Mike Frysinger
        Fix three typos in identifier names.

operator.7
    Karsten Sperling
        The + operator should be in the list of unary operators.

raw.7
    mtk
        Small wording changes around discussion of SO_BSDCOMPAT.
        Fixed a couple of wording errors elsewhere.
        Reformatted some long lines.

socket.7
    mtk, after a note by Stefan Puiu
        Updated discussion of SO_BSDCOMPAT.

        Reformatted some long lines.

        Noted the Linux-specific feature whereby setsockopt() doubles
        the value given for SO_SNDBUF and SO_RCVBUF.

        Noted kernel-imposed minimum values for SO_SNDBUF and SO_RCVBUF.

udp.7
    mtk, after a note by Stefan Puiu
        Updated discussion of SO_BSDCOMPAT.

unix.7
    mtk
        Added new (UN)SUPPORTED FEATURES section in which it is noted
        that Unix domain sockets do not support MSG_OOB or MSG_MORE.

        Noted details of SO_SNBUF and SO_RCVBUF support for
        Unix domain sockets.


==================== Changes in man-pages-2.19 ====================

Released: 2005-12-23

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Walter Harms <walter.harms@informatik.uni-oldenburg.de>
Stefan Puiu <stefanpuiuro@yahoo.com>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

HOWTOHELP
    mtk
        Minor changes.

bind.2
    Stefan Puiu / mtk
        Remove text under EINVAL error: "This may change in the future:
        see linux/unix/sock.c for details."  This behavior has been
        unchanged for a long time, and seems unlikely to change.

        Add EADDRINUSE to errors.

send.2
    aeb
        Add cmsg(3) to SEE ALSO.

fopen.3
    Walter Harms / mtk
        Added description of 'x' mode character (exclusive open).

pipe.7
    mtk / aeb
        Some wording changes to description of pipes.


==================== Changes in man-pages-2.20 ====================

Released: 2006-01-03

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

sigaltstack.2
    mtk
        Added some text to explain the usual scenario in which
        sigaltstack() is employed.

getloadavg.3
    mtk
        Noted that this function is available since glibc 2.2.

strcpy.3
    mtk
        s/nulls/null bytes/

capabilities.7
    mtk
        Noted that capability bounding set appeared with kernel 2.2.11.

arp.7
icmp.7
ip.7
ipv6.7
netdevice.7
packet.7
raw.7
rtnetlink.7
socket.7
tcp.7
unix.7
udp.7
    mtk
        The only changes to these pages have been for formatting:
            -- Structure definitions were changed to K&R style
            -- Some long source lines were broken to fit into ~70
               character lines.
        No changes were made to the content of these pages (yet...).


==================== Changes in man-pages-2.21 ====================

Released: 2006-01-16

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Falk Hueffner <falk@debian.org>
Mike Frysinger <vapier@gentoo.org>
Senthil Kumar <senthilkumar_sen@hotpop.com>
Stefan Puiu <stefanpuiuro@yahoo.com>

Apologies if I missed anyone!


Global changes
--------------

dd.1 cp.1
truncate.2 gethostname.2 lseek.2 listxattr.2 readlink.2
sysfs.2 stat.2 ustat.2 uname.2 getdomainname.2
argz_add.3 asprintf.3 confstr.3 bstring.3 bzero.3 dlopen.3 fwide.3
gethostbyname.3 getline.3 getlogin.3 getnameinfo.3 getpass.3 hsearch.3
perror.3 printf.3 readdir.3 scanf.3 stpcpy.3 strdup.3 strfmon.3
strftime.3 string.3 strptime.3 sysconf.3 termios.3 ttyname.3
dsp56k.4 tty_ioctl.4
elf.5 proc.5 termcap.5
charsets.7 unix.7
    mtk
        Various pages use inconsistent terms for 'null byte' (which
        is the C99/SUSv3 term for the '\0' character).

        To rectify this the following changes were made in the above
        pages:

            Replace 'zero byte' with 'null byte'.
            Replace 'null character' with 'null byte'.
            Replace 'nulls' with 'null bytes'.
            Replace 'NUL-terminated' by 'null-terminated'.
            Replace 'NUL' by 'null byte'.
            Replace 'terminating NUL' by 'terminating null byte'.
            Replace 'final NUL' by 'terminating null byte'.
            Replace 'NUL character' by 'null byte'.

Various pages
    mtk
        Replace "SysV"/"SYSV" by "System V".

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

capget.2
    mtk
        Noted bug that could wrongly cause EPERM in unprivileged
        capset() with 'pid' field == getpid().

epoll_ctl.2
    mtk
        Noted that EPOLLONESHOT was added in 2.6.2.

gethostname.2
    mtk
        Added GLIBC NOTES describing operation of glibc's
        gethostname() wrapper function.

mmap.2
    mtk / Mike Frysinger
        Clarify relationship between mmap2(2) and mmap64(3).
    mtk
        A few other small rewordings.

mmap64.3
    Mike Frysinger
        New link to mmap.2.

open.2
    mtk
        Added BUG noting that O_ASYNC can't be enabled via
        open(): fcntl() must be used for this purpose.

recv.2
    Stefan Puiu
        Relocate misplaced discussion of MSG_DONTWAIT.

dlopen.3
    mtk
        Rewrote discussion of dlopen() 'flag' argument;
        added descriptions of RTLD_NOLOAD, RTLD_DELETE,
        and RTLD_DEEPBIND.

        Noted use of atexit() to register a function that is
        automatically called when a library is unloaded.

fmemopen.3
    mtk
        Rewrote substantial parts of the page, and relicensed under GPL.

fseeko.3
    Mike Frysinger
        Add RETURN VALUE section.

getopt.3
    mtk
        Noted historical use of <stdio.h> to declare getopt().

qsort.3
    mtk / Falk Hueffner
        Clarify how strcmp() should be used as the 'compar'
        function by providing an example.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=348072

proc.5
    mtk
        Noted that /proc/mounts is pollable since kernel 2.6.15.

        Documented /proc/PID/task.

        Noted that the contents of /proc/PID/{cwd,exe,fd,root,task}
        are not available if the main thread has terminated.

    Senthil Kumar
        Add pointer to random(4) for description of files under
        /proc/sys/kernel/random.

udp.7
    Stefan Puiu / mtk
        Small rewording of discussion of SO_BSDCOMPAT
        (add cross-ref to socket(7)).


==================== Changes in man-pages-2.22 ====================

Released: 2006-02-02

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andre Noll <maan@systemlinux.org>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Colin Tuckley <colin@tuckley.org>
Stefan Puiu <stefanpuiuro@yahoo.com>
Thomas Hood <jdthood@yahoo.co.uk>
Thorsten Kukuk <kukuk@suse.de>
Walter Harms <walter.harms@informatik.uni-oldenburg.de>


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.

Changes to individual pages
---------------------------

mmap.2
    aeb / mtk
        Noted that portable applications should specify fd as -1
        when using MAP_ANONYMOUS.
        Some rewriting of description of MAP_ANONYMOUS.

rt_sigreturn.2
    Thorsten Kukuk
        New link to sigreturn.2.

rt_sigsuspend.2
    mtk
        New link to sigsuspend.2.

waitid.2
    mtk
        Noted that waitid() does not set infop->si_uid field on
        most other implementations.

getopt.3
    Walter harms / mtk
        Make clear that when calling getopt_long() and there are no
        short options, then 'optstring' should be "", not NULL.

openpty.3
    Thomas Hood / mtk
        In glibc 2.0.92, openpty() was modified to preferably open
        Unix 98 ptys instead of BSD ptys.

qsort.3
    mtk
        Small rewording under EXAMPLES.

strtol.3
strtoul.3
    Stefan Puiu
        s/string must begin/string may begin/

proc.5
    mtk
        Documented inotify files under /proc/sys/fs/inotify:
        max_queued_events, max_user_instances, and max_user_watches.


==================== Changes in man-pages-2.23 ====================

Released: 2006-02-10

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <ak@muc.de>
Britton Leo Kerin <bkerin_rb@letterboxes.org>
Dan Jacobson <jidanni@jidanni.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Luc Van Oostenryck <lkml@looxix.net>
Kurt Wall <kwall@kurtwerks.com>
Martin (Joey) Schulze <joey@infodrom.org>
Matthias Andree <matthias.andree@gmx.de>
Robert Love <rlove@rlove.org>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Urs Thuermann <urs@isnogud.escape.de>

Apologies if I missed anyone!

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


New pages
---------

inotify_init.2
inotify_add_watch.2
inotify_rm_watch.2
    Robert Love, with some additions by mtk.
        New pages describing the inotify API.

mbind.2
get_mempolicy.2
set_mempolicy.2
    Andi Kleen, with additional work by mtk
        New pages describing the NUMA memory allocation policy API.
        Drawn from the set at ftp://ftp.suse.com/pub/people/ak/numa.

rtc.4
    Urs Thuermann, with additional work by mtk
        New page describing the real-time clock driver.

inotify.7
    mtk
        Overview of the inotify API.

Changes to individual pages
---------------------------

clone.2
    Andi Kleen
        On x86, clone() should not be called through vsyscall,
        but directly through "int $0x80".

fcntl.2
    mtk
        Small wording changes.

        Added cross-ref to inotify.7 under the description of dnotify.

kill.2
    mtk / Britton Leo Kerin
        Small wording change under NOTES to clarify
        what happens when a process sends a signal to itself.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=350236

mlock.2
    mtk / Matthias Andree
        Added BUGS txt on interaction between MCL_FUTURE and
        RLIMIT_MEMLOCK.
        See the following LKML thread:
        http://marc.theaimsgroup.com/?l=linux-kernel&m=113801392825023&w=2
        "Rationale for RLIMIT_MEMLOCK"

msgop.2
    mtk / Samuel Thibault
        Rewrote declaration of 'msgp' to be "void *" in response
        to http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=350884
        Various other wording fixes.

open.2
    mtk
        Clarify distinction between "file creation flags" and
        "file status flags".

read.2
    Justin Pryzby
        Add SEE ALSO for pread(2).
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=351873

sched_setaffinity.2
    mtk
        Major rewrite.

select.2
    mtk
        Added return types to prototypes for FD_SET(), FD_CLR(),
        FD_ZERO, and FD_ISSET().
        Other minor wording changes.

read.2
    mtk
        Add SEE ALSO for pwrite(2).
        (Analogous with read.2 change above.)

errno.3
    Kurt Wall / mtk
        Add Linux specific errors to this page.

localeconv.3
    mtk
        Added cross-ref to locale.7 for 'struct lconv' defn.
        Other minor wording changes.
    Martin (Joey) Schulze
        Added SEE ALSO refs for nl_langinfo.3
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=351831

scanf.3
    mtk / Justin Pryzby
        Minor formatting & wording fixes.

setlocale.3
    Martin (Joey) Schulze
        Added SEE ALSO refs for nl_langinfo.3
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=351831

proc.5
    mtk
        Migrated description of inotify files to the new inotify.7 page.

ascii.7
    Dan Jacobson / mtk
        Add text describing characters 001 to 037.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=342173

locale.7
    mtk
        Minor wording and formatting changes.


==================== Changes in man-pages-2.24 ====================

Released: 2006-02-17

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Joerg Habenicht <habenich@planetserver.com>
Luc Van Oostenryck <lkml@looxix.net>
Mike Frysinger <vapier@gentoo.org>
Samuel Thibault <samuel.thibault@ens-lyon.org>

Apologies if I missed anyone!


New pages
---------

get_kernel_syms.2
create_module.2
delete_module.2
init_module.2
query_module.2
    FSF / mtk (with assistance of Luc Van Oostenryck)
        man-pages finally gets pages for these system calls, several
        of which are obsolete in Linux 2.6.
        Took the old GPLed pages dated 1996 and made a number of
        clean-ups and minor additions.


Global changes
--------------

various pages
    mtk
        Change "file name" to "filename"
        Change "path name" to "pathname"

stpncpy.3
strstr.3
strcmp.3
toupper.3
strlen.3
stpcpy.3
puts.3
strdup.3
strtok.3
isalpha.3
strspn.3
gets.3
strpbrk.3
    mtk after a suggestion from Samuel Thibault
        Added SEE ALSO pointers to wide character equivalent functions
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=351996

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

clone.2
    mtk
        Remove duplicate CLONE_STOPPED text.
        Commented out crufty text describing EINVAL error
        for the now obsolete CLONE_DETACHED flag.
        Under CLONE_SIGHAND, noted that 'flags' must also include
        CLONE_VM if CLONE_SIGHAND is specified.

fcntl.2
    mtk
        Under ERRORS: Separate out EAGAIN error for locking mmaped files.

inotify_add_watch.2
    mtk
        Minor wording fix.

msgop.2
    mtk
        Documented the EAGAIN error for msgrcv().

fnmatch.3
    Mike Frysinger / mtk
        Expand explanation of FNM_PATHNAME.

lockf.3
    Joerg Habenicht / mtk
        Fix up discussion of EAGAIN/EACCESS errors.


==================== Changes in man-pages-2.25 ====================

Released: 2006-03-02

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

James Peach <jpeach@samba.org>
Krzysztof Benedyczak <golbi@mat.uni.torun.pl>
Marten von Gagern <Martin.vGagern@gmx.net>
Michael Haardt <michael@moria.de>
Michael Wronksi <michal.wronski@gmail.com>

Apologies if I missed anyone!


New pages
---------

mq_close.3
mq_getattr.3
mq_notify.3
mq_open.3
mq_receive.3
mq_send.3
mq_unlink.3
    mtk
        New pages describing POSIX message queue API.

posix_fallocate.3
    mtk, after a suggestion by James Peach
        New page describing posix_fallocate().

mq_overview.7
    mtk
        New page giving overview of the POSIX message queue API.


Changes to individual pages
---------------------------

lseek.2
    Michael Haardt
        Add a case to the EINVAL error text.
    mtk
        Various minor wording fixes
        Added SEE ALSO referring to new posix_fallocate.3.

posix_fadvise.2
    mtk
        Added "#define _XOPEN_SOURCE 600" to prototype.
        Added SEE ALSO referring to new posix_fallocate.3.

proc.5
    mtk
        Migrated information on POSIX message queues to new mqueue.7 page.

inotify.7
    Marten von Gagern
        Fix thinko: s/assuming a non-blocking/assuming a blocking/


==================== Changes in man-pages-2.26 ====================

Released: 2006-03-21

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andi Kleen <ak@muc.de>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Christoph Lameter <clameter@engr.sgi.com>
Hasso Tepper <hasso@estpak.ee>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Martin (Joey) Schulze <joey@infodrom.org>
Nicolas François <nicolas.francois@centraliens.net>
Paul Brook <paul@nowt.org>
Siward de Groot <siward@wanadoo.nl>
Steve Beattie <sbeattie@suse.de>
Walter Harms <walter.harms@informatik.uni-oldenburg.de>

Apologies if I missed anyone!

Global changes
--------------

clone.2
getdents.2
gettid.2
llseek.2
mmap2.2
modify_ldt.2
pivot_root.2
quotactl.2
readdir.2
sysctl.2
syslog.2
tkill.2
    mtk, aeb, Steve Beattie
        Added comment in SYNOPSIS to note that syscall(2) may be
        preferable over _syscallN (see intro(2)).

Various minor formatting changes were done on a range of
pages in Section 7.  (No content was changed.)

New pages
---------

openat.2
    mtk
        New page describing openat(2), added in kernel 2.6.16,
        and some notes on rationale for the at*(2) system calls.

mbind.2
    Andi Kleen, Christoph Lameter, mtk
        Added MPOL_MF_MOVE and MPOL_MF_MOVE_ALL descriptions,
        from numactl-0.9.2 man page.
        Plus a few other smaller fixes.

fexecve.3
    mtk
        New page describing fexecve(3).

futimes.3
    mtk
        New page describing futimes(3).

Changes to individual pages
---------------------------

execve.2
    mtk
        Added SEE ALSO pointing to new fexecve.3.

intro.2
    mtk, aeb, Steve Beattie
        Added some notes on syscall(2) versus _syscall.

msgctl.2
msgget.2
msgop.2
    mtk
        Added SEE ALSO pointing to mq_overview.7.

open.2
    mtk
        Added SEE ALSO pointing to new openat.2.

        Split out part of the RETURN VALUE text into separate
        NOTES section.

        Modified wording referring to raw(8) to
        indicate that this interface is deprecated.

poll.2
    mtk
        Added discussion of ppoll(2), which is new in 2.6.16.

ppoll.2
    mtk
        New link to poll.2.

recvmsg.2
sendmsg.2
    mtk / Paul Brook
        Added text to note that although POSIX says msg_controllen
        should be socklen_t, glibc actually uses size_t.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=356502
        and the associated glibc bug report.
        http://sourceware.org/bugzilla/show_bug.cgi?id=2448
    mtk
        Various formatting fixes.

select.2
    mtk
        Updated to reflect the fact that pselect() has been implemented
        in the kernel in 2.6.16; various other minor wording changes.

        pselect() prototype needs "#define _XOPEN_SOURCE 600".

tempnam.3
    Justin Pryzby
        Clean up description of EEXIST error.
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=357893

unlink.2
    mtk
        Added a little extra text to clarify EISDIR vs EPERM.

utime.2
    mtk
        Added new SEE ALSO entry pointing to new futimes.3 page.

exec.3
    mtk
        Added SEE ALSO pointing to new fexecve.3.

shm_unlink.3
    mtk
        New link to shm_open.3 (should have been made when page
        was originally written).

swab.3
    Walter Harms
        Add needed "#define _XOPEN_SOURCE".

undocumented.3
    mtk
        Updated to remove a few function names that are now documented.

capabilities.7
    mtk
        Various changes to bring this page closer to
        current kernel versions.

inotify.7
    mtk
        Noted that glibc 2.4 is required to get glibc support
        for inotify.

mq_overview.7
    mtk
        Some rewording and added a few words about System V
        message queues.

netlink.7
    Hasso Tepper
        Substantial updates to various parts of this page.
    mtk, Alain Portal
        Minor fixes

pthreads.7
    mtk
        Updated to reflect that the NPTL limitation that only the main
        thread could call setsid() and setpgid() was removed in 2.6.16.

raw.7
    Hasso Tepper
        Removed text implying that only in kernel 2.2 does IP_HDRINCL
        prevent datagrams from being fragmented.

socket.7
    mtk
        Documented SO_SNDBUFFORCE and SO_RCVBUFFORCE socket options,
        new in 2.6.14.

        Placed socket options in alphabetical order.


==================== Changes in man-pages-2.27 ====================

Released: 2006-03-24

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Charles P. Wright <cwright@cs.sunysb.edu>
Christoph Lameter <clameter@sgi.com>
Chuck Ebbert <76306.1226@compuserve.com>
Daniel Jacobowitz <dan@debian.org>
Ingo Molnar <mingo@elet.hu>
Heiko Carstens <heiko.carstens@de.ibm.com>
Janak Desai <janak@us.ibm.com>
Paolo (Blaisorblade) Giarrusso <blaisorblade@yahoo.it>
Stefan Puiu <stefanpuiuro@yahoo.com>

Apologies if I missed anyone!


Global changes
--------------

man7/*
    mtk
        Various minor formatting changes were done on a range of
        pages in Section 7.  (No content was changed.)


New pages
---------

unshare.2
    mtk, with reference to documentation by Janak Desai
        New page describing unshare(2), added in kernel 2.6.16.


Changes to individual pages
---------------------------

clone.2
fork.2
vfork.2
    mtk
        Added SEE ALSO pointing to new unshare.2.

mbind.2
    Christoph Lameter
        MPOL_MF_MOVE_ALL requires CAP_SYS_NICE not CAP_SYS_RESOURCE.

mremap.2
    mtk
        Clarified the description of MREMAP_FIXED and restructured
        the text to reflect the fact that this flag is exposed
        by glibc since version 2.4.

ptrace.2
    Chuck Ebbert, with assistance from Daniel Jacobowitz,
    Paolo (Blaisorblade) Giarrusso, and Charles P. Wright;
    after a suggestion from Heiko Carstens.
        Document the following ptrace requests:
            PTRACE_SETOPTIONS (2.4.6)
                plus associated flags:
                    PTRACE_O_TRACESYSGOOD (2.4.6)
                    PTRACE_O_TRACEFORK (2.5.46)
                    PTRACE_O_TRACEVFORK (2.5.46)
                    PTRACE_O_TRACECLONE (2.5.46)
                    PTRACE_O_TRACEEXEC (2.5.46)
                    PTRACE_O_TRACEVFORKDONE (2.5.60)
                    PTRACE_O_TRACEEXIT (2.5.60)
            PTRACE_SETSIGINFO (2.3.99-pre6)
            PTRACE_GETSIGINFO (2.3.99-pre6)
            PTRACE_GETEVENTMSG (2.5.46)
            PTRACE_SYSEMU (since Linux 2.6.14)
            PTRACE_SYSEMU_SINGLESTEP (since Linux 2.6.14)

sched_get_priority_max.2
sched_setscheduler.2
sched_setparam.2
    mtk, Ingo Molnar
        Modified to document SCHED_BATCH policy, new in kernel 2.6.16.

        Text describing SCHED_BATCH was added to sched_setscheduler.2,
        and was drawn in part from Ingo Molnar's description in the
        mail message containing the patch that implemented this policy.

        Various other minor rewordings and formatting fixes.

proc.5
    mtk, using text from Documentation/filesystems/proc.txt
        Document /proc/sys/vm/drop_caches, new in kernel 2.6.16.
    mtk, using information from ChangeLog-2.6.14.
        Document /proc/PID/smaps, new in kernel 2.6.14.

capabilities.7
    mtk
        Noted affect of CAP_SYS_NICE for mbind(MPOL_MF_MOVE_ALL).

pthreads.7
    mtk
        Kernel 2.6.16 eliminated buggy behavior with respect to
        the alternate signal stack.


==================== Changes in man-pages-2.28 ====================

Released: 2006-03-31

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Aleksandr Blokhin <sass@altlinux.ru>
Greg Johnson <gjohnson@lanl.gov>

Apologies if I missed anyone!


New pages
---------

sem_post.3
sem_getvalue.3
sem_close.3
sem_open.3
sem_destroy.3
sem_wait.3
sem_unlink.3
sem_init.3
sem_overview.7
    mtk
        New pages describing the POSIX semaphores API.

        These pages supersede and provide a superset of the information
        in the glibc (3thr) "semaphores(3)" manual page.


Changes to individual pages
---------------------------

ppoll.2
    Aleksandr Blokhin
        Fix broken link.

ptrace.2
    mtk
        Wrapped long lines (no content changes).

semctl.2
semget.2
semop.2
    mtk
        Add SEE ALSO pointing to the new sem_overview.7 page.

elf.5
    Greg Johnson
        Removed SEE ALSO reference to nonexistent core(5).


==================== Changes in man-pages-2.29 ====================

Released: 2006-04-06

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Michael Haardt <michael@moria.de>
Roberto Jimenoca <robertojimenoca@terra.es>
Stefan Puiu <stefanpuiuro@yahoo.com>

Apologies if I missed anyone!


Global changes
--------------

getrlimit.2
prctl.2
sigaction.2
elf.5
signal.7
    mtk
        Added SEE ALSO entry referring to new core.5 page.


New pages
---------

mkdirat.2
    mtk
        New page describing mkdirat(2), new in 2.6.16.

mknodat.2
    mtk
        New page describing mknodat(2), new in 2.6.16.

core.5
    mtk
        New page describing core dump files.

mkfifoat.3
    mtk
        New page describing mkfifoat(3).


Changes to individual pages
---------------------------

accept.2
getpeername.2
getsockname.2
    Michael Haardt / mtk
        Document EINVAL error for 'len' argument < 0.

fcntl.2
    mtk
        Expanded discussion of mandatory locking.

getrlimit.2
    mtk
        Added BUGS text on 2.6.x handling of RLIMIT_CPU limit
        of zero seconds.  See
        http://marc.theaimsgroup.com/?l=linux-kernel&m=112256338703880&w=2

mkdir.2
    mtk
        Added SEE ALSO entry referring to new mkdirat.2.

mknod.2
    mtk
        Added SEE ALSO entry referring to new mknodat.2.

open.2
    mtk / Roberto Jimenoca
        Clarified discussion of file types affected by O_NONBLOCK.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=360243

openat.2
    mtk
        Rewrote NOTES describing rationale for openat().
        Various other minor changes.

recv.2
    Stefan Puiu
        Removed a misleading cross-ref to socket.2.

shmop.2
    mtk
        Since 2.6.17-rc1, shmdt() gives the error EINVAL in a further
        circumstance: if shmaddr is not aligned on a page boundary.

unshare.2
    mtk
        Remove text saying that specifying invalid flags "is likely
        to cause compatibility problems" since the kernel now
        (2.6.17-rc1) contains an explicit check for invalid bits
        with a consequent EINVAL error.

mkfifo.3
    mtk
        Added SEE ALSO entry referring to new mkfifoat.3.

proc.5
    mtk
        Information on core_pattern and core_uses_pid has
        been migrated to the new core.5 page.

ip.7
    Stefan Puiu
        Removed paragraph referring to obsolete ipchains / ipfw(4).

sem_overview.7
    mtk
        Add SEE ALSO entry referring to pthreads.7.


==================== Changes in man-pages-2.30 ====================

Released: 2006-04-17

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andre Lehovich <andrel@yahoo.com>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Karel Kulhavy <clock@twibright.com>
Stefan Puiu <stefanpuiuro@yahoo.com>

Apologies if I missed anyone!


New pages
---------

linkat.2
    mtk
        New page describing linkat(), new in kernel 2.6.16

renameat.2
    mtk
        New page describing renameat(), new in kernel 2.6.16

symlinkat.2
    mtk
        New page describing symlinkat(), new in kernel 2.6.16

unlinkat.2
    mtk
        New page describing unlinkat(), new in kernel 2.6.16


Changes to individual pages
---------------------------

link.2
    mtk
        Added SEE ALSO entry pointing to new linkat.2 page.

openat.2
    mtk
        Added SEE ALSO entries pointing to new *at.2 pages.

rename.2
    mtk
        Added SEE ALSO entry pointing to new renameat.2 page.

rmdir.2
    mtk
        Added SEE ALSO entry pointing to new unlinkat.2 page.

symlink.2
    mtk
        Added SEE ALSO entry pointing to new symlinkat.2 page.

unlink.2
    mtk
        Added SEE ALSO entry pointing to new unlinkat.2 page.

termios.3
    mtk / Karel Kulhavy
        Document the feature test macros required to expose various flags.
    Karel Kulhavy
        Clarify 'speed' argument for cfsetispeed() text.
    Karel Kulhavy / mtk
        Note that LOBLK is not implemented on Linux.
    mtk
        Clarify arguments for cfsetspeed().
        Various formatting changes.

full.4
    Andre Lehovich
        Add a sentence describing the purpose of full(4).

core.5
    aeb / mtk
        Rework text describing circumstances in which
        core dump files are not produced.
    mtk / Stefan Puiu
        A core dump of a multithreaded process always includes the
        PID in the core filename.
    mtk / Stefan Puiu
        Eliminate some accidentally duplicated text.


==================== Changes in man-pages-2.31 ====================

Released: 2006-05-02

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Joshua Kwan <joshk@triplehelix.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Karel Kulhavy <clock@twibright.com>
Mark Glines <mark@glines.org>
Martin (Joey) Schulze <joey@infodrom.org>
Nishanth Aravamudan <nacc@us.ibm.com>
Reuben Thomas <rrt@sc3d.org>
Ryan S. Arnold <rsa@us.ibm.com>
Ulrich Drepper <drepper@redhat.com>

Apologies if I missed anyone!


Page renamings
--------------

The following pages have been relocated into section 7, since
that is their more natural home.  SEE ALSO references in various
other pages have been adjusted.

epoll.4
fifo.4
futex.4
complex.5
environ.5
        (many pages outside man-pages actually *expect*
        'environ' to be in Section 7.)

ipc.5
        renamed to svipc.7

".so" link files have been created to link the old file locations to the
new file locations.  These links are added just to ensure that cross
references from any other (non-man-pages) pages will remain valid;
eventually these links will be removed.


New pages
---------

fstatat.2
    mtk
        New page for fstatat(2), new in 2.6.16.

adjtime.3
    mtk
        New page for adjtime(3).

error.3
    Justin Pryzby / mtk
        New page describing error() and error_at_line()
        Fixes http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=186307

program_invocation_name.3
    mtk
        New page describing program_invocation_name and
        program_invocation_short_name variables.

sockatmark.3
    mtk
        New page for sockatmark(3).

ftm.7
    mtk
        New page describing feature test macros.

time.7
    mtk
        New page giving an overview of "time" on Linux systems.


Global changes
--------------

getgroups.2
wait4.2
chown.2
chdir.2
gettimeofday.2
initgroups.3
dirfd.3
    mtk
        Simplified wording around requirement for _BSD_SOURCE
        feature test macro.

times.2
time.2
gettimeofday.2
getitimer.2
nanosleep.2
ctime.3
rtc.4
    mtk
        Added SEE ALSO referring to new time.7.

err.3
errno.3
perror.3
strerror.3
    Justin Pryzby / mtk
        Add SEE ALSO referring to new error.3.

getdate.3
printf.3
scanf.3
    mtk
        Added SEE ALSO entry referring to setlocale.3.


Changes to individual pages
---------------------------

accept.2
    Mark Glines
        Remove mention of SOCK_RDM from this page, since this socket
        type does not support accept()ing connections.

adjtimex.2
    mtk
        Modified text referring to adjtime(); added SEE ALSO for new
        adjtime.3 page.

fsync.2
    mtk, after a note by Karel Kulhavy
        Rewrote most of the DESCRIPTION, as well as some other parts
        the page, to clarify use and operation of, and rationale for,
        fsync(2) and fdatasync(2).

getitimer.2
    mtk
        Updated discussion of maximum timer value to reflect the fact
        that the default jiffy is now 4 milliseconds.

        Added text to note that current incorrect behavior of
        normalizing tv_usec >= 1000000 will be repaired in a future
        kernel; applications should be fixed now.

gettimeofday.2
    Karel Kulhavy
        Point out more explicitly that 'tz' argument should
        normally be NULL.
    mtk
        Various other minor edits and formatting fixes.

mount.2
    mtk
        Since kernel 2.6.16, MS_NOATIME and MS_NODIRATIME are settable
        on a per-mount basis.
        Detail exactly which mount flags can be changed on MS_REMOUNT.

nanosleep.2
    mtk / Karel Kulhavy
        Clarify RETURN VALUE discussion.

openat.2
    mtk
        Add SEE ALSO reference pointing to new fstatat.2.

program_invocation_short_name.3
    mtk
        New link to new program_invocation_name.3.

recv.2
    mtk
        Added SEE ALSO for new sockatmark.3.

rmdir.2
    Joshua Kwan / Martin (Joey) Schulze / mtk
        Correct wording of EBUSY case.
    mtk
        Add ".." case to ENOTEMPTY error

select.2
    Karel Kulhavy
        Note more clearly that fd_set arguments can be NULL.
    mtk / Karel Kulhavy
        Improve opening paragraph describing purpose of select().
    mtk
        Various other minor edits and formatting fixes.

semget.2
    mtk / Nishanth Aravamudan
        Add text to noting that the initial values of semaphores
        in a new set are indeterminate.

shmget.2
    mtk
        Add text noting that contents of newly created segment are zero
        values.

sigwaitinfo.2
    mtk
        Noted that all threads should block signal being waited for.

stat.2
    Nishanth Aravamudan / mtk
        Added NOTE that st_size is always returned as zero for most
        /proc files.
    mtk
        Add SEE ALSO reference pointing to new fstatat.2.

syscall.2
    Justin Pryzby / mtk
        Remove bogus BUGS text.

utime.2
    mtk
        Various minor changes.

confstr.3
    mtk
        Rewrote RETURN VALUE discussion.
        Updated CONFORMING TO.
        Removed BUGS.

ctanh.3
    Martin (Joey) Schulze / mtk
        Fix errors in DESCRIPTION.

ctime.3
    mtk
        The range of tm_sec is 0..60 (not 0..61).

error_at_line.3
error_message_count.3
error_on_per_line.3
error_print_progname.3
    mtk
        New links to new error.3.

fmemopen.3
    mtk / Ryan S. Arnold
        Add text noting that explicitly controlling output buffering
        may be useful to catch errors on output operations on an
        fmemopen() stream.

getline.3
    Justin Pryzby
        Add SEE ALSO pointing to getline.3.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=364772

strtod.3
strtoul.3
    mtk
        Describe correct handling of errno in order to
        distinguish error from success after the call.

        Added EXAMPLE section which points to strtol.3 which provides
        an example of the use of the analogous strtol(3).

strtol.3
    mtk / Justin Pryzby
        Add an example program.
    mtk
        Describe correct handling or errno in order to
        distinguish error from success after the call.

tmpfile.3
    Reuben Thomas
        DESCRIPTION does not need to say "temporary file name"
        just "temporary file", since the name is in any case
        unavailable to the user.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=363518
    mtk
        In DESCRIPTION:
        Change /automatically deleted when the program terminates normally/
        to     /automatically deleted when the program terminates/
        since deletion occurs on both normal and abnormal termination.

ip.7
    Karel Kulhavy / mtk
        Various wording improvements and clarifications.

signal.7
    mtk / Ulrich Drepper
        Add text noting that a signal's disposition is process-wide,
        shared by all threads.
    mtk
        Add text on changing signal dispositions.
        Add text on "signal mask and pending signals".
        Other minor edits.

time.7
    mtk
        Added SEE ALSO for new adjtime.3.

ld.so.8
    Justin Pryzby
        Remove bogus duplicate line.


==================== Changes in man-pages-2.32 ====================

Released: 2006-05-13

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Johannes Weiner <root@hnaz.ath.cx>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Karel Kulhavy <clock@twibright.com>
Paul Brook <paul@nowt.org>
Pavel Heimlich <tropikhajma@seznam.cz>

Apologies if I missed anyone!


New pages
---------

faccessat.2
    mtk
        New page for faccessat(2), new in 2.6.16.

fchmodat.2
    mtk
        New page for fchmodat(2), new in 2.6.16.

fchownat.2
    mtk
        New page for fchownat(2), new in 2.6.16.

futimesat.2
    mtk
        New page for futimesat(2), new in 2.6.16.


Changes to individual pages
---------------------------

access.2
    mtk
        Add SEE ALSO reference pointing to new faccessat.2 page.

capget.2
    mtk
        Reworded to reflect that capabilities are per-thread.

chmod.2
    mtk
        Add SEE ALSO reference pointing to new fchmodat.2 page.

chown.2
    mtk
        Add SEE ALSO reference pointing to new fchownat.2 page.

mmap.2
    mtk
        Updated discussion of MAP_NORESERVE since it is no longer
        restricted to MAP_PRIVATE mappings.
        Add reference to discussion of /proc/sys/vm/overcommit_memory
        in proc.5.

openat.2
    mtk
        Add SEE ALSO reference pointing to new faccessat.2, fchmodat.2,
        fchownat.2, futimesat.2 pages.

shmget.2
    mtk
        Document SHM_NORESERVE flag, new in 2.6.15.

truncate.2
    Paul Brook / mtk
        Expand text noting that ftruncate()/truncate() may fail if
        asked to extend a file beyond its current length.
        Add EPERM error.

utime.2
    mtk
        Add SEE ALSO reference pointing to new futimesat.2 page.

fopen.3
    Justin Pryzby / mtk
        Document 'm' (mmap) flag.
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=365754
    mtk
        Document 'c' (notcancel) flag.

futimes.3
    mtk
        Add SEE ALSO reference pointing to new futimesat.2 page.

qsort.3
    Johannes Weiner
        Add missing "const" qualifies to cast in EXAMPLE.
    mtk
        Slight rewording of comments in EXAMPLE.

termios.3
    Karel Kulhavy
        Clarify meaning of IXANY.
        Clarify relationship of MIN with VMIN and TIME with VTIME.
    mtk
        Noted that CIBAUD, OFDEL, and DELECHO are not implemented
        on Linux.
        Added explanatory paragraph for phrases "not in POSIX" and
        "XSI".

capabilities.7
    mtk
        Reworded to reflect that capabilities are per-thread.
        Add ioprio_set() to list of operations permitted by
        CAP_SYS_NICE.
        Add ioprio_set() IOPRIO_CLASS_RT and IOPRIO_CLASS_IDLE
        scheduling classes to list of operations permitted by
        CAP_SYS_ADMIN.
        Note effects of CAP_SYS_NICE for migrate_pages().


==================== Changes in man-pages-2.33 ====================

Released: 2006-05-23

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Martin Osvald" <martin.osvald@gmail.com>
Stefan Puiu <stefanpuiuro@yahoo.com>

Apologies if I missed anyone!


Page renamings
--------------

ftm.7
    mtk / Stefan Puiu
        renamed to the more suggestive feature_test_macros.7


New pages
---------

mq_getsetattr.2
    mtk
        New page briefly describing mq_getsetattr(2), the system
        call that underlies mq_setattr(3) and mq_getattr(3).

rpmatch.3
    Justin Pryzby / mtk
        New page for rpmatch(3).


Changes to individual pages
---------------------------

chmod.2
    mtk
        Remove mention of non-standard S_IREAD, S_IWRITE, S_IEXEC.
        POSIX does now document ELOOP.

open.2
    mtk
        Remove mention of non-standard S_IREAD, S_IWRITE, S_IEXEC.

mmap.2
    Justin Pryzby
        Add mincore(2) to SEE ALSO.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=367401

msync.2
    Justin Pryzby
        Note that EINVAL can also be caused by
        flags == MS_SYNC | MS_ASYNC.

sched_setaffinity.2
    mtk
        Add CPU_ISSET, CPU_CLR, CPU_SET, CPU_ZERO to NAME section.

select.2
    mtk
        Various minor changes.

select_tut.2
    mtk
        Removed much material that is redundant with select.2.
        Various other changes.

umask.2
    mtk
        Substantial rewrite of description of 'mask'.

CPU_ISSET.3
CPU_CLR.3
CPU_SET.3
CPU_ZERO.3
    mtk
        New links to sched_setaffinity.2

FD_CLR.3
FD_ISSET.3
FD_SET.3
FD_ZERO.3
    mtk
        New links to select.2.

fts.3
    Justin Pryzby
        Add SEE also referring to ftw.3.

ftw.3
    Justin Pryzby
        Add SEE also referring to fts.3.

getline.3
    Justin Pryzby
        Various minor clarifications.

mkstemp.3
    mtk
        Clarify that O_EXCL is an open(2) flag.

mq_open.3
    Martin Osvald
        Fix prototype declaration for 'attr'.

mq_notify.3
    Martin Osvald
        s/sigev_signal/sigev_signo/

mq_setattr.3
    mtk
        New link to mq_getattr.3.

mq_timedreceive.3
    mtk
        New link to mq_receive.3.

mq_timedsend.3
    mtk
        New link to mq_send.3.

setlocale.3
    Justin Pryzby
        Added SEE ALSO referring to rpmatch.3.

sigandset.3
sigisemptyset.3
sigorset.3
    mtk
        New links to sigsetops.3.

stdio.3
    Justin Pryzby
        Added SEE ALSO referring to unlocked_stdio.3
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=367667

strchr.3
    Justin Pryzby
        Add description of strchrnul().

strchrnul.3
    mtk
        New link to strchr.3.

undocumented.3
    Justin Pryzby / mtk
        Updated to remove some functions that don't exist, and
        therefore don't need to be documented.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=367671

unlocked_stdio.3
    Justin Pryzby
        Added SEE ALSO referring to stdio.3
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=367667

mq_overview.7
    mtk
        Added section describing relationship between library
        interfaces and system calls.
        Added SEE ALSO referring to new mq_getsetattr.2.

feature_test_macros.7
    Stefan Puiu
        Fix typo: s/_POSIX_C_SOURCE/_POSIX_SOURCE/


==================== Changes in man-pages-2.34 ====================

Released: 2006-06-20

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
bert hubert <bert.hubert@netherlabs.nl>
Chris Curtis <chris.curtis@riptidesoftware.com>
Eduardo Madeira Fleury <efleury@br.ibm.com>
Joerg Scheurich <rusmufti@helpdesk.bera.rus.uni-stuttgart.de>
Justin Pryzby <justinpryzby@users.sf.net>
Kenichi Okuyama <okuyama.kenichi@oss.ntt.co.jp>
Marc Lehmann <debian-reportbug@plan9.de>
Martin (Joey) Schulze <joey@infodrom.org>
Mats Wichmann <mats.d.wichmann@intel.com>
Mike Frysinger <vapier@gentoo.org>
Peter Eiserloh <eiserlohpp@yahoo.com>
Stefan Puiu <stefanpuiuro@yahoo.com>
Thomas Dickey <dickey@radix.net>
Walter Harms <wharms@bfs.de>

Apologies if I missed anyone!


Global changes
--------------

tzselect.8
zdump.8
zic.8
    mtk, Joey
        Added header comment noting that these pages are in the public
        domain.

bindresvport.3
getrpcent.3
getrpcport.3
rpc.3
xdr.3
rpc.5
    mtk, aeb, Joey
        Added following to top of these pages to clarify origin and
        license:
        .\" This page was taken from the 4.4BSD-Lite CDROM (BSD license)

New pages
---------

ioprio_set.2
    Eduardo Madeira Fleury, with edits by mtk, and review by Jens Axboe
        New page for ioprio_get(2) and ioprio_set(2), new in 2.6.13.

offsetof.3
    Justin Pryzby / mtk
        New page describing offsetof() macro.


Changes to individual pages
---------------------------

_exit.2
    mtk
        Add SEE ALSO referring to exit_group.2.

acct.2
    mtk
        Add SEE ALSO referring to acct.5.

fcntl.2
    mtk
        Explicitly mention term "dnotify" in discussion of F_NOTIFY.

inotify_add_watch.2
    Aristeu Sergio Rozanski Filho / mtk
        s/<inotify.h>/<sys/inotify.h>/ in prototypes.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=369960
    mtk
        Renamed argument from 'path' to 'pathname'.
        Reword introductory paragraph to clarify that
        inotify_add_watch() may also modify an existing watch item.
    mtk
        The EINVAL error can also occur if 'fd' is not an inotify
        file descriptor.
    mtk
        Moved BUGS section from this page to inotify.7.

inotify_init.2
    Aristeu Sergio Rozanski Filho / mtk
        s/<inotify.h>/<sys/inotify.h>/ in prototypes.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=369960

inotify_rm_watch.2
    Aristeu Sergio Rozanski Filho / mtk
        s/<inotify.h>/<sys/inotify.h>/ in prototypes.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=369960
    mtk
        The EINVAL error can also occur if 'fd' is not an inotify
        file descriptor.

ioprio_get.2
    mtk
        New link to new ioprio_set.2.

mmap.2
    mtk
        Add SEE ALSO referring to remap_file_pages.2.

mount.2
    Kenichi Okuyama
        s/MNT_FORCE/MNT_EXPIRE/ under EINVAL error.

mremap.2
    Mike Frysinger
        s/unsigned long flags/int flags/ in SYNOPSIS.

pipe.2
    mtk
        Add SEE ALSO referring to popen.3.

posix_fadvise.2
    mtk
        Add SEE ALSO referring to readahead.2.

read.2
    mtk
        SEE ALSO for readv should refer to Section 2, not 3.

readahead.2
    mtk
        Add SEE ALSO referring to posix_fadvise.2.

send.2
    Peter Eiserloh
        Fix missing arguments in statement about equivalent send()
        and sendto() calls.

setsid.2
    mtk
        Add SEE ALSO referring to tcgetsid.3.

shmctl.2
    mtk
        Minor wording change at start of DESCRIPTION.

stat.2
    mtk
        Add SEE ALSO referring to access.2.

statfs.2
    mtk
        Relocated "Note" about f_fsid.

write.2
    mtk
        SEE ALSO for writev should refer to Section 2, not 3.

__setfpucw.3
    mtk, Joey
        Added license statement (GPL) after consultation with
        Joerg Scheurich.

assert_perror.3
    Justin Pryzby
        Add #define _GNU_SOURCE to prototype

difftime.3
    Joey
        Added note about time_t representation on other systems.
        Added CONFORMING TO.

ftw.3
    Justin Pryzby / mtk
        A fairly major revision...
        Document FTW_ACTIONRETVAL; include .SH "RETURN VALUE";
        Reorganized and rewrote much of the page
        Added an example program.

inet.3
    Marc Lehmann
        Fixed typo in NOTES.
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=370277

isalpha.3
    Joey
        Updated CONFORMING TO.

mktemp.3
    mtk
        Updated CONFORMING TO.

printf.3
    Walter Harms
        Add documentation of %m.

readdir.3
    mtk
        Added SEE ALSO referring to ftw.3.

re_comp.3
    mtk
        Note that these functions are obsolete in favor of regcomp(3).
    Justin Pryzby
        Add SEE ALSO referring to regcomp.3

scandir.3
    Mats Wichmann
        Reworded CONFORMING TO statement on scandir() and alphasort().

strchr.3
    Stefan Puiu
        Fix prototype for strchrnul().

strtoul.3
    Stefan Puiu
        Add text clarifying treatment of strings starting with
        minus sign.

tmpnam.3
    mtk, after comments by Justin Pryzby
        Add text noting the need to use open(O_EXCL).
    mtk
        Clarify discussion of use of free(3).
        Various other minor changes to text and formatting.

tmpfile.3
    mtk
        Updated CONFORMING TO.

tmpnam.3
    mtk, after comments by Justin Pryzby
        Add text noting the need to use open(O_EXCL).
        Updated CONFORMING TO.

undocumented.3
    mtk
        Remove offsetof(), which is now documented.

null.4
    mtk
        Added SEE ALSO referring to full.4.

console_codes.4
    Thomas Dickey
        Various improvements and corrections.

epoll.7
    mtk
        Added CONFORMING TO section mentioning FreeBSD kqueue and
        Solaris /dev/poll.

feature_test_macros.7
    mtk
        Added pointer to location of LFS specification.

futex.7
    mtk, after suggestion by Joey.
        Added license statement to page, after discussion with
        original author, bert hubert.
    mtk
        Reformat long lines; no content changes.

inotify.7
    mtk
        'path' argument renamed to 'pathname'.
        A few minor rewordings.
        Added BUGS section describing a couple of bugs.

ip.7
    mtk
        Add SEE ALSO referring to byteorder.3.

man.7
    Justin Pryzby
        Add SEE ALSO referring to groff_man(7).
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=369253


==================== Changes in man-pages-2.35 ====================

Released: 2006-07-06

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andi Kleen <ak@suse.de>
Andrew Morton <akpm@osdl.org>
Bauke Jan Douma <bjdouma@xs4all.nl>
Davide Libenzi <davidel@xmailserver.org>
Denis Barbier <barbier@linuxfr.org>
Horacio Rodriguez Montero <Horacio.Rodriguez.Montero@galinter.com.ar>
Johan Lithander <johan.lithander@teligent.se>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Mike Frysinger <vapier@gentoo.org>
Stefan Puiu <stefanpuiuro@yahoo.com>
Thorsten Kukuk <kukuk@suse.de>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.

New pages
---------

sync_file_range.2
    Andrew Morton / mtk
        New page for sync_file_range(2), new in kernel 2.6.17.

Changes to individual pages
---------------------------

adjtime.3
    mtk
        Noted BUG that occurs if 'delta' is specified as NULL.
        See http://bugzilla.kernel.org/show_bug.cgi?id=6761

bind.2
    Stefan Puiu
        Add EADDRNOTAVAIL error.
    Stefan Puiu / mtk
        Make example code more complete.

epoll_ctl.2
    mtk / Davide Libenzi
        Added EPOLLRDHUP description.
    mtk
        Added SEE ALSO referring to poll.2.

poll.2
    mtk / Davide Libenzi
        Added POLLRDHUP description.
    mtk
        The correct header file is <poll.h>, not <sys/poll.h>.
        Rewrote and reformatted various other parts.

readlink.2
    mtk
        Nowadays, readlink() returns 'ssize_t', as required in
        POSIX.1-2001.

wavelan.4
    mtk
        Added license statement.

nscd.conf.5
    Thorsten Kukuk
        Add documentation for various new fields.

passwd.5
    Horacio Rodriguez Montero
        Add explanation of 'x' character in 'password' field.
    mtk
        The proper name of "*" is "asterisk" not "star".

tcp.7
    Johan Lithander
        Update RFC reference for ECN.
    Andi Kleen
        Add sentence on "low memory" limit for tcp_mem on 32-bit systems.


==================== Changes in man-pages-2.36 ====================

Released: 2006-07-11

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Jens Axboe <jans@suse.de>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Kyle McMartin <kyle@mcmartin.ca>

Apologies if I missed anyone!

Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.

New pages
---------

MAINTAINING
    mtk
        How to maintain man-pages.

TODO
    mtk
        Things that it would be nice to get done for man-pages one day.

scripts/FIXME_list.sh
    mtk
        This script, intended for use by manual page maintainers,
        displays the FIXMEs in the manual page source files.

Changes to individual pages
---------------------------

fdatasync.2
fsync.2
    mtk
        Added SEE ALSO referring to sync_file_range.2.

sendfile.2
    mtk / Jens Axboe
        Fix description of 'offset' argument to explain the case
        where 'offset' is NULL.

ferror.3
    Justin Pryzby
        Add SEE ALSO referring to fdopen.3.

intro.3
    mtk
        Removed information about Section 3 subsections -- it doesn't
        reflect current reality, and probably never has.

        Added SEE ALSO referring to intro.2.

tcp.7
    Kyle McMartin
        Correction: tcp_window_scaling is ENabled by default.


==================== Changes in man-pages-2.37 ====================

Released: 2006-08-02

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Dean Gaudet <dean@arctic.org>
Frank van Viegen <F.C.vanViegen@UTwente.nl>
Helmut Grohne <helmut@subdivi.de>
Ivana Varekova <varekova@redhat.com>
Thomas Huriaux <thomas.huriaux@gmail.com>
Ville Skyttä <ville.skytta@iki.fi>

Apologies if I missed anyone!

Global changes
--------------

Thomas Huriaux / mtk

        Various formatting problems found as a result of reviewing the
        following command were fixed.

        for a in  $(wc -l man?/*.?| awk '$1 > 2 {print $2}' | grep -v total); do
            echo $a; groff -Tascii -wmac -mman $a > /dev/null;
        done 2>&1 | less

        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=378544

Typographical or grammatical errors have been corrected in several
places.

New pages
---------

readlinkat.2
    mtk (after prompting from Ivana Varekova)
        New page for readlinkat(2), new in kernel 2.6.16.

Changes to individual pages
---------------------------

ldd.1
    Ville Skyttä
        Document "-u" option.

chdir.2
    mtk
        Noted effect of fork() and execve() on current working directory.

chroot.2
    mtk
        Noted effect of fork() and execve() on root directory.

epoll_ctl.2
    Frank van Viegen / mtk
        Fix description of EBADF error.

exevce.2
    mtk
        Add text noting that effective IDs are copied to
        saved set-IDs during execve().
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=379297

getitimer.2
    mtk
        Noted effect of fork() and execve() on interval timers.

getrlimit.2
    mtk
        Noted effect of fork() and execve() on resource limits.

getpriority.2
    mtk
        Noted effect of fork() and execve().

inotify_add_watch.2
    mtk
        Some rewording; included text describing required file
        permissions.

intro.2
    mtk
        Revised description of standards under CONFORMING TO.

makecontext.3
    Helmut Grohne / mtk
        Point out that args following 'argc' are int.
    mtk
        Added an example program.
        Various minor wording fixes.

mmap.2
    mtk
        Expand description of MAP_POPULATE.
    mtk, after prompting by Dean Gaudet
        Expand description MAP_NONBLOCK.
    mtk
        Various minor formatting fixes.

openat.2
    mtk
        Added SEE ALSO linking to readlinkat.2.

nanosleep.2
    mtk
        Noted buggy behavior in Linux 2.4 and earlier when
        nanosleep() is restarted after receiving stop+SIGCONT signals.

nice.2
    mtk
        Very minor rewording.

readlink.2
    mtk
        Added SEE ALSO linking to readlinkat.2.

sched_setscheduler.2
    mtk
        Noted preservation of scheduling parameters across execve().

setpgid.2
    mtk
        Noted effect of fork() and execve() on process group ID.

setsid.2
    mtk
        Noted effect of fork() and execve() on session ID.

umask.2
    mtk
        Noted effect of fork() and execve() on umask.

atexit.3
    mtk
        Noted inheritance of registrations across fork().

capabilities.7
    mtk
        Added material on privileges required for move_pages().
        CLONE_NEWNS needs CAP_SYS_ADMIN.
        keyctl(KEYCTL_CHOWN) and keyctl(KEYCTL_SETPERM) require
        CAP_SYS_ADMIN.


==================== Changes in man-pages-2.38 ====================

Released: 2006-08-03

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>

Apologies if I missed anyone!

Global changes
--------------

Most pages
    mtk
        There was a major reworking of the CONFORMING TO sections
        in most manual pages.

        * generally try to rationalize the names used for standards.
          The preferred names are now documented as the head words
          of the list in standards(7).  For the future: there is
          probably no need to talk about anything more than
          C89, C99, POSIX.1-2001 (or later), xBSD, and SVr4.
          (In particular, I've eliminated most references to XPG
          and SVID, replacing them with references to SUS or SVr4.)

        * eliminate discussion of errors that can occur on other
          systems.  This information exists only patchily in the
          manual pages, is probably of limited use, is hard to maintain,
          and was in some cases simply wrong (and probably always was).

        * Tried to ensure that those interfaces specified in C99 or
          POSIX.1-2001 are marked as such in their manual pages.

intro.1
intro.2
intro.3
intro.4
intro.5
intro.7
feature_test_macros.7
    mtk
        Added SEE ALSO referring to new standards.7.

Various pages
    mtk
        Changed instances of "HP UX" to "HP-UX".

Various pages
    mtk
        Changed instances of "DG-UX to "DG/UX"

Typographical or grammatical errors have been corrected in several
places.

New pages
---------

standards.7
    mtk
        Based on material taken from intro.2, but expanded to
        include discussion of many additional standards.

Changes to individual pages
---------------------------

bind.2
    mtk
        Minor wording change for ENOTSOCK error.

intro.2
    mtk
        Removed information on standards to new standards.7.


==================== Changes in man-pages-2.39 ====================

Released: 2006-08-05

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>

Apologies if I missed anyone!

Global changes
--------------

Various pages
    mtk
        Updated CONFORMING TO and/or standards references
        in various pages that were missed for 2.38.

Typographical or grammatical errors have been corrected in several
places.

Changes to individual pages
---------------------------


chdir.2
    mtk
        _XOPEN_SOURCE=500 also gets fchdir() prototype.

standards.7
    mtk
        Added a few more standards, and expand some explanations.


==================== Changes in man-pages-2.40 ====================

Released: 2006-09-04

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andi Kleen <ak@suse.de>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Christoph Hellwig <hch@lst.de>
Chuck Ebbert <76306.1226@compuserve.com>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Toralf Förster <toralf.foerster@gmx.de>

Apologies if I missed anyone!

Global changes
--------------

faccessat.2
fchmodat.2
fchownat.2
fstatat.2
futimesat.2
linkat.2
mkdirat.2
mknodat.2
openat.2
readlinkat.2
renameat.2
symlinkat.2
    mtk (after a note by Alain Portal)
        Make naming of 'pathname' argument consistent; various
        minor rewordings.

Typographical or grammatical errors have been corrected in several
places.

Changes to individual pages
---------------------------

clone.2
    mtk
        Reinstate text on CLONE_DETACHED, and add a few words.

execve.2
    mtk
        Added list of process attributes that are not preserved on exec().

fork.2
    mtk, after a suggestion by Christoph Hellwig
        Greatly expanded, to describe all attributes that differ
        in parent and child.

linkat.2
    mtk
        Document AT_SYMLINK_FOLLOW (new in 2.6.18).

set_mempolicy.2
    mtk / Andi Kleen
        Memory policy is preserved across execve().

write.2
    mtk / Alain Portal
        SEE ALSO for writev should refer to Section 2, not 3.
        (i.e., really make the change that was logged in 2.34)

getcwd.3
    Samuel Thibault / mtk
        Fix SYNOPSIS and CONFORMING TO text for getwd() and
        get_current_dir().
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=381692

proc.5
    Chuck Ebbert
        Document /proc/PID/auxv.

capabilities.7
    Alain Portal
        Restore text accidentally deleted in 2.39.

regex.7
    mtk / Alain Portal
        Change references to "1003.2" to "POSIX.2".


==================== Changes in man-pages-2.41 ====================

Released: 2006-10-12

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <ak@suse.de>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Andrew Morton <akpm@osdl.org>
Britton Leo Kerin <bkerin_rb@letterboxes.org>
Dan Jacobson <jidanni@jidanni.org>
Guillem Jover <guillem@hadrons.org>
Hrvoje Niksic <hniksic@xemacs.org>
Jens Axboe <axboe@suse.de>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Kevin Ryde <user42@zip.com.au>
Marcel Holtmann <marcel@holtmann.org>
Senthil Kumar <senthilkumar_sen@hotpop.com>
Stefan Puiu <stefanpuiuro@yahoo.com>
Stuart MacDonald <stuartm@connecttech.com>
Trond Myklebust <trond.myklebust@fys.uio.no>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


New pages
---------

splice.2
tee.2
vmsplice.2
    Jens Axboe / Michael Kerrisk
        See also:
            http://lwn.net/Articles/118760/
            http://lwn.net/Articles/178199/
            http://lwn.net/Articles/179492/
            http://kerneltrap.org/node/6505
            http://lwn.net/Articles/179434/

Changes to individual pages
---------------------------

ldd.1
    Stefan Puiu
        Note glibc version where "ldd -u" appeared.

execve.2
    mtk
        The PR_SET_NAME setting is not preserved across an execve().

fork.2
    mtk
        Mappings marked with madvise(MADV_DONTFORK) are not inherited
        by child.

getdtablesize.2
    mtk
        Noted that sysconf(_SC_OPEN_MAX) is preferred in portable
        applications.

getpagesize.2
    mtk
        Noted that sysconf(_SC_PAGE_SIZE) is preferred in portable
        applications.
        _SC_PAGE_SIZE is available on most systems.

madvise.2
    mtk
        Document MADV_REMOVE, new in 2.6.16.
        Document MADV_DONTFORK / MADV_DOFORK, new in 2.6.16.

mount.2
    mtk / Trond Myklebust
        MNT_FORCE can cause data loss.

mmap.2
    mtk
        Added note on Linux's old (pre-2.6.12) buggy treatment of
        length==0.
    Justin Pryzby / mtk
        Added some EINVAL errors.

mremap.2
    mtk
        Remove superfluous "#include <unistd.h>" from SYNOPSIS.

msync.2
    mtk
        Added EBUSY error for case where MS_INVALIDATE is applied to
        a locked region.

posix_fadvise.2
    Andrew Morton
        Since 2.6.18, POSIX_FADV_NOREUSE is a no-op.

prctl.2
    Marcel Holtmann / mtk
        Since kernel 2.6.18, setting 2 for PR_SET_DUMPABLE is no longer
        possible.
    Guillem Jover
        Updated Linux versions where the options where introduced.
        Added PR_SET_TIMING, PR_GET_TIMING, PR_SET_NAME, PR_GET_NAME,
        PR_SET_UNALIGN, PR_GET_UNALIGN, PR_SET_FPEMU, PR_GET_FPEMU,
        PR_SET_FPEXC, PR_GET_FPEXC.
    Michael Kerrisk
        Document PR_GET_ENDIAN and PR_SET_ENDIAN.

remap_file_pages.2
    mtk
        Add "#define _GNU_SOURCE" to SYNOPSIS.

sync_file_range.2
    mtk
        Noted that sync_file_range() appeared in kernel 2.6.17.

vfork.2
    mtk
        Noted interactions with fork handlers in multithreaded programs.

wait4.2
    mtk
        Added feature test macros to SYNOPSIS.

clog2.3
    mtk / aeb / Kevin Ryde
        Fix broken text in description.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=386214

clog10.3
    Kevin Ryde
        Fix broken text in description.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=386214

mq_receive.3
    Britton Leo Kerin
        Fix return type in SYNOPSIS; should be "ssize_t" not "mqd_t".
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=387551

qsort.2
    Hrvoje Niksic
        Fix wording referring to the use of strcmp() in 'compar'
        function.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=391402

sendfile.2
    mtk
        Added SEE ALSO referring to new splice.2 page.

termios.3
    mtk
        Documented IUTF8 (which was new in kernel 2.6.4).

tzset.3
    mtk
        Added some TZ examples.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=386087

proc.5
    mtk
        Added delayacct_blkio_ticks (new in 2.6.18) to /proc/PID/statm.

ip.7
    Stuart MacDonald / Andi Kleen
        Fix discussion for TCP error queue /IP_RECVERR on TCP.

pthreads.7
    mtk
        Noted effect of RLIMIT_STACK resource limit for NPTL.

socket.7
    Senthil Kumar
        Place socket options in alphabetical order.


==================== Changes in man-pages-2.42 ====================

Released: 2006-11-24

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andrew Morton <akpm@osdl.org>
Chuck Ebbert <76306.1226@compuserve.com>
Doug Goldstein <cardoe@gentoo.org>
Eduard Bloch <blade@debian.org>
Evan Teran <eteran@alum.rit.edu>
Pavel Heimlich <tropikhajma@seznam.cz>
Petr Baudis <pasky@ucw.cz>
Randy Dunlap <rdunlap@xenotime.net>
Ulrich Drepper <drepper@redhat.com>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

brk.2
    Evan Teran / mtk
        Add text describing behavior of the Linux brk() system call
        and point out that the glibc brk() wrapper provides different
        behavior.
    mtk
        Note that sbrk() is implemented as a library function in glibc
        that calls the brk() system call.

futex.2
    mtk
        FUTEX_FD is scheduled for removal in June 2007.

getaddrinfo.3
getnameinfo.3
    Ulrich Drepper, with edits by mtk
        Add text describing Internationalized Domain Name
        extensions.

open.2
    mtk / Eduard Bloch
        Fix description of O_LARGEFILE to mention required feature test
        macros.

ptrace.2
    Chuck Ebbert
        Since Linux 2.6.18, the PID of the new process is also available
        for PTRACE_EVENT_VFORKDONE.

syslog.3
    Doug Goldstein
        Fix header file required for vsyslog() in SYNOPSIS.

wcwidth.3
    Petr Baudis
        Fix CONFORMING TO.

core.5
    mtk
        Linux 2.4.21 added core_pattern (which was already in 2.6).
        Noted a few more reasons why a core dump file might not
        be produced.


==================== Changes in man-pages-2.43 ====================

Released: 2006-11-29

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <ak@suse.de>
David Brownell <david-b@pacbell.net>
Eduard Bloch <blade@debian.org>
Egmont Koblinger <egmont@uhulinux.hu>
Reuben Thomas <rrt@sc3d.org>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

ioperm.2
    mtk
        Clarify discussion of privilege requirements.
        Added ENOMEM to ERRORS.

open.2
    mtk / Eduard Bloch
        Clarify description of O_LARGEFILE.

crypt.3
    Egmont Koblinger
        Make description of MD5 output string less ambiguous.

strerror.3
    Reuben Thomas
        Add C99 to CONFORMING TO; see
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=400634

rtc.4
    David Brownell

        Update the RTC man page to reflect the new RTC class framework:

        - Generalize ... it's not just for PC/AT style RTCs, and there
          may be more than one RTC per system.

        - Not all RTCs expose the same feature set as PC/AT ones; most
          of these ioctls will be rejected by some RTCs.

        - Be explicit about when {A,P}IE_{ON,OFF} calls are needed.

        - Describe the parameter to the get/set epoch request; correct
          the description of the get/set frequency parameter.

        - Document RTC_WKALM_{RD,SET}, which don't need AIE_{ON,OFF} and
          which support longer alarm periods.

        - Hey, not all system clock implementations count timer irqs any
          more now that the new RT-derived clock support is merging.

proc.5
    mtk
        s/fseek(3)/lseek(2)/ under /proc/PID/mem entry.

feature_test_macros.7
    mtk / Eduard Bloch
        The LFS spec is now at http://opengroup.org/platform/lfs.html

raw.7
udp.7
    Andi Kleen
        Describe the correct default for UDP/RAW path MTU discovery.


==================== Changes in man-pages-2.44 ====================

Released: 2007-04-04

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andre Majorel <aym-naideb@teaser.fr>
Benjamin Gilbert <bgilbert@cs.cmu.edu>
Carlo Marcelo Arenas Belon <carenas@sajinet.com.pe>
Chuck Ebbert <76306.1226@compuserve.com>
Ivana Varekova <varekova@redhat.com>
Jakub Jelinek <jakub@redhat.com>
John Ward <jward@idealcorp.com>
Jorge Peixoto de Morais Neto <jorgepeixotomorais@gmail.com>
Julien Blache <jblache@debian.org>
Julien Cristau <jcristau@debian.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Martín Ferrari <martin.ferrari@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Nick Piggin <npiggin@suse.de>
Nick Pollitt <npollitt@mvista.com>
Nicolas François <nicolas.francois@centraliens.net>
Pádraig Brady <P@draigBrady.com>
Premysl Hruby <dfenze@gmail.com>
Reuben Thomas <rrt@sc3d.org>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Serge E. Hallyn <serge@hallyn.com>
Thomas Huriaux <thomas.huriaux@gmail.com>
Timo Sirainen <tss@iki.fi>
Val Henson <val_henson@linux.intel.com>

Apologies if I missed anyone!


New pages
---------

termio.7
    mtk, after a bit of prodding by Reuben Thomas
        A brief discussion of the old System V termio interface,
        with pointers to pages that will contain the information
        that the reader probably wants.

scripts/find_repeated_words.sh
    mtk
        Find consecutive duplicate words in a man page, some of
        which may be grammar errors.

Global changes
--------------

Various pages
    Justin Pryzby / mtk
        Add "#define _ATFILE_SOURCE" to SYNOPSIS in following pages:
            faccessat.2
            fchmodat.2
            fchownat.2
            fstatat.2
            futimesat.2
            linkat.2
            mkdirat.2
            mknodat.2
            openat.2
            readlinkat.2
            renameat.2
            symlinkat.2
            unlinkat.2
            mkfifoat.3

Various pages
    mtk
        Various references to "getty" were changed to "mingetty", since
        that is the manual page more likely to be found on current systems.

Various pages
    mtk, after a suggestion by Reuben Thomas <rrt@sc3d.org>
        Updated various header pages to accurately reflect which functions
        are and are not part of C89.  Also fixed/improved a few other
        CONFORMING TO entries.

Various pages
    mtk
        s/Unices/Unix systems/ on the 5 pages where it appears.

Various pages
    mtk
        Wrapped long source lines in the following files
            getsockopt.2
            mknodat.2
            io_setup.2
            select_tut.2
            select.2
            readlinkat.2
            io_cancel.2
            syslog.2
            wcsncat.3
            getipnodebyname.3
            cmsg.3
            wcpncpy.3
            wcsrtombs.3
            wcstok.3
            fgetwc.3
            wmemcmp.3
            wcsspn.3
            div.3
            modf.3
            stdio_ext.3
            ctermid.3
            des_crypt.3
            wcsncmp.3
            wmemchr.3
            wcsstr.3
            wmemcpy.3
            wprintf.3
            wcsnrtombs.3
            termios.3
            erf.3
            ceil.3
            lround.3
            nextafter.3
            wcsncpy.3
            wmemset.3
            getw.3
            console_ioctl.4
            sk98lin.4
            environ.7
            unix.7
            time.7

Various pages
    mtk
        Added a SEE ALSO reference for feature_test_macros(7) to all
        pages where a feature test macro appears in the SYNOPSIS.

Various pages
    mtk
        Added SEE ALSO entry pointing to time.7
            alarm.2
            nanosleep.2
            ualarm.3
            usleep.3

Various pages
    Justin Pryzby / mtk
        Fixed consecutive duplicate word typos on a number of pages.

Typographical or grammatical errors have been corrected in several
places.  (Special thanks to Nicolas François!)


Changes to individual pages
---------------------------

access.2
    mtk
        Since 2.6.20, access() honors the MS_NOEXEC mount flag.
    Jorge Peixoto de Morais Neto / mtk
        Improve ENOENT description.

clone.2
    mtk
        Added some detail to the prototype.
        Added some notes on IA-64's clone2().

epoll_ctl.2
    mtk
        Add text to note that EPOLLRDHUP appeared in kernel 2.6.17.

faccessat.2
    Justin Pryzby
        Various fixes as per
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=411177
        * s/effective/real/ in description text.
        * added <fcntl.h> to synopsis.
        * various other changes.

getrlimit.2
    mtk / Fedora downstream patches; thanks to Ivana Varekova
        Added a few words to note that RLIMIT_NPROC is really a limit on
        threads.

io_cancel.2
io_destroy.2
io_getevents.2
io_setup.2
io_submit.2
    Fedora downstream patches; thanks to Ivana Varekova
        s%linux/aio.h%libaio.h% in SYNOPSIS.
        Changed return type from "long" to "int".

mbind.2
    Samuel Thibault / mtk
        Fix EINVAL description.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=411777

mincore.2
    Nick Piggin
        Kernel 2.6.21 fixes several earlier bugs in mincore().
    Nick Pollitt
        Remove words "of a file" -- mincore() is describing
        memory residence information, not properties of a file.
    mtk
        Rewrote various parts to make the page clearer.

mmap.2
    mtk
        Rewrote and reorganized various parts to be clearer.
    Taken from Fedora downstream patches; thanks to Ivana Varekova
        Removed text stating that mmap() never returns 0; that's
        not true.

mount.2
    mtk / Val Henson
        Document MS_RELATIME, new in Linux 2.6.20.

open.2
    Andre Majorel / mtk
        On Linux, the error returned when opening a large file on a
        32-bit system is actually EFBIG, not EOVERFLOW.

posix_fadvise.2
    Pádraig Brady
        Fix RETURN VALUE description: returns error number of failure.

rename.2
    mtk / Timo Sirainen
        Various improvements to DESCRIPTION.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=416012

semop.2
    mtk
        If sops contains multiple operations, then these are performed
        in array order.  All Unix systems that I know of do this,
        and some Linux applications depend on this behavior.  SUSv3
        made no explicit statement here, but SUSv4 will explicitly
        require this behavior.
        Small rewording of explanation of "atomically".

signal.2
    Nicolas François
        Fix incorrect argument name in DESCRIPTION.
    mtk
        Small wording improvement.

socket.2
    Nicolas François
        Add reference to ipv6.7 page.

socketcall.2
    Nicolas François
        Fix .TH line.

splice.2
    Benjamin Gilbert
        Fix inconsistent argument names in SYNOPSIS and DESCRIPTION.

statvfs.2
    mtk
        Small wording clarification.

symlink.2
    mtk / Nicolas François
        Removed cryptic text under CONFORMING to referring to
        "open(2) and NFS".  There is no relevant text in open.2 as
        far as I (mtk) can see.

time.2
    mtk / Reuben Thomas
        Remove sentence "gettimeofday() obsoleting time() on 4.3BSD".
        This information is old, and probably no longer relevant.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=403888

write.2
    mtk, after an idea from a downstream Fedora patch.
        Clarified discussion of /count == 0/ case.

ptrace.2
    Chuck Ebbert
        When the parent receives an event with PTRACE_EVENT_* set,
        the child is not in the normal signal delivery path.  This
        means the parent cannot do ptrace(PTRACE_CONT) with a signal
        or ptrace(PTRACE_KILL).  kill() with a SIGKILL signal can be
        used instead to kill the child process after receiving one
        of these messages.

sched_setaffinity.2
    mtk
        Fix glibc version number in description of 'cpusetsize' argument.

vfork.2
    mtk
        Stripped some excess/outdated text from the BUGS section.

basename.3
    mtk / Jorge Peixoto de Morais Neto
        Add text to clarify that the pointer returned by these
        functions may be into some part of 'path'.

dlopen.3
    Taken from Fedora downstream patches; thanks to Ivana Varekova
    + Carlo Marcelo Arenas Belon
        Add "#include <stdlib.h>" to example program.

fclose.3
    mtk
        Complete rewrite.  The existing page was hard to read,
        and the RETURN VALUE description seems to be wrong.

getopt.3
    mtk
        Added getopt() example program.
    mtk
        Add a few words to clarify the operation of the GNU-specific
        double-colon feature, which allows options to have optional
        arguments.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=352139

glob.3
    Nicolas François
        Fix PROTOTYPE.

inet_network.3
    mtk, after an idea from a downstream Fedora patch.
        Clarified description of inet_network().

log.3
    Nicolas François
        Fix .TH line.

log10.3
    Nicolas François
        Fix .TH line.

malloc.3
    Nicolas François
        Small rewording to mention calloc().

posix_openpt.3
    Martín Ferrari
        Fix return type in SYNOPSIS; as per
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=400971
        Needs _XOPEN_SOURCE == 600; as per
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=400975
    Julien BLACHE
        s/ptsname/posix_openpt/ in RETURN VALUE

re_comp.3
    Taken from Fedora downstream patches; thanks to Ivana Varekova
        Add "#define _REGEX_RE_COMP" to SYNOPSIS.

regex.3
    Nicolas François
        Fix .TH line.

termios.3
    mtk
        Added .SS headers to give some structure to this page; and a small
        amount of reordering.
    mtk
        Added a section on canonical and non-canonical mode.
    mtk
        Enhanced the discussion of "raw" mode for cfmakeraw().
    mtk
        Document CMSPAR.
    mtk
        Make description of PARODD a little clearer.
    Reuben Thomas
        Add SEE ALSO link to tty_ioctl.4
    mtk
        Add SEE ALSO link to console_ioctl.4

ualarm.3
    mtk
        Removed BSD prototype from synopsis.
        Various rewordings.

usleep.3
    mtk
        Removed BSD prototype from synopsis.
        Various rewordings.

termcap.5
    Taken from Fedora downstream patches; thanks to Ivana Varekova
        s/curses/ncurses/ under SEE ALSO

bootparam.7
    Taken from Fedora downstream patches; thanks to Ivana Varekova
        Documented "mem=nopentium".

feature_test_macros.7
    mtk
        The default treatment of _POSIX_C_SOURCE changed in glibc 2.4.
    mtk, after a suggestion by Justin Pryzby
        Added some text warning that the "__" macros that
        <features.h> defines internally should never be
        directly defined by programs.
    mtk, based on notes by Jakub Jelinek
        Document _FORTIFY_SOURCE
        (See http://gcc.gnu.org/ml/gcc-patches/2004-09/msg02055.html )
    mtk
        Document _REENTRANT and _THREAD_SAFE.

mdoc.7
    mtk / Nicolas François
        Remove CONFIGURATION section, since this does not seem to be
        true for Linux.

svipc.7
    Nicolas François
        Fix data types in associated data structures;
        remove nonexistent semzcnt and semncnt fields.

time.7
    mtk
        Since kernel 2.6.20, the software clock can also be 300 HZ.


==================== Changes in man-pages-2.45 ====================

Released: 2007-04-05

Global changes
--------------

This release consists mainly of formatting fixes (to a large
number of pages) to achieve greater consistency across pages.
With the exception of the few individual changes noted below,
no changes were made to content.

Changes to individual pages
---------------------------

io_destroy.2
io_getevents.2
io_setup.2
io_cancel.2
io_submit.2
    mtk
        Clarified RETURN VALUE text

bindresvport.3
    mtk
        Rewrote prototype using modern C syntax.


==================== Changes in man-pages-2.46 ====================

Released: 2007-04-06

Global changes
--------------

This release consists mainly of formatting fixes (to a large
number of pages) to achieve greater consistency across pages:

* Most instances of two or more consecutive blank lines in man
  page output were shrunk to a single line.
* A number of example programs were reformatted
  to more closely match K&R style.
* In various places (mainly code examples), the use of tabs was
  replaced by spaces

With the exception of the few individual changes noted below,
no changes were made to content.


Changes to individual pages
---------------------------

bdflush.2
    mtk
        Add <sys/kdaemon.h> header file to SYNOPSIS.

sched_rr_get_interval.2
    mtk
        Moved timespec definition from SYNOPSIS into description.

select_tut.2
    mtk
        Make SYNOPSIS match select.2.


==================== Changes in man-pages-2.47 ====================

Released: 2007-05-04

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
John Heffner <jheffner@psc.edu>

Apologies if I missed anyone!


Global changes
--------------

This release consists mainly of changes to source file layout
(wrapped long lines; stripped trailing white space; started new
sentences on new lines).

There is very little change to output formatting or content (see the
notes below).


Changes to individual pages
---------------------------

sched_rr_get_interval.2
    mtk
        Remove crufty statement that this system call is not implemented.
        The nice interval can be used to control the size of
        the round-robin quantum.
        Corrected .TH line.

ip.7
    John Heffner / mtk
        Document IP_PMTUDISC_PROBE, which will be in 2.6.22.


==================== Changes in man-pages-2.48 ====================

Released: 2007-05-04

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Colin Watson <cjwatson@debian.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>

Apologies if I missed anyone!


Global changes
--------------

This release consists mainly of changes to source file layout
(wrapped long lines; stripped trailing white space; started new
sentences on new lines).

There is very little change to output formatting or content (see the
notes below).

Various pages
    mtk
        In various places where it occurred,
        s/nonnegative/non-negative/

Various pages
    mtk
        s/wide character/wide-character/ when used attributively.


Changes to individual pages
---------------------------

man.7
    Justin Pryzby / Colin Watson / mtk
        .SH doesn't require quotes.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=411303


==================== Changes in man-pages-2.49 ====================

Released: 2007-05-20

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Akihiro MOTOKI <amotoki@dd.iij4u.or.jp>
Bruno Haible <bruno@clisp.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>

Apologies if I missed anyone!


New pages
---------

bsd_signal.3
    mtk
        Documentation of bsd_signal().

euidaccess.3
    mtk
        Manual page for euidaccess() and eaccess().

getsubopt.3
    mtk / Justin Pryzby
        Documentation of getsubopt().

sysv_signal.3
    mtk
        Documentation of sysv_signal().


New links
---------

epoll_pwait.2
    mtk
        New link to epoll_wait.2.

eaccess.3
    mtk
        New link to new euidaccess.3,

sem_timedwait.3
    mtk
        New link to sem_wait.3.

sem_trywait.3
    mtk
        New link to sem_wait.3.


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

access.3
    mtk
        Added SEE ALSO ref to new euidaccess.3 page.

epoll_wait.2
    mtk
        Added description of epoll_pwait(), new in kernel 2.6.19.

execve.2
    mtk
        Add text noting that Linux allows 'argv' and 'envp' to be
        NULL, but warning that this is non-standard and non-portable,
        and should be avoided in portable programs.
        Bug filed (http://bugzilla.kernel.org/show_bug.cgi?id=8408)
        to get this changed, but maybe that won't be done because it
        is an ABI change.
    mtk
        Added an example program.
    mtk
        Expanded the discussion of interpreter scripts and the
        'optional-arg' argument of an interpreter script.
        For further info, see
        http://homepages.cwi.nl/~aeb/std/hashexclam-1.html
        http://www.in-ulm.de/~mascheck/various/shebang/
    mtk
        Added text noting that FD_CLOEXEC causes record locks to be
        released.
    mtk
        Mention effect of MS_NOSUID mount(2) flag for set-user-ID
        programs.
    mtk
        Expanded description of handling of file descriptors during
        execve(), adding text to note that descriptors 0, 1, and 2
        may be treated specially.

faccessat.3
    mtk
        Added SEE ALSO ref to new euidaccess.3 page.

mmap.2
    mtk
        Place MAP_* flags list in alphabetical order.

readv.2
    mtk
        A fairly substantial rewrite, which among other things
        fixes the problem reported by Kyle Sluder in
        http://bugzilla.kernel.org/show_bug.cgi?id=8399
        And added some example code.

sigaction.2
    mtk
        Added text referring to the discussion of async-signal-safe
        functions in signal(7).
        A few other minor formatting and wording changes.

signal.2
    mtk
        Moved the discussion of async-signal-safe functions to signal(7).
        Added text referring to the discussion of async-signal-safe
        functions in signal(7).
        Added SEE ALSO entries referring to new bsd_signal.3 and
        sysv_signal.3 pages.

copysign.3
    Bruno Haible
        Clarify discussion of negative zero.

getopt.3
    mtk
        Add SEE ALSO ref to new getsubopt.3.

iconv_open.3
    Bruno Haible
        Describe the glibc/libiconv //TRANSLIT and //IGNORE extensions
        for 'tocode'.

iswblank.3
    Bruno Haible
        Update CONFORMING TO; iswblank() is in POSIX.1-2001.

inotify.7
    mtk
        Definitions for IN_DONT_FOLLOW, IN_MASK_ADD, and IN_ONLYDIR
        were added to glibc in version 2.5.

signal.7
    mtk
        Incorporated (and slightly modified) the text on
        async-signal-safe functions that was formerly in signal(2).
        Added SEE ALSO entries referring to new bsd_signal.3 and
        sysv_signal.3 pages.


==================== Changes in man-pages-2.50 ====================

Released: 2007-05-21

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andreas Halter <halter@google.com>
Laird Shaw <netocrat@dodo.com.au>
Mike Frysinger <vapier@gentoo.org>

Apologies if I missed anyone!

Removed pages (!)
-----------------

Most Section 1 man pages are removed
    mtk (with help from Mike Frysinger, Laird Shaw, Andreas Halter)
        Once upon time Andries added a number of Section 1 manual pages
        to man-pages.  However, since that time, those pages have not
        seen much maintenance, and are not in fact distributed in most
        distributions.  Instead most distributions supply the
        coreutils versions of these pages, which are currently
        maintained.  In addition, man-pages provides the 1p pages,
        which document the portable subset of functionality of these
        commands.  Since the man1 pages are mostly unneeded, and
        out of date, I'm removing them.  The following pages disappear:

            chgrp.1
            chmod.1
            chown.1
            cp.1
            dd.1
            df.1
            diff.1
            dir.1
            dircolors.1
            du.1
            install.1
            ln.1
            ls.1
            mkdir.1
            mkfifo.1
            mknod.1
            mv.1
            rm.1
            rmdir.1
            touch.1
            vdir.1

        The following Section 1 pages will be kept:

            intro.1
            ldd.1
            time.1


==================== Changes in man-pages-2.51 ====================

Released: 2007-05-28

Global changes
--------------

Various pages
    mtk
        (Hopefully) all cross references outside a page now include a
        section number.  This should permit better resulting output
        from a man2html-type conversion.

Various pages
    mtk
        Convert function formatting of the form "\fBname\fP()" to
        ".BR name ()".


Changes to individual pages
---------------------------

futimesat.2
    mtk
        s/futimes/futimesat/ in .SH NAME line.

msgop.2
    mtk
        Put "msgrcv" and "msgsnd" in .SH NAME line.

mount.2
    mtk
        Add "umount2" to .SH NAME line.

wait.2
    mtk
        Add "waitid" to .SH NAME line.

getopt.3
    mtk
        Add "getopt_long" and "getopt_long_only" in .SH NAME line.

sem_wait.3
    mtk
        Add "sem_timedwait" and  "sem_trywait" to .SH NAME line.

stdarg.3
    mtk
        Add "va_start", "va_arg", "va_end", "va_copy" to .SH NAME line.


==================== Changes in man-pages-2.52 ====================

Released: 2007-05-29

    "A foolish consistency is the hobgoblin of little minds, adored by
     little statesmen and philosophers and divines"

        Ralph Waldo Emerson (1803-1882)

    "But damn it, these man pages are a mess!"


Global changes
--------------

Most of the changes below are about bringing greater consistency
to manual pages, including reducing the wide range of .SH
Section headings.

Typographical or grammatical errors have been corrected in several
places.

Various pages
    mtk
        Make 'manual' component of .TH line into the string
        "Linux Programmer's Manual".
        Reason: consistency.

Various pages
    mtk
        Changed date in .TH line into form YYYY-DD-MM.
        Reason: consistency.

Various pages
    mtk
        Some .SH header lines were made into .SS lines.  (One of the aims
        here is to reduce the number of non-standard .SH lines.)

Various pages
    mtk
        Change title .SH sections named "NOTE" to "NOTES", in some cases
        also changing the location of the section within the page.
        Reason: consistency.

Various pages
    mtk
        Commented out .SH AUTHOR sections; the right place for
        documentation authorship sections is usually comments at the
        top of the page source.

Various pages
    mtk
        Changed .SH HISTORY to .SH VERSIONS.
        Reason: in many cases, HISTORY was being used to describe
        Linux/glibc version information, as was already done for
        VERSIONS sections in other pages.

Various pages
    mtk
        Removed HISTORY section, or moved it as a subsection or paragraphs
        under another section e.g., NOTES.
        Reason: there are too many arbitrary section (.SH) names, and
        a HISTORY section never was consistently used across Linux
        manual pages.

Various pages
    mtk
        Moved SEE ALSO section to be last section on the page
        Reason: consistency -- and this is where SEE ALSO should be!

Various pages
    mtk
        Relocated GLIBC NOTES as subsection under NOTES
        Reason: reduce number of arbitrary section (.SH) names.

Various pages
    mtk
        Relocated LINUX NOTES as subsection under NOTES
        Reason: reduce number of arbitrary section (.SH) names.

Various pages
    mtk
        Renamed some "AVAILABILITY" sections to "VERSIONS".
        Reason: consistency.

Various pages
    mtk
        Renamed some "DIAGNOSTICS" sections to "RETURN VALUE".
        Reason: consistency.

getopt.3
tzselect.8
    mtk
        s/\.SH ENVIRONMENT VARIABLES/.SH ENVIRONMENT/
        Reason: consistency.

intro.2
select.2
sysctl.2
bsearch.3
dlopen.3
envz_add.3
fmtmsg.3
getgrent_r.3
getgrouplist.3
getpwent_r.3
getutent.3
hsearch.3
rtime.3
strptime.3
tsearch.3
vcs.4
wordexp.3
    mtk
        s/return 0/exit(EXIT_FAILURE)/ in main() of function example
        program.
        Reason: consistency.

mprotect.2
select_tut.2
dlopen.3
getgrent_r.3
getopt.3
getpwent_r.3
hsearch.3
select_tut.2
tsearch.3
    mtk
        Use symbolic constants (EXIT_SUCCESS, EXIT_FAILURE) in calls
        to exit().
        Reason: consistency.

access.2
chown.2
lseek.2
open.2
read.2
utmp.5
    mtk
        Renamed RESTRICTIONS section to NOTES, or moved text in a
        RESTRICTIONS section under existing NOTES section.
        Reason: consistency, and reduce number of arbitrary section (.SH)
        names.


Changes to individual pages
---------------------------

capget.2
    mtk
        s/\.SH FURTHER INFORMATION/.SH NOTES/

dup.2
    mtk
        s/\.SH WARNING/.SH NOTES/

kill.2
    mtk
        Renamed LINUX HISTORY section to LINUX NOTES, and relocated
        within page.

select_tut.2
    mtk
        Relocated example program and made its .SH title "EXAMPLE".

sigaltstack.2
    mtk
        Move code example into its own EXAMPLE section.

sigreturn.2
    mtk
        s/\.SH WARNING/.SH NOTES/

setuid.2
    mtk
        s/\.SH "LINUX-SPECIFIC REMARKS"/.SH LINUX NOTES/

shmget.2
    mtk
        Remove section about effect of fork()/exec()/exit(); shmop.2
        contains the same text, and it only needs to be said once.

shmop.2
    mtk
        Minor rewording under DESCRIPTION.

daemon.3
    mtk
        Minor wording and formatting changes.

encrypt.3
    mtk
        Removed statement that glibc unconditionally exposes declarations
        of encrypt() and setkey(), since portable applications must
        use <unistd.h> and define _XOPEN_SOURCE to obtain the declarations
        of setkey() and encrypt().  Adjusted example program accordingly.

mkstemp.3
    mtk
        Slight rewording.

LDP.7
    mtk
        Minor wording and formatting changes.

man.7
    mtk
        Substantial rewrite, revising and extending the discussion
        about desired conventions for writing pages.
        There will be further updates to this page in the next few
        man-pages releases.


==================== Changes in man-pages-2.53 ====================

Released: 2007-05-30

    "A foolish consistency is the hobgoblin of little minds, adored by
     little statesmen and philosophers and divines"

        Ralph Waldo Emerson (1803-1882)

    "But damn it, these man pages are a mess!"


Global changes
--------------

Many many pages
    mtk
        Reordered sections to be more consistent, in some cases renaming
        sections or shifting paragraphs between sections.

man7/*
    mtk
        In various pages in this section, .SH headings were
        converted to .SS.


==================== Changes in man-pages-2.54 ====================

Released: 2007-06-07

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Emmanuel Mogenet <emogenet@google.com>
Michael Berg <michaeljberg@gmail.com>

Apologies if I missed anyone!


Global changes
--------------

Various pages
    mtk
        Where there is an instruction in the SYNOPSIS about linking
        or compiling with a certain option, the option is now
        marked up in italics (e.g., "\fI-lm\fP").

Various pages
    mtk
        Added page numbers to page cross references.

A few pages
    mtk
        s/manpage/man page/, for consistency.

Typographical or grammatical errors have been corrected in several
places.


New pages
---------

man-pages.7
    mtk
        A description of the conventions that should be followed
        when writing pages for the man-pages package.

Removed pages
-------------

man1/README
    mtk
        Already deleted most of the man1 pages previously, so
        this doesn't need to stay.

LDP.7
    mtk
        Removed this page since it is out of date, and the proper place
        to go for up-to-date information is http://www.tldp.org/

ksoftirq.9
    mtk
        Reason: this was the only Section 9 page, and it is old
        (Linux 2.4).  The man9 section never took off as an idea, and
        I see little point in keeping a Section 9 with just a single
        old page.


Changes to individual pages
---------------------------

HOWTOHELP
    mtk
        Moved some material out of here into new man-pages.7.

alloc_hugepages.2
    mtk
        Minor rewrites, eliminating some duplication, and removing
        some outdated text.

epoll_pwait.2
    Michael Berg
        Fix broken link path;
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=425570

fcntl.2
    mtk
        Remove misleading text about setting O_ASYNC when calling
        open(); one must use fcntl() F_SETFL for this task.

fdatasync.2
    mtk
        Converted outdated BUGS note about fdatasync() being
        equivalent to fsync() on Linux 2.2 into a NOTES note
        about this historical behavior.

futex.2
    mtk
        Small rewording to fix "fails with the error EWOULDBLOCK"
        rather than "returns EWOULDBLOCK".
        See Red Hat bug 172828.

mprotect.2
    mtk, after an observation by Emmanuel Mogenet
        A much improved example program.
    mtk
        Significant rewrites and additions to description.

mremap.2
    mtk
        Remove text about the nonexistent BSD mremap() -- too
        much information, in my opinion.

sched_yield.2
    mtk
        Added ERRORS section.

set_mempolicy.2
    mtk
        Moved text for "Versions and Library Support".

set_tid_address.2
    mtk
        Small rewording in RETURN VALUE section.

sigaction.2
    mtk
        Add EXAMPLE section with a pointer to example in mprotect.2.

sync_file_range.2
    mtk
        Fix return type in SYNOPSIS.  Add RETURN VALUE section.

atexit.3
    mtk
        Small rearrangement of text under NOTES.

bindresvport.3
    mtk
        Rewrite and substantial additional text.

exec.3
    mtk
        Minor clarifications for text on execlp() and execvp().  Removed
        FILES section, since it provides no useful additional info.

fenv.3
    mtk
        Moved link instructions from NOTES to SYNOPSIS.
        Added feenableexcept, fedisableexcept, fegetexcept
        to .SH NAME list.

fputwc.3
    mtk
        Added 'putwc' to .SH NAME list.

gethostbyname.3
    mtk
        s/int/socklen_t/ for type of gethostbyaddr() 'len' argument,
        and add a few more words in NOTES about the type used here.

login.3
    mtk
        Removed remark from NOTES about linking with -lutil; add
        text on that point to SYNOPSIS.

openpty.3
    mtk
        Removed redundant remark from NOTES about linking with -lutil
        since there is text on that point under SYNOPSIS.

sysconf.3
    mtk
        Added SEE ALSO referring to getconf(1).

unlocked_stdio.3
    mtk
        Revised .SH NAME section.

ascii.7
    mtk
        Minor rearrangement of order of text.

capabilities.7
    mtk
        s/exec()/execve(2)/ in various places.

complex.7
    mtk
        Changed "atan(1)" to "atan(1.0)" to prevent some versions of
        man2html(1) from mistaking that string as a page cross reference.

rtnetlink.7
    mtk
        Small restructuring to avoid 'cannot adjust line' from man(1).

ldconfig.8
    mtk
        Removed now very out-of-date sentence about need to link shared
        libraries with -lc.

man.7
    mtk
        Various text was moved out of this page into the new man-pages.7.

mdoc.7
    mtk
        Added SEE ALSO referring to new man-pages.7.

mdoc.samples.7
    mtk
        A few changes, hopefully done right, to eliminate some
        errors to stderr when rendering with man(1).

rtnetlink.7
    mtk
        Shorten a line in table so it fits in 80 columns.
        Minor rewording under BUGS.

tzselect.8
    mtk
        Moved EXIT STATUS section.


==================== Changes in man-pages-2.55 ====================

Released: 2007-06-10

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alexander Taboriskiy <alextab@math-solution.com>
Joey Hess <joeyh@debian.org>
John Reiser <jreiser@bitwagon.com>
Julien Cristau <jcristau@debian.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Martin (Joey) Schulze <joey@infodrom.org>
Mike Frysinger <vapier@gentoo.org>
Serge van den Boom <svdb@stack.nl>
Ulrich Drepper <drepper@redhat.com>
Xose Vazquez Perez <xose.vazquez@gmail.com>

Apologies if I missed anyone!


Global changes
--------------

clone.2
getdents.2
gettid.2
ioprio_set.2
llseek.2
mmap2.2
modify_ldt.2
mq_getsetattr.2
pivot_root.2
quotactl.2
readdir.2
sysctl.2
syslog.2
tkill.2
    mtk, after a note by Mike Frysinger
        Updated to reflect the fact that the _syscallN() macros
        have gone away,

Several pages
    mtk
        Change reference to path_resolution.2 to path_resolution.7.

Typographical or grammatical errors have been corrected in several
places.


Moved pages
-----------

path_resolution.2 has been moved to section 7, thus path_resolution.7
    mtk
        Reason: this is an overview page, not one describing as
        a specific system call.


Changes to individual pages
---------------------------

MAINTAINING
    mtk, after a note from Xose Vazquez Perez
        Added pointer to Red Hat man-pages bugzilla.
    mtk
        Added a release philosophy note on separating out big
        formatting changes into their own release that contains minimal
        content changes.

accept.2
    mtk
        Add new EXAMPLE section with pointer to example in bind.2.

arch_prctl.2
    mtk
        Added RETURN VALUE section.

bind.2
    mtk
        Expand example program, and move it to new EXAMPLE section.
        Added text pointing to example in getaddrinfo.3.

cacheflush.2
    mtk
        Convert NOTES section to CONFORMING TO and note that
        this call is Linux-specific.
        Other minor rewordings.

connect.2
    mtk
        Added new EXAMPLE section pointing to example in getaddrinfo.3.

create_module.2
    mtk
        Add ENOSYS error.

fcntl.2
flock.2
    mtk
        Small rewrite of SEE ALSO text pointing to Documentation/* in
        kernel source.

get_kernel_syms.2
    mtk
        Added ERRORS heading
        Add ENOSYS error.

getdtablesize.2
    mtk
        Added an ERRORS section.

getsid.2
    mtk
        Added a RETURN VALUE section.

getpid.2
    mtk
        Added an ERRORS section (stating that the calls are
        always successful).

ioctl_list.2
    mtk
        Add SEE ALSO reference to ioctl.2.

listen.2
    mtk
        Add new EXAMPLE section with pointer to example in bind.2.

query_module.2
    Martin (Joey) Schulze
        Add ENOSYS error.

recv.2
    mtk
        Added new EXAMPLE section pointing to example in getaddrinfo.3.

sched_get_priority_max.2
sched_rr_get_interval.2
sched_setscheduler.2
sched_yield.2
    mtk
        Modified .TH line

send.2
    mtk
        Added new EXAMPLE section pointing to example in getaddrinfo.3.

set_tid_address.2
    mtk
        Added an ERRORS section (stating that the call is
        always successful).

signal.2
    mtk, after a note from Alexander Taboriskiy
        Strengthen warning against the use of signal().
        Added siginterrupt(3) to SEE ALSO list.
    mtk
        Rewrote various parts; added an ERRORS section.

socket.2
    mtk
        Added new EXAMPLE section pointing to example in getaddrinfo.3.

stat.2
    mtk
        Added EXAMPLE program.

syscall.2
    mtk
        Converted to -man format; some rewrites; added an EXAMPLE.

sysctl.2
    mtk
        Improved the example program.

getnameinfo.3
    mtk
        Add text pointing to example in getaddrinfo.3.

getaddrinfo.3
    mtk
        Add example programs.
        Add getnameinfo() to SEE ALSO list.

memmove.3
    mtk / Serge van den Boom
        Clarify discussion of what happens if 'src' and 'dest' overlap.

regex.3
    Justin Pryzby
        Add grep(1) to SEE ALSO list.

sigpause.3
    mtk after a note from Ulrich Drepper
        Clarify discussion of feature test macros that are needed to
        expose System V and BSD versions of this function in glibc.

undocumented.3
    mtk
        Removed some functions that have been documented.

wprintf.2
    Martin (Joey) Schulze
        Remove wscanf.3 from SEE ALSO list, since that page does not exist.

utmp.5
    Joey Hess
        Removed outdated note on xdm.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=418009
    Martin (Joey) Schulze
        Removed outdated note about Debian and libc5.

bootparam.7
    Martin (Joey) Schulze
        Fix order of commands listed under 'init='.

hier.7
    Joey Hess
        Add /media, remove /dos.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=418234

inotify.7
    mtk
        Added text describing what happens when the buffer given to
        read(2) is too small to return information about the next event,
        and noting the behavior change in 2.6.21.

man-pages.7
    mtk
        Added text to note that ERRORS list should be in alphabetical order.

mdoc.7
mdoc.samples.7
    mtk
        Added SEE ALSO reference to groff_mdoc(7).

unix.7
    mtk
        Added  EXAMPLE section with pointer to bind.2 EXAMPLE.

ld.so.8
    mtk
        Simplify text describing --inhibit-rpath.
    mtk, after a note by John Reiser
        Describe use of $ORIGIN in rpath.


==================== Changes in man-pages-2.56 ====================

Released: 2007-06-11

Global changes
--------------

Many pages
    mtk
        Removed version numbers in .TH lines.
        Reason: these were only arbitrarily updated, and so impart no
        useful information.  Version information goes into a
        VERSIONS section nowadays, and the date in the .TH line should
        be updated to reflect the date of the last (significant)
        change to the page.

Typographical or grammatical errors have been corrected in several
places.


==================== Changes in man-pages-2.57 ====================

Released: 2007-06-17

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Samuel Thibault <samuel.thibault@ens-lyon.org>

Apologies if I missed anyone!


Global changes
--------------

Many pages
    mtk
        Fix section numbers in page cross references.


Changes to individual pages
---------------------------

access.2
    mtk
        Minor wording fixes.
        Small clarification of description of 'mode'.

bind.2
    mtk
        Small reworking of EXAMPLE program.

exit_group.2
    mtk
        Minor wording fixes.

exit.3
    mtk
        Added more detail on exit handlers.
        Minor wording fixes.

ioctl.2
    mtk
        Remove SEE ALSO reference to nonexistent mt.4.

modify_ldt.2
    Samuel Thibault / mtk
        In Linux 2.6, the 'modify_ldt_ldt_s' structure was renamed
        'user_desc'.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=378668
    mtk
        Include definition of 'user_desc' structure.
        Minor rewordings.

mprotect.2
    mtk
        Small reworking of EXAMPLE program.

sigaction.2
    mtk
        Removed reference to nonexistent sigsend(2).

a64l.3
    mtk
        Remove SEE ALSO reference to nonexistent itoa.3.

dysize.3
    mtk
        Removed SEE ALSO reference to nonexistent time.3.

encrypt.3
    mtk
        Removed SEE ALSO reference to nonexistent fcrypt.3.

fmemopen.3
    mtk
        Small reworking of EXAMPLE program.

fpurge.3
    mtk
        Remove SEE ALSO reference to nonexistent fclean.3.

getutent.3
    mtk
        s/ttyname(0)/ttyname(STDIN_FILENO)/ in program example.

vcs.4
    mtk
        s/exit(1)/exit(EXIT_FAILURE)/

environ.7
    mtk
        Correct some section numbers in page cross references.

man-pages.7
    mtk
        Modify requirements for example programs a little.

uri.7
    mtk
        Wrapped long source lines.


==================== Changes in man-pages-2.58 ====================

Released: 2007-06-24

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Marc Boyer <marc.boyer@enseeiht.fr>
Mike Frysinger <vapier@gentoo.org>

Apologies if I missed anyone!


Global changes
--------------

Various pages, as detailed below
    mtk
        Added or updated VERSIONS sections.

killpg.2
setuid.2
faccessat.2
fork.2
setfsuid.2
kill.2
getsid.2
wait.2
execve.2
getpid.2
setgid.2
seteuid.2
setresuid.2
setfsgid.2
access.2
initgroups.3
euidaccess.3
tcgetpgrp.3
path_resolution.7
capabilities.7
unix.7
    mtk
        Add SEE ALSO link to new credentials.7.


New pages
---------

credentials.7
    mtk
        An overview of Linux process identifiers (PIDs, PPIDs,
        PGIDS, SIDs, UIDs, GIDs).


Changes to individual pages
---------------------------

bind.2
    mtk
        Added some comments to example program.

getxattr.2
    mtk
        VERSIONS: In kernel since 2.4; glibc support since 2.3.

listen.2
    mtk
        Updated discussion of somaxconn limit.

listxattr.2
    mtk
        VERSIONS: In kernel since 2.4; glibc support since 2.3.

posix_fadvise.2
    mtk
        VERSIONS: Glibc support has been provided since version 2.2.

readahead.2
    mtk
        Added VERSIONS section.

remap_file_pages.2
    mtk
        Updated VERSIONS section with text on glibc support.

removexattr.2
    mtk
        VERSIONS: In kernel since 2.4; glibc support since 2.3.

semop.2
    mtk
        Added VERSIONS section with info on semtimedop().

setxattr.2
    mtk
        VERSIONS: In kernel since 2.4; glibc support since 2.3.

dl_iterate_phdr.3
    mtk
        VERSIONS: Supported since glibc 2.2.4.

getloadavg.3
    mtk
        Added VERSIONS section.

posix_openpt.3
    mtk
        VERSIONS: Supported since glibc 2.2.1.

printf.3
    mtk after a suggestion by Mike Frysinger
        Add text to the introductory part of DESCRIPTION, about the
        'size' argument of snprintf() and vsnprintf().

shm_open.3
    mtk
        Added VERSIONS section; rewrote info about linking with -lrt.

strcat.3
    Marc Boyer
        Improve the discussion of strncat().

strcpy.3
    Marc Boyer
        Improve the discussion of strncpy().

proc.5
    mtk
        Added discussion of /proc/sys/net/core/somaxconn.


==================== Changes in man-pages-2.59 ====================

Released: 2007-06-25

Global changes
--------------

Manual pages are now standardized on American spelling.  See
http://en.wikipedia.org/wiki/American_and_British_English_spelling_differences
for more information on the differences.  Formerly, different pages (and
sometimes even a single page!) employed American and British spelling
conventions; best to standardize on one spelling, and American English
is the standard in Computer Science.

Changes to individual pages
---------------------------

man-pages.7
    mtk
        Note that man-pages has now standardized on American spelling
        conventions.

execve.2
getxattr.2
listxattr.2
removexattr.2
setxattr.2
signal.2
syscall.2
aio_cancel.3
bindresvport.3
stdarg.3
charmap.5
bootparam.7
ipv6.7
man.7
path_resolution.7
uri.7
nscd.8
    mtk
        Corrected minor spelling/wording mistakes (i.e., changes
        independent of fixes for American spelling).


==================== Changes in man-pages-2.60 ====================

Released: 2007-06-25


Global changes
--------------

Various pages
    mtk
        Wrapped lines in some files.

Various pages
    mtk
        Change "e.g. " to "e.g., ", or in some cases, "for example, ".

Various pages
    mtk
        Change "i.e. " to i.e., ", or in some cases, "that is, ".

Various pages
    mtk
        Removed AUTHORS section.

Typographical or grammatical errors have been corrected in several
places.


Changes to individual pages
---------------------------

vfork.2
    mtk
        s/w.r.t/with respect to/

man-pages.7
    mtk
        Strengthened warning against use of AUTHORS section.


==================== Changes in man-pages-2.61 ====================

Released: 2007-07-01


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Benno Schulenberg <bensberg@justemail.net>
Florian Ernst <florian_ernst@gmx.net>
Ivana Varekova <varekova@redhat.com>
Jeff Schroeder <jeffschroeder@computer.org>
Joey (Martin) Schulze <joey@infodrom.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Loïc Minier <lool@dooz.org>
Michael Gehring <mg@ebfe.org>
Serge van den Boom <svdb@stack.nl>
Stefan Puiu <stefanpuiuro@yahoo.com>
Stepan Kasal <kasal@ucw.cz>

Apologies if I missed anyone!


Global changes
--------------

Various pages
    mtk
        substitute `\\0' by '\\0'.

Various pages
    mtk
        s/`/'/ when the thing being quoted is a character.

accept.2
bind.2
connect.2
getsockopt.2
listen.2
socket.2
socketpair.2
    mtk after a note by Martin (Joey) Schulze
        Add NOTES paragraph noting that <sys/types.h> isn't required by
        POSIX.1-2001 or Linux, but was required on some implementations.

accept.2
getsockname.2
recv.2
vm86.2
send.2
getgrouplist.3
memmem.3
nsswitch.conf.5
putenv.3
wprintf.3
    mtk
        Replace form `...' with \fI...\fP where the enclosed string
        is a pathname, type name, or argument name.

A few files
    mtk
        s/process' /process's/

gets.3
qsort.3
getaddrinfo.3
rpc.3
ungetwc.3
wcsnrtombs.3
capabilities.7
    mtk
        Add section number to page cross references.

time.1
bind.2
pivot_root.2
sysctl.2
    mtk
        Reordered .SH sections.

full.4
mouse.4
random.4
sd.4
    mtk
        Made CONFIG/CONFIGURING heading ==> CONFIGURATION

time.1
console_codes.4
random.4
sk98lin.4
charmap.5
ftpusers.5
bootparam.7
charsets.7
glob.7
mq_overview.7
unicode.7
uri.7
utf-8.7
    mtk
        Reformatted headings


New pages
---------

backtrace.3
    mtk, with input from Justin Pryzby and Stefan Puiu
        Documents backtrace(), backtrace_symbols(), and
        backtrace_symbols_fd().


New links
---------

backtrace_symbols.3
backtrace_symbols_fd.3
    mtk
        Links to backtrace.3.

__clone.2
    Stepan Kasal
        Link to clone.2.


Changes to individual pages
---------------------------

Makefile
    Serge van den Boom
        Fix setting of 'prefix' macro.

eval.1p
    Benno Schulenberg
        Fix bad text (concatenated line).

chdir.2
    mtk
        Fixed description of EACCES error.
        Added sentence defining "current working directory".
        Other minor wording changes.

cfree.3
    mtk
        Added SEE ALSO section.

clone.2
    mtk
        s/clone2/__clone2/.

fdatasync.2
    mtk
        Minor wording changes.

fork.2
    Alain Portal
        Fix small wording error.

gethostid.2
    Stefan Puiu / mtk
        Add NOTES on what happens if gethostid() can't open /etc/hostid.

idle.2
    mtk
        Made NOTES text into a VERSIONS section, since that's what it
        really describes.

ioperm.2
    mtk
        Minor wording changes.

intro.2
    mtk
        Rewrite to reflect the fact that the _syscallN
        macros are no longer available.

io_cancel.2
    mtk
        Add "Link with -laio" to SYNOPSIS.

io_destroy.2
    mtk
        Add "Link with -laio" to SYNOPSIS.

io_getevents.2
    mtk
        Add "Link with -laio" to SYNOPSIS.

io_setup.2
    mtk
        Add "Link with -laio" to SYNOPSIS.

io_submit.2
    Ivana Varekova
        Fix include in SYNOPSIS.
    mtk
        Add "Link with -laio" to SYNOPSIS.

ipc.2
    mtk
        Add semtimedop() to SEE ALSO.
        Note that some architectures don't have ipc(2); instead
        real system calls are provided for shmctl(), semctl(), etc.

killpg.2
    mtk
        Minor wording changes.

listen.2
    mtk
        Added <sys/types.h> to SYNOPSIS.

sched_setscheduler.2
    mtk
        Add NOTES para about permissions required to call
        sched_setscheduler() on other systems.

select.2
    mtk
        Noted that 'timeout' can also be changed if select() is
        interrupted by a signal.

setup.2
    mtk
        Remove reference to _syscall0() macro.

shmop.2
    mtk
        Changed text for EINVAL error.

socketcall.2
    mtk
        Add recvmsg() and sendmsg() to SEE ALSO.
        Note that some architectures don't have socketcall(2); instead
        real system calls are provided for socket(), bind(), etc.

swapon.2
    Ivana Varekova  / mtk
        Update text for EPERM error describing the maximum number of
        swap files.  (From downstream Fedora patch.)

write.2
    mtk
        Added details about seekable files and file offset.
        Noted that write() may write less than 'count' bytes, and
        gave some examples of why this might occur.
        Noted what happens if write() is interrupted by a signal.
        Minor wording changes.

__setfpucw.3
    mtk
        Added a CONFORMING TO section; other minor edits.

confstr.3
    mtk
        Minor rewrites in code example.

ctime.3
    Justin Pryzby
        Make SEE ALSO refer to timegm.3

daemon.3
    mtk
        Small wording change.

dl_iterate_phdr.3
    Michael Gehring
        Comment was missing closing "*/".

dlopen.3
    mtk
        Formatting changes, and minor rewordings.
    mtk, after a note by Serge van den Boom
        Add a comment explaining the need for the rather
        strange cast of the return value of dlsym().

fpclassify.3
    mtk
        Add "isinf" to NAME section.

getgrouplist.3
    mtk
        Minor rewording.

getline.3
    mtk
        Minor rewording, and note that '*n* is ignored
        if '*lineptr' is NULL.

malloc.3
    Ivana Varekova  / mtk
        Update description of MALLOC_CHECK_ to include description
        for value 3.  (From downstream Fedora patch.)

netlink.3
    mtk
        Added a CONFORMING TO section; other minor edits.

openpty.3
    mtk
        Minor changes to SYNOPSIS.

program_invocation_name.3
    mtk
        Shortened page title to INVOCATION_NAME.

rtnetlink.3
    mtk
        Added a CONFORMING TO section; other minor edits.

scanf.3
    Florian Ernst
        Fix duplicated word "the".
        (Really fix http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=412467 !)

select_tut.3
    mtk
        Small wording change.

setnetgrent.3
    mtk
        Added a CONFORMING TO section.

sigpause.3
    mtk
        Added a CONFORMING TO section.

strftime.3
    Just Pryzby
        Small wording fix.
    mtk
        Note use of "gcc -Wno-format-y2k" to avoid the "`%c' yields only
        last 2 digits of year in some locales" warning.

strstr.3
    mtk
        Add "strcasestr" to NAME section.

syslog.3
    mtk
        Small wording change.


termios.3
    mtk
        Reformat SYNOPSIS.
        Added a CONFORMING TO section.

timegm.3
    mtk
        Small wording changes.

ulimit.3
    mtk
        Remove erroneous text saying that glibc does not provide
        <ulimit.h>; it does.

initrd.4
    mtk
        Various reformattings.

core.5
    mtk
        Added a sentence noting why core dumps named "core.PID" were useful
        with LinuxThreads.

bootparam.7
    mtk
        Fix capitalization in .SS headings.

epoll.7
    mtk
        Language clean ups.

feature_test_macros.7
    mtk
        Added SEE ALSO section.

mq_overview.7
    mtk
        Reformatted headings; minor rewrites.

sem_overview.7
    mtk
        Reformatted headings; minor rewrites.

socket.7
    Loïc Minier <lool@dooz.org>
        Document argument type for SO_REUSEADDR.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=255881

uri.7
    mtk
        Wrap long line in SYNOPSIS.

ldconfig.8
    mtk
        Added SEE ALSO section.


==================== Changes in man-pages-2.62 ====================

Released: 2007-07-09

This release consists solely of formatting fixes.  There are no changes
to content.

Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Stepan Kasal <kasal@ucw.cz>

Apologies if I missed anyone!


Global changes
--------------

Many many pages
    mtk
        Many many formatting fixes.

man[013]p/*
    Stepan Kasal
        Add section number to .TH line for POSIX pages in man[013]p.


==================== Changes in man-pages-2.63 ====================

Released: 2007-07-16


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Arnd Bergmann <arndb@de.ibm.com>
Eduardo M. Fleury <efleury@br.ibm.com>
Ivana Varekova <varekova@redhat.com>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Marc Boyer <marc.boyer@enseeiht.fr>
Martin (Joey) Schulze <joey@infodrom.org>
Martin Röhricht <martin@roehricht.info>
Patrick Mansfield <patmans@us.ibm.com>
Pierre Habouzit <madcoder@debian.org>
Stepan Kasal <kasal@ucw.cz>

Apologies if I missed anyone!


Global changes
--------------

gettimeofday.2
madvise.2
msgctl.2
select.2
semctl.2
shmctl.2
syslog.2
stat.2
a64l.3
printf.3
termios.3
xdr.3
sd.4
    mtk
        Minor wording changes.

obsolete.2
syscall.2
unimplemented.2
    mtk
        Added SEE ALSO reference to syscalls.2.


New pages
---------

sgetmask.2
    mtk
        A real man page for sgetmask(2) and ssetmask(2).
        (This page replaces a previous link of the same name, which
        linked to signal.2.)

spu_create.2
    Arnd Bergmann with additional work by Eduardo M. Fleury and mtk
        Document the PowerPC SPU spu_create() system call.
        (Originally taken from the kernel source file
        Documentation/filesystems/spufs.txt.)

spu_run.2
    Arnd Bergmann with additional work by Eduardo M. Fleury and mtk
        Document the PowerPC SPU spu_run() system call.
        (Originally taken from the kernel source file
        Documentation/filesystems/spufs.txt.)

spufs.7
    Arnd Bergmann with additional work by Eduardo M. Fleury and mtk
        Document the PowerPC SPU file system.
        (Originally taken from the kernel source file
        Documentation/filesystems/spufs.txt.)


Removed Pages
-------------

__clone.2
    mtk
        This file was created by accident in 2.61, as a copy of clone.2.
        (it should have been a link to clone.2.)

obsolete.2
    mtk
        Details on this page are covered in syscalls.2 and in
        respective syscall man pages (stat.2, uname.2).

undocumented.2
    mtk
        This page is very out of date, and in any case difficult
        to maintain.  Information about undocumented system calls
        is maintained in the HOWTOHELP file, and probably in other
        places soon.

killpg.3
    mtk
        This rather incomplete page seems unnecessary since there
        is a killpg.2.


New links
---------

chown32.2
fchown32.2
getegid32.2
geteuid32.2
getgid32.2
getgroups32.2
getresgid32.2
getresuid32.2
getuid32.2
lchown32.2
setfsgid32.2
setfsuid32.2
setgid32.2
setgroups32.2
setregid32.2
setresgid32.2
setresuid32.2
setreuid32.2
setuid32.2
    mtk
        Added as link to corresponding page without "32".

fcntl64.2
fstat64.2
fstatat64.2
fstatfs64.2
ftruncate64.2
getdents64.2
lstat64.2
pread64.2
pwrite64.2
sendfile64.2
stat64.2
statfs64.2
truncate64.2
    mtk
        Added as link to corresponding page without "64".

__clone2.2
clone2.2
    mtk
        Links to clone.2.

ugetrlimit.2
    mtk
        Link to getrlimit.2.

mq_notify.2
mq_open.2
mq_timedreceive.2
mq_timedsend.2
mq_unlink.2
    mtk
        Added as links to corresponding section 3 pages.

fadvise64.2
fadvise64_64.2
    mtk
        Links to posix_fadvise.2.

rt_sigaction.2
rt_sigpending.2
rt_sigprocmask.2
rt_sigtimedwait.2
    mtk
        Added as link to corresponding page without "rt_" prefix.

rt_sigqueueinfo.2
    mtk
        Link to sigqueue.2.

madvise1.2
tuxcall.2
vserver.2
    mtk / Ivana Varekova
        Link to unimplemented.2.


Changes to individual pages
---------------------------

access.2
    mtk
        Fairly substantial rewrites of various parts,
        and a few additions.

chmod.2
    mtk
        Update SYNOPSIS to reflect the fact that fchmod(2) needs
        either "#define _XOPEN_SOURCE 500" or "#define _BSD_SOURCE".

chown.2
    mtk
        Update SYNOPSIS to reflect the fact that fchmod(2) and lchown(2)
        need either "#define _XOPEN_SOURCE 500" or "#define _BSD_SOURCE".
        Added an example program.

killpg.2
    mtk
        Note that killpg() is actually a library function on Linux.

mmap.2
    mtk
        Added note that glibc mmap() wrapper nowadays invokes mmap2().

mmap2.2
    Ivana Varekova / mtk
        On most platforms the unit for 'offset' is 4096 bytes, not
        the system page size.
    mtk
        Rewrote NOTES to note that glibc mmap() wrapper nowadays
        invokes this system call.
    mtk
        Added an EXAMPLE program.

oldfstat.2
oldlstat.2
oldstat.2
    mtk
        Changed link to point to stat.2 (instead of obsolete.2).

olduname.2
oldolduname.2
    mtk
        Changed link to point to uname.2 (instead of obsolete.2).

sched_setaffinity.2
    Martin Röhricht
        Added _GNU_SOURCE to SYNOPSIS.

semctl.2
    mtk
        Remove reference discussion of ipc(2), since none of the
        other System V IPC pages mention ipc(2).

semop.2
    mtk
        Add an example code segment.

shmctl.2
    mtk
        Add svipc(7) to SEE ALSO list.

sigaction.2
    mtk
        Reformatted tables as lists; other minor reformattings and
        wording changes.

sigqueue.2
    mtk
        Added info on rt_sigqueueinfo(2).

sigwaitinfo.2
    mtk
        Noted that sigwaitinfo() is a library function implemented on
        top of sigtimedwait().

ssetmask.2
    mtk
        Make this link point to new sgetmask.2 instead of signal.2.

stat.2
    mtk
        Add notes on the different system call interfaces that
        have appeared over time.

syscalls.2
    mtk
        A fairly substantial rewrite of this page,
        bringing it up to date with the current
        kernel version, and listing all system calls
        in tabular form.

uname.2
    mtk
        Add notes on the different system call interfaces that
        have appeared over time.

unimplemented.2
    mtk
        Add vserver, madvise1 to NAME line.
        Removed SEE ALSO reference to obsolete.2.
    Ivana Varekova
        Add tuxcall to NAME line.

mktemp.3
    Patrick Mansfield
        Fix description of return value.

strcat.3
    Marc Boyer
        Minor fix to example program.

undocumented.3
    mtk
        Add section numbers to function names; remove some functions
        since they are documented.

proc.5
    mtk
        Update/correct text on /proc/malloc.
    mtk, after a note by Pierre Habouzit, and a few comments by Justin Pryzby
        Update description of /proc/PID/stat to match 2.6.21.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=417933

inotify.7
    mtk
        IN_DONT_FOLLOW and IN_ONLYDIR are only available from 2.6.15.

signal.7
    Stepan Kasal / mtk
        Note SIGRTMIN value depends on glibc.
    mtk
        Various rewrites and additions to the text in real-time signals.
        Add SEE ALSO reference to sgetmask.2.

svipc.7
    mtk
        Add ipc(2) to SEE ALSO.


==================== Changes in man-pages-2.64 ====================

Released: 2007-07-27


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Aleksandr Koltsoff <czr@iki.fi>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Justin Pryzby <justinpryzby@users.sourceforge.net>

Apologies if I missed anyone!


Global changes
--------------

INFINITY.3
_exit.2
a64l.3
abs.3
acct.2
acosh.3
addseverity.3
adjtime.3
asinh.3
atanh.3
atoi.3
brk.2
cbrt.3
cfree.3
chdir.2
chmod.2
chown.2
clearenv.3
clock_getres.3
clone.2
confstr.3
copysign.3
ctermid.3
ctime.3
daemon.3
dirfd.3
div.3
drand48.3
drand48_r.3
dysize.3
ecvt.3
ecvt_r.3
erf.3
euidaccess.3
exp2.3
expm1.3
fdatasync.2
ferror.3
fexecve.3
fgetgrent.3
fgetpwent.3
finite.3
flockfile.3
fopen.3
fpclassify.3
fsync.2
futimes.3
fwide.3
gamma.3
gcvt.3
getcwd.3
getdate.3
getdirentries.3
getdomainname.2
getdtablesize.2
getgrent.3
getgrent_r.3
getgrouplist.3
getgroups.2
gethostbyname.3
gethostid.2
gethostname.2
getlogin.3
getmntent.3
getpagesize.2
getpw.3
getpwent.3
getpwent_r.3
getpwnam.3
getsid.2
getspnam.3
gettimeofday.2
getumask.3
getusershell.3
gsignal.3
hypot.3
inet.3
initgroups.3
insque.3
isalpha.3
iswblank.3
j0.3
kill.2
killpg.2
lgamma.3
lockf.3
log1p.3
log2.3
logb.3
longjmp.3
lrint.3
lround.3
madvise.2
mbsnrtowcs.3
memfrob.3
mincore.2
mkdtemp.3
mknod.2
mkstemp.3
mktemp.3
nan.3
nanosleep.2
nextafter.3
nice.2
on_exit.3
perror.3
posix_memalign.3
posix_openpt.3
printf.3
profil.3
psignal.3
putenv.3
putpwent.3
qecvt.3
rand.3
random.3
rcmd.3
readahead.2
readlink.2
realpath.3
remainder.3
remquo.3
rexec.3
rint.3
round.3
rpmatch.3
scalb.3
scandir.3
scanf.3
seekdir.3
select.2
sem_wait.3
semop.2
setbuf.3
setenv.3
seteuid.2
setjmp.3
setnetgrent.3
setpgid.2
setresuid.2
setreuid.2
sigaltstack.2
siginterrupt.3
significand.3
sigqueue.2
sigvec.3
sigwaitinfo.2
sockatmark.3
stat.2
stime.2
strdup.3
strerror.3
strsep.3
strtod.3
strtok.3
strtol.3
strtoul.3
symlink.2
sync.2
syscall.2
syslog.3
tcgetsid.3
telldir.3
tempnam.3
termios.3
tgamma.3
timegm.3
toascii.3
trunc.3
truncate.2
ttyslot.3
tzset.3
ualarm.3
unlocked_stdio.3
unshare.2
usleep.3
vfork.2
vhangup.2
wait.2
wait4.2
wcscasecmp.3
wcsncasecmp.3
wcsnlen.3
wcsnrtombs.3
wcswidth.3
wordexp.3
wprintf.3
    mtk
        Added/updated feature test macro requirements for
        glibc; see feature_test_macros.7 for details.

Changes to individual pages
---------------------------

mq_notify.2
mq_open.2
mq_timedreceive.2
mq_timedsend.2
mq_unlink.2
    mtk
        Fix broken link

setpgid.2
    mtk
        Fairly substantial changes and corrections, including adding
        coverage of all of the interfaces that get/set PGIDs.

syscalls.2
    mtk / aeb
        Various rewordings; clear up some imprecisions.

lgamma.3
    mtk
        Added 'signgam' to SYNOPSIS and NAME line.

strerror.3
    mtk
        Note that the XPG version is provided since glibc 2.3.4.
        The page formerly said that the GNU-specific version
        is provided by default.  That certainly isn't true
        nowadays, since _POSIX_C_SOURCE is set to 200112L by
        default, so that the XSI-compliant version is supplied
        by default.

man-pages.7
    mtk
        Added note pointing to feature_test_macros.7 for a description
        of how feature test macro requirements should be specified in
        manual pages.  Various other minor fixes and changes.

feature_test_macros.7
    mtk
        Added note about how feature test macros are specified
        in manual pages.
        Many other corrections, improvements, additions, and
        details about differences across glibc versions.


==================== Changes in man-pages-2.65 ====================

Released: 2007-09-17


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Aleksandr Koltsoff <czr@iki.fi>
Andi Kleen <ak@suse.de>
Anton Blanchard <anton@samba.org>
Ari Entlich <lmage11@twcny.rr.com>
Carsten Emde <Carsten.Emde@osadl.org>
François Diakhate <diakhate@enseirb.fr>
Geoff Clare <gclare@gclare.org.uk>
Jon Burgess <jburgess777@googlemail.com>
Julien Cristau <jcristau@debian.org>
Lee Schermerhorn <Lee.Schermerhorn@hp.com>
Mats Wichmann <mats.d.wichmann@intel.com>
Maxime Bizon <mbizon@freebox.fr>
Maxime Vaudequin <maxime.vaudequin@gmail.com>
Michael Prokop <mika@grml.org>
Mike Frysinger <vapier@gentoo.org>
Nicolas François <nicolas.francois@centraliens.net>
Nicolas George <nicolas.george@ens.fr>
Paul Brook <paul@nowt.org>
Reuben Thomas <rrt@sc3d.org>
Sam Varshavchik <mrsam@courier-mta.com>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Thomas Huriaux <thomas.huriaux@gmail.com>
Tolga Dalman <tdalman@project-psi.org>
Ulrich Drepper <drepper@redhat.com>
Vincent Lefevre <vincent@vinc17.org>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.

Various pages
    mtk
        Use 'glibc' consistently to refer to GNU C library.

Various pages
    mtk
        Order errors under ERRORS alphabetically.

Various pages
    Nicolas François
        Spelling and formatting fixes, as per
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=439560

intro.2
select.2
fmtmsg.3
getgrent_r.3
envz_add.3
rtime.3
strptime.3
wordexp.3
    Maxime Vaudequin
        Add "#include <stdlib.h>" (to declare exit(3)) to example program.


New pages
---------

timeradd.3
    mtk
        Description of timeradd(), timersub(), timerclear(),
        timerisset(), timercmp() macros for operating on
        struct timeval.


Removed pages
-------------

fdatasync.2
    mtk
        Somehow, over time, material on fdatasync(2) crept into
        fsync.2, and fdatasync also got added to the NAME section
        of fsync.2.  All of the material in fdatasync.2 that was
        not already in fsync.2 has now been moved there, and
        the former page has been removed.
        In place of the content there, is now a link to fsync.2.


New links
---------

clock_getres.2
clock_gettime.2
clock_settime.2
    mtk
        Link to man3/clock_getres.3.

fdatasync.2
    mtk
        Link to fsync.2.

fdopendir.3
    mtk
        Link to opendir.3.

gethostbyaddr_r.3
    Mats Wichmann
        Link to gethostbyaddr.3.

timerclear.3
timercmp.3
timerisset.3
timersub.3
    mtk
        Links to new timeradd.3.


Changes to individual pages
---------------------------

Makefile
    Mike Frysinger
        Make the install target of man-pages respect the standard
        "DESTDIR" variable as well as check the exit status of the
        install command so errors aren't ignored.

get_mempolicy.2
    Lee Schermerhorn
        changed the "policy" parameter to "mode" through out the
        descriptions in an attempt to promote the concept that the memory
        policy is a tuple consisting of a mode and optional set of nodes.

        added requirement to link '-lnuma' to synopsis

        rewrite portions of description for clarification.

        added all errors currently returned by sys call.

        removed cautionary note that use of MPOL_F_NODE|MPOL_F_ADDR
        is not supported.  This is no longer true.

        added mmap(2) to SEE ALSO list.

getitimer.2
    mtk
        Since kernel 2.6.22, Linux setitimer() now conforms to POSIX.1,
        giving an EINVAL error for a non-canonical tv_usec value.

gettimeofday.2
    mtk
        Replace discussion of timer* macros with a pointer
        to new page timeradd.3.

ioctl_list.2
    Nicolas George
        Fixed argument type for BLKGETSIZE.

mbind.2
    Lee Schermerhorn

        changed the "policy" parameter to "mode" throughout the
        descriptions in an attempt to promote the concept that the memory
        policy is a tuple consisting of a mode and optional set of nodes.

        rewrite portions of description for clarification.

            clarify interaction of policy with mmap()'d files and shared
            memory regions, including SHM_HUGE regions.

            defined how "empty set of nodes" specified and what this
            means for MPOL_PREFERRED.

            mention what happens if local/target node contains no
            free memory.

            clarify semantics of multiple nodes to BIND policy.
            Note:  subject to change.  We'll fix the man pages when/if
                   this happens.

        added all errors currently returned by sys call.

        added mmap(2), shmget(2), shmat(2) to SEE ALSO list.

mmap.2
mprotect.2
    François Diakhate
        Add text noting that PROT_WRITE may (and on x86 does)
        imply PROT_READ.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=441387

nfsservctl.2
    Aleksandr Koltsoff
        Fix prototype.

oldfstat.2
oldlstat.2
oldstat.2
    mtk
        Fix broken link

prctl.2
    mtk
        Update arches/kernel versions for PR_SET_UNALAIGN / PR_GET_UNALIGN.

readahead.2
    mtk
        Removed SEE ALSO reference to nonexistent fadvise.2.

reboot.2
    mtk
        Place SYNOPSIS comments inside C comments (/* ... */).

sched_setaffinity.2
    Samuel Thibault
        Note what thread is affected if 'pid' is specified
        as 0, or as the value returned by getpid().

sched_setscheduler.2
    Carsten Emde
        Add text on real-time features of mainline Linux kernel.

select_tut.2
    mtk
        sync SYNOPSIS with select.2

set_mempolicy.2
    Lee Schermerhorn

        changed the "policy" parameter to "mode" throughout the
        descriptions in an attempt to promote the concept that the memory
        policy is a tuple consisting of a mode and optional set of nodes.

        added requirement to link '-lnuma' to synopsis

        rewrite portions of description for clarification.

            clarify interaction of policy with mmap()'d files.

            defined how "empty set of nodes" specified and what this
            means for MPOL_PREFERRED.

            mention what happens if local/target node contains no
            free memory.

            clarify semantics of multiple nodes to BIND policy.
            Note:  subject to change.  We'll fix the man pages when/if
                   this happens.

        added all errors currently returned by sys call.

        added mmap(2) to SEE ALSO list.

sigaction.2
    mtk
        s/si_sign/si_errno/ in statement about which field is unused.
    Ari Entlich
        s/SIGILL/SIGCHLD/ for paragraph describing SIGCHLD.

stat.2
    mtk
        Improve text describing underlying system calls.

swapon.2
    Michael Prokop
        EINVAL also occurs if target path is on tmpfs or similar.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=435885

sync.2
    mtk
        Incorporated material from now deleted fdatasync.2.

syscall.2
    mtk
        Small fix in example program.

uname.2
    mtk
        Improve text describing underlying system calls.

utime.2
    Vincent Lefevre / mtk
        Clarify utimes() behaviour when 'times' is NULL.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=431480
    mtk
        Other minor clarifications of description of utimes().

copysign.3
    Vincent Lefevre
        s/sign/sign bit/ to remove ambiguity in description.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=435415

euidaccess.3
    mtk
        Changed NOTES to VERSIONS.

ffsl.3
    mtk
        Add ffsl and ffsll to NAME line.

fts.3
    mtk
        Removed statement that fts functions are expected to appear
        soon in POSIX; it's years old and has not yet come to pass.

ftw.3
    mtk / Geoff Clare
        Fixes/improvements for example program.

getdate.3
    mtk
        Add getdate_r to NAME section.

getaddrinfo.3
    mtk / Geoff Clare
        Fixes/improvements for example program.

gethostbyaddr.3
    Mats Wichmann
        Add documentation for gethostbyaddr_r().
        Plus a few other small fixes.

gethostbyname.3
    mtk
        Add gethostbyname2, gethostbyname2_r, gethostbyname_r,
        gethostent_r to NAME line.

getmntent.3
    mtk
        Fix misnamed function references.

getopt.3
    Jon Burgess
        Fix small error in example program.

getrpcent.3
    mtk
        Add setrpcent and endrpcent to NAME line.

gsignal.3
    Aleksandr Koltsoff
        Fix gsignal() prototype.

hsearch.3
    mtk
        Add hcreate_r, hdestroy_r, hsearch_r to NAME line.

inet.3
    Maxime Bizon
        Correct definition of "struct in_addr".

isatty.3
    mtk
        Minor wording fix.

isgreater.3
    mtk
        Add islessequal to NAME line.

lgamma.3
    Vincent Lefevre
        Fix CONFORMING TO section.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=417592

log1p.3
    mtk
        Add log1pf and log1pl to NAME line.

longjmp.3
    Paul Brook / mtk
        After a call to longjmp(), the values of modified, non-volatile
        variables in the function that called setjmp() are unspecified.

makecontext.3
    Aleksandr Koltsoff
        Fix makecontext() prototype.

malloc.3
    mtk / Tolga Dalman
        Explain what happens for malloc(0), or calloc() where one of the
        arguments is 0.
    mtk
        Added notes on malloc()'s use of sbrk() and mmap().
    mtk
        Add mmap(2), alloca(3) to SEE ALSO.

mq_close.3
mq_getattr.3
mq_notify.3
mq_open.3
mq_receive.3
mq_send.3
mq_unlink.3
    mtk
        Add "Link with -lrt." to SYNOPSIS.

opendir.3
    Ulrich Drepper; some edits and additional text by mtk
        Document fdopendir().

readdir.3
    mtk, after a note by Andi Kleen
        Document DT_* constants for d_type.
    Ulrich Drepper / mtk
        Rework discussion of non-standard structure fields.

sem_wait.3
    mtk
        Minor improvements to example program.

syslog.3
    mtk
        Add vsyslog to NAME section.

termios.3
    Nicolas François
        Fix XCASE feature test macro description.

wcsspn.3
    Aleksandr Koltsoff
        Add return type to prototype.

proc.5
    mtk
        Improve description of num_threads field under /proc/PID/stat.
    Maxime Vaudequin
        Fix path error (s%proc/sys%proc/sys/kernel%) in mentions of
        /proc/sys/ostype, /proc/sys/osrelease and proc/sys/version.
    Maxime Vaudequin
        I noticed things to correct and to clarify in subsection
        "/proc/filesystems" of proc.5:
        - clarify filesystems listing: not only FS compiled
          into the kernel, also FS kernel modules currently loaded
        - add a reference to fs(5)
        - add an explanation for FS marked with "nodev"
        - s/mount(1)/mount(8)/, also corrected in section "SEE ALSO"
        - clarify usage by mount: the current wording may lead to
          think /proc/filesystems is always used by mount when no FS
          is specified. So, usage of "may" which IMHO is more
          appropriate + additional explanations
          In mount(8) we can see:

               If no -t option is given, or if the auto type is
               specified, mount will try to guess the desired type.
               If mount was compiled with the blkid library, the
               guessing is done by this library. Otherwise, mount
               guesses itself by probing the superblock; if that
               does not turn up anything that looks familiar,
               mount will try to read the file /etc/filesystems,
               or, if that does not exist, /proc/filesystems.
               All of the filesystem types listed there will be
               tried, except for those that are labeled "nodev"
               (e.g., devpts, proc and nfs). If /etc/filesystems
               ends in a line with a single * only, mount will
               read /proc/filesystems afterwards.
    Samuel Thibault
        Since linux 2.6.11, /proc/stat has an eighth value for cpu
        lines: stolen time, which is the time spent in other operating
        systems when running in a virtualized environment.

arp.7
        Updated BUGS text referring to jiffies; refer to time.7 instead.

credentials.7
    mtk
        Add words to note that file system ID is Linux specific.

hier.7
    Maxime Vaudequin
        This is some corrections for hier.7:
        - missing period for /media and /mnt
        - /mnt description is not totally correct, it is true for some
          distributions but in others /mnt is used as a temporary FS
          mount point, as it is specified by FHS:
          http://www.pathname.com/fhs/pub/fhs-2.3.html#MNTMOUNTPOINTFORATEMPORARILYMOUNT
        - s/X-Windows/X-Window/ (3 occurrences)
        - section "SEE ALSO": s/mount(1)/mount(8)/

man-pages.7
man.7
mdoc.7
mdoc.samples.7
    mtk / Nicolas François
        Nowadays tmac.XXX are called XXX.tmac.

pthreads.7
    mtk
        Update text about modern threading implementations
        (NPTL vs LinuxThreads).

socket.7
    mtk, after a note by Andi Kleen
        Clarify that SO_SNDTIMEO and SO_RCVTIMEO only have effect for
        socket I/O calls; not for multiplexing system calls like
        select() and poll().

time.7
    mtk
        Add SEE ALSO reference to new timeradd.3.


==================== Changes in man-pages-2.66 ====================

Released: 2007-10-01


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Amit K. Arora <aarora@linux.vnet.ibm.com>
David Chinner <dgc@sgi.com>
Fredrik Noring <noring@nocrew.org>
Mats Wichmann <mats.d.wichmann@intel.com>
Maxime Vaudequin <maxime.vaudequin@gmail.com>
Ollie Wild <aaw@google.com>
Ulrich Drepper <drepper@redhat.com>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several
places.


New pages
---------

fallocate.2
    David Chinner, with some input from Amit Amora and mtk
        Describes the fallocate() system call, new in 2.6.23.


Changes to individual pages
---------------------------

close.2
    Fredrik Noring
        Add text cautioning about use of close() in
        multithreaded programs.

execve.2
    Ollie Wild / mtk
        Add text describing limit on total size of argv + envp,
        and changes that occurred with 2.6.23.
    mtk
        Add getopt(3) to SEE ALSO list.

open.2
    mtk, Acked by Ulrich Drepper
        Added description of O_CLOEXEC (new in 2.6.23) + other
        minor fixes for O_DIRECT.

recv.2
    mtk
        Added description of MSG_CMSG_CLOEXEC (new in 2.6.23).

sysctl.2
    mtk
        Strengthened the warning against using this system call
        and note that it may disappear in a future kernel version.

rpc.3
    Mats Wichmann
        Fix type definition for 'protocol' in prototypes of pmap_set()
        and pmap_getport().


==================== Changes in man-pages-2.67 ====================

Released: 2007-10-08


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
Andrew Josey <a.josey@opengroup.org>
Maxime Vaudequin <maxime.vaudequin@gmail.com>

Apologies if I missed anyone!


Global changes
--------------

*.1p
*.3p
    mtk, after a note by Andi Kleen and consultation with Andrew Josey.
        Add a PROLOG section:
            This manual page is part of the POSIX Programmer's Manual.
            The Linux implementation of this interface may differ
            (consult the corresponding Linux manual page for details
            of Linux behavior), or the interface may not be implemented
            on Linux.

*.0p
*.1p
*.3p
    mtk
        Some formatting fixes, mostly to get rid of unwanted
        spaces before "," in formatted output.

*
*/*
    mtk
        Change all occurrences of my email address in man-pages source
        to my new gmail address.

Many many pages
    Maxime Vaudequin
        I noticed useless use of macros with alternating formatting
        (".IR" instead ".I" which suffices, ".BR" instead ".B", etc.)
        because there is only one element.  For example in ldconfig.8:

            -.BR /sbin/ldconfig
            +.B /sbin/ldconfig

        This is not very important, it only makes the sources more tidy.
        To find these I used:

            egrep '^\.(B[RI]|R[IB]|I[RB]) ([^ ]+|\"[^\"]\+\")$'

        And if you want to make these changes, you can use:

            sed 's/^\(\.[BRI]\)[BRI]\( \([^ ]\+\|\"[^\"]\+\"\)\)$/\1\2/g'


==================== Changes in man-pages-2.68 ====================

Released: 2007-11-19


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

A. Costa <agcosta@gis.net>
Andrew McDonald <andrew@mcdonald.org.uk>
Geoff Clare <gclare@gclare.org.uk>
Heikki Orsila <shd@modeemi.cs.tut.fi>
Hyokyong Kim <hyokyong@ppj.kr>
Ivana Varekova <varekova@redhat.com>
Justin Pryzby <jpryzby+d@quoininc.com>
Maxime Vaudequin <maxime.vaudequin@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Nicolas François <nicolas.francois@centraliens.net>
Pádraig Brady <P@draigBrady.com>
Sam Varshavchik <mrsam@courier-mta.com>
Timo Juhani Lindfors <timo.lindfors@iki.fi>
Ulrich Drepper <drepper@redhat.com>

Apologies if I missed anyone!


Global changes
--------------

faccessat.2
fchmodat.2
fchownat.2
fstatat.2
futimesat.2
linkat.2
mkdirat.2
mknodat.2
readlinkat.2
renameat.2
symlinkat.2
mkfifoat.3
    mtk, after http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=445436
        by Timo Juhani Lindfors
        Added <fcntl.h> to SYNOPSIS.

Typographical or grammatical errors have been corrected in several places.


New pages
---------

_syscall.2
    mtk
        Created as a new page, by taking the content specific to
        the _syscall() macros from intro(2).


Changes to individual pages
---------------------------

README
    mtk
        Brought up to date.

man-pages-*-Announce
    mtk
        Brought the info in here up to date.

intro.1
    mtk
        Added intro paragraph about section, plus a paragraph
        about exit status values.
        Move "user intro" text to NOTES.

get_mempolicy.2
    mtk
        Reorder ERRORS sections alphabetically

intro.2
    mtk
        Pretty much a complete rewrite, covering some additional topics.
        Moved _syscallN() material to new _syscall(2) page.

mbind.2
    mtk
        Reorder ERRORS sections alphabetically

mmap.2
    Maxime Vaudequin
        Fix syntax error in example program.

prctl.2
    mtk
        Linux 2.6.22 added support on Alpha for PR_SET_UNALIGN.

ptrace.2
    Nicolas François / mtk
        s/PTRACE_POKEUSR/PTRACE_POKEUSER/
        s/PTRACE_PEEKUSR/PTRACE_PEEKUSER/

read.2
    mtk / Geoff Clare
        Add text describing timerfd EINVAL error for read(2).

set_mempolicy.2
    mtk
        Reorder ERRORS sections alphabetically

syscall.2
    mtk
        Added _syscall(2) and intro(2) to SEE ALSO section.

syscalls.2
    mtk
        Added fallocate(2); removed timerfd(2).

sysinfo.2
    mtk
        Removed reference to example in intro(2).

dlopen.3
    mtk
        Added "Link with -ldl." to SYNOPSIS.

getaddrinfo.3
    Ulrich Drepper / mtk
        Remove references to getipnodebyname.3 and getipnodebyaddr.3.

gethostbyname.3
    mtk / Ulrich Drepper
        Remove SEE ALSO references to getipnodebyname.3 and
        getipnodebyaddr.3.

    Pádraig Brady / mtk / Ulrich Drepper
        Point out that the functions described on this page
        are made obsolete by getaddrinfo(3) and getnameinfo(3).

getipnodebyname.3
    mtk
        Clarify that glibc does not implement these functions.

glob.3
    Ulrich Drepper / mtk
        Fix description of GLOB_ONLYDIR.
    mtk
        Added description of GLOB_TILDE_NOMATCH.
        Expanded the description of various flags.
        Various wording fixes..

intro.3
    mtk
        Pretty much a complete rewrite, covering some additional topics.

posix_fallocate.3
    mtk
        Add SEE ALSO referring to fallocate.2.

rpc.3
    Sam Varshavchik
        Add some arg declarations to prototypes; fix typos.

setbuf.3
    Mike Frysinger
        Fix text in BUGS section.

sigset.3
    mtk
        The sigset() bugs were fixed in glibc 2.5.
        See http://sourceware.org/bugzilla/show_bug.cgi?id=1951

intro.4
    mtk
        Minor rewrites.

st.4
    Maxime Vaudequin
        Various small corrections, formattings and modifications.

elf.5
    Mike Frysinger
        Document:
        - new p_flag: PT_GNU_STACK
        - new sections: .gnu.version .gnu.version_d .gnu.version_r
          .note.GNU-stack
        - new structures: ElfN_Verdef ElfN_Verdaux ElfN_Verneed
          ElfN_Vernaux

intro.5
    mtk
        Minor rewrites.

proc.5
    Ivana Varekova / mtk
        Add text noting that since kernel 2.6.16, /proc/slabinfo is
        only available if CONFIG_SLAB is enabled.
    Maxime Vaudequin
        Update description of /proc/pci.
    Maxime Vaudequin
        Give italic formatting to file names in proc.5.
    mtk
        The display type of the /proc/PID/stat fields changed
        %lu to %u in Linux 2.6.22:
            flags
            rt_priority
            policy

slabinfo.5
    Ivana Varekova / mtk
        Add text noting that since kernel 2.6.16, /proc/slabinfo is
        only available if CONFIG_SLAB is enabled.

intro.6
    mtk
        Minor rewrites.

bootparam.7
    Maxime Vaudequin
        Update references to files in kernel "Documentation" directory.

intro.7
    mtk
        Minor rewrites.

ipv6.7
    Andrew McDonald
        Fix description of IPV6_ROUTER_ALERT option.

standards.7
    mtk
        Note online location of C99 standard.

intro.8
    mtk
        Some rewrites, plus new paragraph on exit status values.


==================== Changes in man-pages-2.69 ====================

Released: 2007-12-03


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Adam Borowski <kilobyte@angband.pl>
Alain Portal <aportal@univ-montp2.fr>
Andries E. Brouwer <Andries.Brouwer@cwi.nl>
J. Bruce Fields <bfields@citi.umich.edu>
David Härdeman <david@hardeman.nu>
Jeremy Kerr <jk@ozlabs.org>
Luke Browning <lukebr@linux.vnet.ibm.com>
Mats Wichmann <mats.d.wichmann@intel.com>
Maxime Vaudequin <maxime.vaudequin@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Reuben Thomas <rrt@sc3d.org>
Sam Varshavchik <mrsam@courier-mta.com>

Apologies if I missed anyone!


Global changes
--------------

*.[013]p
    mtk
        Many whitespace clean-ups in formatted output.

mprotect.2
bind.2
mq_notify.3
makecontext.3
fmemopen.3
    David Härdeman / mtk
        Rename error handling function in example program
        (s/die/handle_error/).

Typographical or grammatical errors have been corrected in several places.


Removed pages
-------------

HOWTOHELP
MAINTAINING
    mtk
        The content of these files is now available in HTML format.

New links
---------

cfsetspeed.3
    mtk
        Link to termios.3.


Changes to individual pages
---------------------------

time.1
    Alain Portal
        Added "Linux User's Manual" to .TH line.

_syscall.2
    aeb / mtk
        Remove outdated text about pointer blocks for syscalls that have
        more than 5 arguments.

fcntl.2
    J. Bruce Fields
        Add warning that mandatory locking is unreliable.
    J. Bruce Fields
        Clarify details in description of file leases.
    J. Bruce Fields / mtk
        Minor wording edits.
    J. Bruce Fields
        Add F_GETLEASE under RETURN VALUE.

mmap.2
    mtk
        Handle errors using a custom handle_error() macro.

sched_setscheduler.2
    Mats Wichmann
        Add BUGS text noting that the return value from Linux
        sched_setschuler() does not conform to POSIX.

spu_create.2
    Jeremy Kerr
        Various updates and improvements.
    Luke Browning
        Refinement of text describing a "gang".
    mtk
        Minor edits.

spu_run.2
    Jeremy Kerr
        Various updates and improvements.
    mtk
        Minor edits.

err.3
    mtk
        Remove HISTORY section.

fopen.3
    Mike Frysinger
        Document 'e' (close-on-exec) option, new in glibc 2.7.

getloadavg.3
    Alain Portal / mtk
        Remove HISTORY section.

printf.3
    Andries E. Brouwer / mtk
        Fix the discussion of stdarg macros in the description of
        vprintf() description.

sem_wait.3
    mtk
        Handle errors using a custom handle_error() macro.

sigsetops.3
    Mats Wichmann
        Note that sigset_t objects must be initialized
        with sigemptyset() or sigfillset() before the other
        macros are employed.

termios.3
    mtk, after a note by Alain Portal
        Added cfsetspeed() to SYNOPSIS.  Added text under CONFORMING TO
        noting that cfsetspeed() is BSD specific.

ttyslot.3
    Alain Portal
        Various references to "getty" were changed to "mingetty", since
        that is the manual page more likely to be found on current
        systems.  (Completes changes that were made in man-pages-2.44.)

initrd.4
    mtk, after a note by Alain Portal
        Move "Configuration" section to top of page (like other
        section 4 pages) and make it a .SH section.

full.4
    mtk
        Re-ordered CONFIGURATION section to go before DESCRIPTION.

sk98lin.4
    Maxime Vaudequin
        Fix reference to kernel Documentation file.

elf.5
    mtk
        Renamed HISTORY section to NOTES, and removed BSD specific info.

proc.5
    Maxime Vaudequin
        Mention grub(8) in same sentence as lilo(8).
    Maxime Vaudequin
        Improve description of /proc/sys/abi and
        /proc/sys/kernel/modprobe.

utmp.5
    Alain Portal
        Various references to "getty" were changed to "mingetty", since
        that is the manual page more likely to be found on current
        systems.  (Completes changes that were made in man-pages-2.44.)

iso_8859-2.7
    Adam Borowski
        Reverse the 2.68 change applied by mtk in response to
        http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=445085
        that replaced "Sorbian" with "Serbian".
        (Sorbian is a language of 50000 people in Brandenburg.)

man-pages.7
    mtk
        Added CONFIGURATION to list of "standard" section names.

spufs.7
    Jeremy Kerr
        Various updates and improvements.
    mtk
        Minor edits.

tcp.7
    Maxime Vaudequin
        Fix reference to kernel Documentation file.


==================== Changes in man-pages-2.70 ====================

Released: 2007-12-06


Global changes
--------------

Many pages
    mtk
        Remove section numbers for page references where the
        reference refers to the page itself.  (This stops man2html
        producing links from a page back to itself.)

Typographical or grammatical errors have been corrected in several places.


Changes to individual pages
---------------------------

get_mempolicy.2
    mtk
        Add CONFORMING TO section.

io_getevents.2
    mtk
        Remove redundant SEE ALSO entry.

mbind.2
    mtk
        Add CONFORMING TO section.

msgop.2
    mtk
        Remove redundant SEE ALSO entries.

sigprocmask.2
    mtk
        Remove redundant SEE ALSO entry.

splice.2
    mtk
        Remove redundant SEE ALSO entry.
        Add SEE ALSO referring to vmsplice(2).

csin.3
    mtk
        Remove redundant SEE ALSO entry.
        Add SEE ALSO referring to ccos(3).

gethostbyname.3
    mtk
        Add gethostbyaddr_r to NAME section.

rint.3
    mtk
        Remove redundant SEE ALSO entry.

sigsetops.3
    mtk
        Minor rewording.

epoll.7
    mtk
        Minor rewording.


==================== Changes in man-pages-2.71 ====================

Released: 2007-12-14


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
John Sigler <linux.kernel@free.fr>
Josh Triplett <josh@freedesktop.org>
Mats Wichmann <mats.d.wichmann@intel.com>
Pascal MALAISE <malaise@magic.fr>
Sam Varshavchik <mrsam@courier-mta.com>

Apologies if I missed anyone!


Global changes
--------------

err.3
fts.3
getloadavg.3
queue.3
rcmd.3
rexec.3
stdin.3
elf.5
operator.7
    mtk
        Replaced the use of mdoc macros on these pages with man
        macros.  The only pages in man-pages that still use
        mdoc macros are mdoc.7 and mdoc.samples.7.

Typographical or grammatical errors have been corrected in several places.


Deleted pages
-------------

TODO
    mtk
        This information is now on the website.


Changes to individual pages
---------------------------

Changes.old
    mtk
        Reformat various change log entries to use a consistent format.
        Expand Debian bug report numbers to be URLs.
        Other minor tidy-ups.

fcntl.2
    mtk
        Document the F_DUPFD_CLOEXEC operation, which is
        new in kernel 2.6.24.

listen.2
    Josh Triplett
        Fix incorrect path for somaxconn.

getpw.3
    Alain PORTAL
        Add ENOENT error to ERRORS.

sysconf.3
    Mats Wichmann
        Add documentation of _SC_NPROCESSORS_CONF and _SC_NPROCESSORS_ONLN.

tty.4
    John Sigler
        Add tty_ioctl(4) to SEE ALSO list.

regex.7
    Pascal MALAISE <malaise@magic.fr>
        Separate text on back references from that describing basic regexps,
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=379829.
    mtk
        Remove crufty text about word boundaries.


==================== Changes in man-pages-2.72 ====================

Released: 2007-12-14


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Alex Tuninga <atuninga@google.com>
Bert Wesarg <bert.wesarg@googlemail.com>
Maxime Vaudequin <maxime.vaudequin@gmail.com>
Rob Weryk <rjweryk@uwo.ca>
Sam Varshavchik <mrsam@courier-mta.com>

Apologies if I missed anyone!


Global changes
--------------

Various pages
    Alain PORTAL / mtk
        Format include files consistently (".I <.*\.h>").

Various pages
    Alain PORTAL / mtk
        Format pathname in italics (.I).

dbopen.3
mpool.3
recno.3
    Alain PORTAL
        Remove brackets ([]) around error names.

console.4
tty.4
ttyS.4
issue.5
ttytype.5
utmp.5
    mtk / Maxime Vaudequin
        Some systems have mingetty(8), others have agetty(8), so both
        should be mentioned when we are talking about getty-style programs.


Typographical or grammatical errors have been corrected in several places.


Renamed pages
-------------

filesystems.5
    mtk / Alain PORTAL
        Was previously fs.5


New links
---------

argz.3
    Bert Wesarg / mtk
        Link to argz_add.3.

envz.3
    Bert Wesarg / mtk
        Link to envz_add.3.

fs.5
    mtk / Alain PORTAL
        Link to filesystems.5.


Changes to individual pages
---------------------------

readahead.2
    Rob Weryk
        Fix declaration of 'offset' in SYNOPSIS.

seteuid.2
    mtk
        s/SETGUID/SETEUID/ in .TH line.

__setfpucw.3
    mtk
        Fixed include files references / formatting.

abort.3
    mtk, after a note by Alex Tuninga
        A fairly significant rewrite to clarify operation of abort().

argz_add.3
    Bert Wesarg / mtk
        s/envz/envz_add/ in SEE ALSO.

basename.3
    mtk
        s/DIRNAME/BASENAME/ in .TH line, and swap function names
        in NAME section.

envz_add.3
    Bert Wesarg / mtk
        s/argz/argz_add/ in SEE ALSO.

flockfile.3
    mtk
        s/LOCKFILE/FLOCKFILE/ in .TH line.

getgrent_r.3
    mtk
        s/GETGRENT/GETGRENT_R/ in .TH line.

stdio.3
    Sam Varshavchik
        Reformat function list at end of page as a proper table.

ttyslot.3
    Maxime Vaudequin
        Revert earlier s/getty/mingetty/.  This page talks about
        historical behavior, and that means "getty(8)".

undocumented.3
    mtk
        Remove reference to "obstack stuff"; it's not clear what
        that is about.

console_ioctl.4
    mtk
        s/CONSOLE_IOCTLS/CONSOLE_IOCTL/ in .TH line.

proc.5
    mtk
        s/fs (5)/filesystems (5)/

man-pages.7
    mtk / Alain PORTAL
        Improve discussion of formatting of file names.


==================== Changes in man-pages-2.73 ====================

Released: 2007-12-14


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Pádraig Brady <P@draigBrady.com>
Reuben Thomas <rrt@sc3d.org>

Apologies if I missed anyone!


Global changes
--------------

Various pages
    Alain PORTAL
        Formatting fixes.

Typographical or grammatical errors have been corrected in several places.


Changes to individual pages
---------------------------

mknod.2
    mtk, after a report by Reuben Thomas
        Clarify use of mkfifo() versus mknod().
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=455825

fgetgrent.3
    mtk
        Small rewording.

fgetpwent.3
    mtk
        Small rewording.

rcmd.3
    mtk
        Noted feature test macro requirements.
        BUGS: noted that iruserok() is not declared in glibc headers.

filesystems.5
    mtk
        Added Reiserfs, XFS, JFS to list of file systems.


==================== Changes in man-pages-2.74 ====================

Released: 2007-12-20


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andrew Morton <akpm@linux-foundation.org>
David Brown <lkml@davidb.org>
Jeremy Kerr <jk@ozlabs.org>
Mats Wichmann <mats.d.wichmann@intel.com>
Sam Morris <sam@robots.org.uk>
Sam Varshavchik <mrsam@courier-mta.com>
Samuel Thibault <samuel.thibault@ens-lyon.org>

Apologies if I missed anyone!


Global changes
--------------

Various pages
    Alain PORTAL
        Formatting fixes.

Various pages
    mtk / Alain Portal
        s/``...''/"..."/

Various pages
    mtk
        s/epoch/Epoch/

Various pages
    mtk
        Make the standard indent for code samples, shell session
        logs, etc. to be ".in +4n".

Typographical or grammatical errors have been corrected in several places.


Changes to individual pages
---------------------------

_syscall.2
    mtk
        Nowadays there is _syscall6() also.

chroot.2
    mtk
        Various minor formatting changes.

epoll_wait.2
    mtk
        Fix types in structs.
        Formatting fixes.

mount.2
    mtk, after a note by Sam Morris
        Clarify that MS_NODIRATIME provides a subset of the
        functionality provided by MS_NOATIME.

sched_setaffinity.2
    mtk
        Minor rearrangement of text.

select_tut.2
    mtk
        Fix (my) typos in argument names.
        Formatting fixes.

spu_create.2
    Jeremy Kerr
        We can use context FDs for the dirfd argument to the *at() syscalls.

times.2
    mtk, after a note from David Brown and Andrew Morton
        http://marc.info/?l=linux-kernel&m=119447727031225&w=2
        Rework the text describing the return value to be closer
        to the requirements of POSIX.1; move Linux details
        to NOTES and add a warning not to rely on those details.
        Add a warning about the -1 to -4095 bug which results
        in a 41 second window where the glibc wrapper will wrongly
        return -1 indicating an error.
    mtk
        Remove cruft HZ text.
        Clarify text describing return value of clock(3).

getw.3
    Mats Wichmann
        CONFORMING TO: getw() and putw() were in SUSv2, but are not
        in POSIX.1-2001.

hash.3
    mtk / Alain Portal
        Minor rewordings + formatting fixes.

st.4
    Alain Portal / mtk
        Many formatting fixes.
    mtk
        Place ERRORS in alphabetical order.

vcs.4
    Samuel Thibault
        Document VT_GETHIFONTMASK (new in 2.6.18) and add to example program;
        attribute/text characters are in the host byte order.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=456437
    mtk
        Minor edits.

bootparam.7
    Alain PORTAL
        Formatting fixes.

inotify.7
    mtk
        Minor heading changes and reformattings.

man-pages.7
    mtk
        Note that code segments, structure definitions, shell session
        logs, should be indented by 4 spaces.

spufs.7
    Jeremy Kerr
        Add a little information about the differences to mbox.


==================== Changes in man-pages-2.75 ====================

Released: 2008-01-08


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andi Kleen <ak@suse.de>
Andreas Henriksson <andreas@fatal.se>
Jeremy Kerr <jk@ozlabs.org>
Justin Pryzby <jpryzby+d@quoinic.com>
Phil Endecott <spam_from_debian_bugs_4@chezphil.org>
Sam Varshavchik <mrsam@courier-mta.com>
Thomas Huriaux <thomas.huriaux@gmail.com>
Timo Sirainen <tss@iki.fi>
Trond Myklebust <trond.myklebust@fys.uio.no>

Apologies if I missed anyone!


Global changes
--------------

Various pages
    mtk
        (Grammatical) hyphenation was fixed in many places.

epoll_wait.2
mbind.2
spu_run.2
ecvt.3
fmtmsg.3
getnameinfo.3
rtc.4
proc.5
charsets.7
ip.7
ipv6.7
raw.7
uri.7
    Justin Pryzby / mtk
        Fix incorrect usage of "a" and "an" before following vowel /
        consonant, by reviewing the output of the following scripts:

            for a in  $(wc */*.? | awk '$1 > 10 {print $4}' | gv total); do
                echo $a
                MANWIDTH=4000 man -l $a 2>/dev/null |
                        egrep '(^| )an [^aeiou][a-z]'
            done | less

            for a in  $(wc */*.? | awk '$1 > 10 {print $4}' | gv total); do
                echo $a
                MANWIDTH=4000 man -l $a 2>/dev/null |
                        egrep '(^| )a [aeiou][a-z]'
            done| less

err.3
fts.3
queue.3
rcmd.3
rexec.3
stdin.3
elf.5
    mtk, after a note by Alain Portal
        Improve macros used in 2.71 to convert from "mdoc" to "man".

_exit.2
chroot.2
getgid.2
getpid.2
getrusage.2
getsid.2
gettid.2
getuid.2
iopl.2
kill.2
personality.2
pivot_root.2
ptrace.2
sched_setparam.2
sched_setscheduler.2
sched_yield.2
seteuid.2
setgid.2
setpgid.2
setresuid.2
setreuid.2
setuid.2
unlink.2
wait.2
openpty.3
raise.3
setlogmask.3
sleep.3
ttyslot.3
ulimit.3
tty.4
tty_ioctl.4
path_resolution.7
    mtk
        s/current process/calling process/

cacheflush.2
clone.2
fcntl.2
getitimer.2
getrlimit.2
mmap.2
mprotect.2
times.2
adjtime.3
byteorder.3
inet.3
offsetof.3
rtc.4
icmp.7
pipe.7
time.7
    mtk
        s/x86/i386/ since that is the name used in 'arch' directories
        in the kernel source, and previously both i386 and x86 were both
        used in man pages; also nowadays 'x86' is somewhat ambiguous,
        since it is the name of the 'arch' directory for i386 and x86-64.

conj.3
cacos.3
cacosh.3
cabs.3
carg.3
casin.3
casinh.3
catan.3
catanh.3
ccos.3
ccosh.3
cexp.3
cimag.3
clog.3
cosh.3
creal.3
csin.3
csinh.3
ctan.3
ctanh.3
sinh.3
tanh.3
    mtk
        Various reformattings.

Various pages
    Alain Portal
        Formatting fixes.

mlock.2
mprotect.2
mpool.3
offsetof.3
    Alain Portal
        Format SYNOPSIS in a manner consistent with other pages.

Various pages
    mtk / Alain Portal
        Format casts so that there is a non-breaking space after the
        type, and remove unnecessary parentheses around the casted value.
        Thus, for example, the following:

            .IR "(size_t) (\-1)" .

        becomes:

            .IR "(size_t)\ \-1" .

Various pages
    mtk / Alain Portal
        Replace "-" by "\-" where a real dash is required.

Various pages
    mtk
        Make the formatting of instances of '*varname' consistent, changing
        instances such as:

            .RI * varname

        to:

            .I *varname

pciconfig_read.2
nfsservctl.2
bstring.3
cpow.3
getipnodebyname.3
getpwnam.3
getrpcent.3
lsearch.3
malloc_hook.3
mpool.3
stdin.3
strtol.3
strtoul.3
unlocked_stdio.3
regex.3
sd.4
resolv.conf.5
utmp.5
futex.7
    mtk
        Format SYNOPSIS consistently.

drand48.3
drand48_r.3
flockfile.3
erf.3
sigvec.3
timeradd.3
wprintf.3
    mtk, after a note by Alain Portal
        Standardize sentence used under "Feature Test Macro Requirements"
        when referring to all functions shown in the SYNOPSIS.

get_kernel_syms.2
getdents.2
getitimer.2
nanosleep.2
query_module.2
statvfs.2
clock_getres.3
getaddrinfo.3
getgrent.3
getipnodebyname.3
console_ioctl.4
tty_ioctl.4
rtnetlink.7
    mtk
        Indent structure definitions by +4n.

recv.2
btree.3
dbopen.3
ether_aton.3
fts.3
hash.3
mpool.3
profil.3
rcmd.3
recno.3
rpc.3
xdr.3
console_ioctl.4
ddp.7
ip.7
ipv6.7
svipc.7
    mtk
        Use C99 standard types in declarations.
            s/u_long/unsigned long/
            s/ulong/unsigned long/
            s/u_char/unsigned char/
            s/u_short/unsigned short/
            s/ushort/unsigned short/
            s/u_int8_t/uint8_t/
            s/u_int16_t/uint16_t/
            s/u_int32_t/uint32_t/
            s/u_int/unsigned int/

exit_group.2
fallocate.2
getdents.2
ioctl_list.2
nfsservctl.2
sched_setaffinity.2
set_tid_address.2
ustat.2
argz_add.3
confstr.3
envz_add.3
getline.3
getpwnam.3
gets.3
getw.3
inet_ntop.3
inet_pton.3
offsetof.3
console_ioctl.4
termcap.5
ascii.7
feature_test_macros.7
netlink.7
operator.7
svipc.7
    mtk
        Fix unbalanced .nf/.fi pairs.

chmod.2
getxattr.2
listxattr.2
lseek.2
removexattr.2
setxattr.2
stat.2
feature_test_macros.7
fpathconf.3
fopen.3

    mtk
        Rename argument: s/file*des/fd/ , since that is the name most
        commonly used on man pages for a file descriptor argument.

bindresvport.3
des_crypt.3
getopt.3
getrpcent.3
realpath.3
rpc.3
xdr.3
    mtk
        Removed .SM macros.

madvise.2
getdirentries.3
printf.3
sigvec.3
    mtk
        Remove extraneous .br macro before/after .SH/.SS.

_syscall.2
lookup_dcookie.2
aio_cancel.3
aio_error.3
aio_fsync.3
aio_read.3
aio_return.3
aio_write.3
canonicalize_file_name.3
envz_add.3
getgrouplist.3
getttyent.3
key_setsecret.3
mtrace.3
tcgetpgrp.3
tcgetsid.3
ttyslot.3
tty_ioctl.4
    mtk
        Remove extraneous .sp macros.

fcntl.2
outb.2
send.2
syscalls.2
getopt.3
proc.5
man-pages.7
standards.7
tcp.7
    mtk
        Remove/replace extraneous .sp macros.

Typographical or grammatical errors have been corrected in several places.


Changes to individual pages
---------------------------

_syscall.2
    mtk
        Nowadays there are seven macros (see 2.74 change log also).

arch_prctl.2
    mtk, Acked by Andi Kleen
        Clarify interpretation of 'addr'; plus a few other minor edits
        and updates.

bind.2
    mtk
        Minor rewrites.

close.2
    mtk
        Clarify relationship between file descriptor and open file
        description.

connect.2
    mtk, Acked by Andi Kleen
        Since kernel 2.2, AF_UNSPEC for unconnecting a connected
        socket *is* supported.

execve.2
    Alain Portal
        Minor rewordings.

futimesat.2
    Alain Portal
        Remove duplicate "#include <fcntl.h>" from SYNOPSIS.

getgid.2
    mtk
        Add getresgid(2) and credentials(7) to SEE ALSO.

getpagesize.2
    mtk
        Small rewording.

getresuid.2
    mtk
        Rewrote various parts.

getuid.2
    mtk
        Add getresuid(2) and credentials(7) to SEE ALSO.

ioctl_list.2
    Alain Portal
        Use proper tables for layout, and various formatting fixes.
    mtk
        Various formatting fixes.

listen.2
    mtk
        Rewrote various parts.

mbind.2
    Andi Kleen / mtk / Alain Portal
        Modify explanation of EINVAL 'maxnode' error.

mmap.2
    mtk
        Add comma to clarify meaning of a sentence.

open.2
    mtk
        Clarify initial description of O_EXCL.
        Clarify description of behaviors of O_CREAT | O_EXCL
        for symbolic links.
        Clarify text describing use of lockfiles without O_EXCL.
    mtk, with input from Timo Sirainen and Trond Myklebust
        O_EXCL is supported on NFSv3 and later, with Linux 2.6 and later.

pipe.2
    mtk
        Rename 'filedes' argument 'pipefd'.

pivot_root.2
    mtk
        s/cwd/current working directory/

seteuid.2
    mtk
        Minor changes.

setpgid.2
    mtk
        Add credentials(7) to SEE ALSO, and updated copyright credits,
        to reflect my rewrite of a few months ago.

setsid.2
    mtk
        Add getsid(2) and credentials(7) to SEE ALSO.

spu_create.2
    Alain Portal / mtk; acked by Jeremy Kerr
        Minor formatting/wording changes.
    mtk
        Put EPERM in right alphabetical position in ERRORS list.

argz_add.3
    mtk
        Formatting fixes.

atexit.3
    mtk
        Minor changes to example program.

cerf.3
    mtk
        These functions are still not present as at glibc 2.7.

dbopen.3
    Alain Portal / mtk
        Various minor spelling and formatting fixes.

envz_add.3
    mtk
        Formatting fixes.

fexecve.3
    mtk
        Fix placement of feature test macro in SYNOPSIS.

fmax.3
fmin.3
    mtk
        Small rewording.

getline.3
    mtk
        Minor changes to example program.

getrpcent.3
getrpcport.3
    mtk
        Use modern C prototypes in SYNOPSIS.

getutent.3
    Alain Portal / mtk
        Formatting fixes.

mbsnrtowcs.3
mbsrtowcs.3
mbstowcs.3
    mtk
        Use .IP tags to create properly formatted lists.

rpc.3
    mtk
        Convert function declarations to use modern C prototypes.
        Add text and start of page describing header files
        and types required by functions.
        Reformat discussion of request under clnt_control().

xdr.3
    mtk
        Convert function declarations to use modern C prototypes.
        Remove crufty "int empty" from xdrrec_eof() description.

console_codes.4
    Phil Endecott
        Relocate misplaced line:
            "and if LF/NL (new line mode) is set also a carriage return;"
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=458338.

console_ioctl.4
    mtk
        Formatting fixes.

bootparam.7
    mtk, after a note by Alan Portal
        Fix reference to kernel documentation source file in the
        "The Sound Driver" subsection.

man-pages.7
    Alain Portal
        Move CONFIGURATION description after SYNOPSIS description.
    mtk / Alain Portal
        Note that header files should be surrounded by angle brackets (<>).

posixoptions.7
    mtk
        Minor formatting and wording fixes.

rtnetlink.7
    Andreas Henriksson
        Fix description of RTM_F_EQUALIZE.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=458325.

signal.7
    mtk
        Minor formatting and wording fixes.

socket.7
    mtk
        Small rewording of discussion of O_ASYNC.

spufs.7
    mtk / Jeremy Kerr / Alain Portal
        s/SPE/SPU/


==================== Changes in man-pages-2.76 ====================

Released: 2008-01-14


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Carlo Marcelo Arenas Belon <carenas@sajinet.com.pe>
Jeremy Kerr <jk@ozlabs.org>
Sam Varshavchik <mrsam@courier-mta.com>
Trond Myklebust <trond.myklebust@fys.uio.no>

Apologies if I missed anyone!


Global changes
--------------

longjmp.3
printf.3
scanf.3
setbuf.3
setjmp.3
sk98lin.4
environ.7
    mtk
        Rework/remove use of ".ad" macros.

ioctl_list.2
mlock.2
mprotect.2
mremap.2
syslog.2
cfree.3
mpool.3
offsetof.3
rpc.3
stdin.3
    mtk
        Fix unbalanced quotes in formatting macros.

ftok.3
    mtk
        s/i-node/inode/, for consistency with other pages and POSIX.1-2001.

Typographical or grammatical errors have been corrected in several places.


Changes to individual pages
---------------------------

chown.2
    mtk
        Minor wording change.

dup.2
    mtk
        Reordered text in DESCRIPTION and added some details for dup2().

open.2
    Trond Myklebust / mtk
        Minor fix to O_EXCL changes in previous release.

gettid.2
    mtk
        Rewrote DESCRIPTION; noted that thread ID is not the same
        thing as a POSIX thread ID.

pipe.2
    mtk
        Rewrote DESCRIPTION; minor additions to EXAMPLE text.

umask.2
    mtk
        A few rewrites and additions.

strptime.3
    Carlo Marcelo Arenas Belon / mtk
        Add "#define _XOPEN_SOURCE" to example program.

initrd.4
    mtk
        Use quotes more consistently in formatting macros.

random.4
    mtk, after a report by Daniel Kahn Gilmor
        Add 2.6 details for /proc/sys/kernel/random/poolsize.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=459232.

pthreads.7
    mtk
        Minor changes.

spufs.7
    mtk / Jeremy Kerr
        Define abbreviation "MSS".


==================== Changes in man-pages-2.77 ====================

Released: 2008-01-31


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Pavel Heimlich <tropikhajma@seznam.cz>
Phil Endecott <phil_vonar_endecott@chezphil.org>
Thomas Huriaux <thomas.huriaux@gmail.com>
Vincent Lefevre <vincent@vinc17.org>
WANG Cong <xiyou.wangcong@gmail.com>

Apologies if I missed anyone!


Global changes
--------------

stdarg.3
bootparam.7
    Thomas Huriaux
        Fix broken use of single quotes at start of line,
        as per: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=462636

Typographical or grammatical errors have been corrected in several places.

New pages
---------

remove_COLOPHON.sh
    mtk
        Script to remove the COLOPHON section from the man pages provided
        as command-line arguments.  This is useful to remove the COLOPHON
        sections from all of the man pages in two different release trees
        in order to do a "diff -ruN" to see the "real" differences
        between the trees.


Changes to individual pages
---------------------------

fcntl.2
    mtk
        Replace tables with .TP macros.

fork.2
    mtk
        Added discussion of directory streams.
        Removed "#include <sys/types>" from SYNOPSIS.
        Changed authorship notice.

futex.2
    mtk
        Add ENOSYS error to errors.
    Phil Endecott
        Explicitly describe return value in the event of an error.

inotify_add_watch.2
    mtk
        Minor wording changes.

splice.2
    WANG Cong
        Fix types for 2 and 4 arguments in splice prototype.

wait.2
    Phil Endecott
        Clarify description of return value for WNOHANG.

tkill.2
    mtk
        Rewrote DESCRIPTION; emphasized that tkill() is obsoleted by
        tgkill().

alloca.3
    mtk
        Change description in NAME section.
        Various rewrites and additions (including notes on longjmp() and
        SIGSEGV).
    mtk / Vincent Lefevre
        Weaken warning against use of alloca(), and
        point out some cases where it can be useful;
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=461100.

bootparam.7
    Pavel Heimlich
        Remove junk line.

inotify.7
    mtk
        Replace tables with .TP macros.
        s/MultiSource Synchronization/MultiSource Synchronization (MSS)/


==================== Changes in man-pages-2.78 ====================

Released: 2008-02-15


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Davide Libenzi <davidel@xmailserver.org>
Greg Banks <gnb@melbourne.sgi.com>
Michael Tokarev <mjt@tls.msk.ru>
Phil Endecott <phil_vonar_endecott@chezphil.org>

Apologies if I missed anyone!


Global changes
--------------

sigaction.2
signal.2
sigwaitinfo.2
signal.7
    mtk
        Add SEE ALSO entry referring to new signalfd.2 page.

Typographical or grammatical errors have been corrected in several places.


New pages
---------

eventfd.2
    mtk, with input and review from Davide Libenzi
        Documents the eventfd() system call, new in 2.6.22.

signalfd.2
    mtk, with input and review from Davide Libenzi
        Documents the signalfd() system call, new in 2.6.22.

Changes to individual pages
---------------------------

futex.2
    mtk / Phil Endecott
        Improve wording describing error returns.

open.2
    Greg Banks
        Greatly expand the detail on O_DIRECT.

reboot.2
    mtk / Michael Tokarev
        Fix RETURN VALUE description: in some cases reboot() does not
        return.
    mtk
        Rename the 'flag' argument to 'cmd', since that is more meaningful,
        and also what is used in the kernel source.
        Other minor wording changes.


==================== Changes in man-pages-2.79 ====================

Released: 2008-03-07


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries E. Brouwer <Andries.Brouwer@cwi.nl>
Chris Heath <chris@heathens.co.nz>
Davide Libenzi <davidel@xmailserver.org>
Fernando Luis Vázquez Cao <fernando@oss.ntt.co.jp>
Heikki Orsila <shdl@zakalwe.fi>
Jeremy Kerr <jk@ozlabs.org>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Lasse Kärkkäinen <tronic@trn.iki.fi>
Michael Haardt <michael@moria.de>
Mike Frysinger <vapier@gentoo.org>
Ron Burk <ronburk@gmail.com>
Sam Varshavchik <mrsam@courier-mta.com>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Walter Harms <WHarms@bfs.de>

Apologies if I missed anyone!


Global changes
--------------

Typographical or grammatical errors have been corrected in several places.


New pages
---------

timerfd_create.2
    mtk, with input and review from Davide Libenzi
        Documents the timerfd_create(), timerfd_settime(), and
        timerfd_gettime() system calls, which are new in 2.6.25.


New links
---------

timerfd_gettime.2
timerfd_settime.2
    mtk
        Links to new timerfd_create.2 page.

eventfd_read.3
eventfd_write.3
    mtk
        Links to eventfd.2.


Changes to individual pages
---------------------------

Makefile
    aeb
        Remove code relating to man1/README, which no longer exists.

execve.2
    mtk
        Clarify detail of RLIMIT_STACK/4 limit for argv+environ.

getitimer.2
    mtk
        Added SEE ALSO entry referring to timerfd_create.2.

getrusage.2
    mtk
        Minor rewordings.

open.2
    Michael Haardt
        Move discussion of 'mode' argument under description of O_CREAT.

signalfd.2
    mtk
        Fix type for 'ssi_ptr' field.
        See http://sources.redhat.com/ml/libc-hacker/2008-01/msg00002.html.

syscalls.2
    mtk
        Add timerfd_create(), timerfd_settime(), and timerfd_gettime()
        to list.

syslog.2
    Jeremy Kerr
        Add info on command type 10.
        Add details on types 6, 7, 8, and 9.
        Minor grammar fix.
    mtk
        Update LOG_BUF_LEN details.
        Update RETURN VALUE section.
        Notes capability requirements under EPERM error.
        Minor fix to description of type==3 and type==4.
        Other minor edits.

ctime.3
    Walter Harms
        Note that POSIX requires localtime() to act as though tzset()
        was called, but localtime_r() does not have the same requirement.
        See also http://thread.gmane.org/gmane.comp.time.tz/2034/

getaddrinfo.3
    mtk
        Clarify discussion of NULL 'hints' argument; other minor rewrites.
    mtk / Sam Varshavchik
        Remove some duplicated text.

malloc.3
    Lasse Kärkkäinen / Mike Frysinger / mtk
        Clarify description of realloc() behavior for
        ((size == 0) && (ptr != NULL)).

posix_fallocate.3
    Samuel Thibault
        s/stdlib.h/fcntl.h/ in SYNOPSIS.

proc.5
    Fernando Luis Vázquez Cao
        Update /proc/[number]/cmdline description.
        It used to be true that the command line arguments were
        not accessible when the process had been swapped out.
        In ancient kernels (circa 2.0.*) the problem was that the
        kernel relied on get_phys_addr to access the user space buffer,
        which stopped working as soon as the process was swapped out.
        Recent kernels use get_user_pages for the same purpose and thus
        they should not have that limitation.

epoll.7
    Davide Libenzi / mtk
        Clarify the somewhat unintuitive behavior that occurs if a file
        descriptor in an epoll set is closed while other file descriptors
        referring to the same underlying open file description remain
        open.
        See also http://thread.gmane.org/gmane.linux.kernel/596462/.
    mtk
        Clarify error that occurs if we add an epoll fd to its own set.
    mtk
        A few minor rewordings.
    mtk, after a note by Chris Heath
        Rework Q1/A1, describing what happens when adding the same
        file descriptor twice to an epoll set, and when adding duplicate
        file descriptors to the same epoll set.
    Heikki Orsila / mtk / Davide Libenzi
        Clarify Q9/A9 to discuss packet/token-oriented files.
    mtk, after comments by Davide Libenzi and Chris Heath
        Added Q0/A0, making explicit that the key for items in an epoll
        set is [file descriptor, open file description].
    mtk, after a note by Ron Burk
        Change A3, to note that when events are available,
        the epoll file descriptor will indicate as being readable.
    mtk
        Add some further explanation to Q5/A5 about why an epoll file
        descriptor cannot be passed across a Unix domain socket.

posixoptions.7
    mtk
        Add SEE ALSO entry for standards(7).

regex.7
    mtk
        Add grep(1) to SEE ALSO.
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=348552.

standards.7
    mtk
        Add SEE ALSO entry for posixoptions(7).

time.7
    mtk
        Added SEE ALSO entry referring to timerfd_create.2.


==================== Changes in man-pages-2.80 ====================

Released: 2008-06-05


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Adrian Bunk <bunk@kernel.org>
Alain Portal <aportal@univ-montp2.fr>
Andreas Herrmann <andreas.herrmann3@amd.com>
Andrew Morton <akpm@linux-foundation.org>
Andries E. Brouwer <Andries.Brouwer@cwi.nl>
Anoop <acv@linux.vnet.ibm.com>
Aurelien Gerome <ag@roxor.cx>
Daniel Burr <dburr@topcon.com>
Davide Libenzi <davidel@xmailserver.org>
Felix Kater <fkater@googlemail.com>
Folkert van Heusden <folkert@vanheusden.com>
Hamaji Shinichiro <shinichiro.hamaji@gmail.com>
Heikki Orsila <shd@modeemi.fi>
Ingo Molnar <mingo@elte.hu>
Justin Pryzby <justinpryzby@users.sourceforge.net>
Karsten Weiss <K.Weiss@science-computing.de>
Martin Pitt <mpitt@debian.org>
Marty Leisner <leisner@rochester.rr.com>
Nicolas François <nicolas.francois@trialog.com>
Nick Piggin <npiggin@suse.de>
Petter Reinholdtsen <pere@hungry.com>
Reuben Thomas <rrt@sc3d.org>
Sam Varshavchik <mrsam@courier-mta.com>
Stuart Brady <sdbrady@ntlworld.com>
Theodoros V. Kalamatianos <thkala@softlab.ece.ntua.gr>
Thomas Huriaux <thomas.huriaux@gmail.com>
Tim Stoakes <tim@stoakes.net>
Timothy Baldwin <T.E.Baldwin99@members.leeds.ac.uk>
Tolga Dalman <tdalman@project-psi.org>

Apologies if I missed anyone!


Global changes
--------------

bdflush.2
inotify_add_watch.2
mprotect.2
sigprocmask.2
ctime.3
getusershell.3
setbuf.3
st.4
ip.7
packet.7
    mtk
        Replace "(il)legal" by "(not) permitted" or "(in)valid".

read.2
utime.2
filesystems.5
packet.7
    mtk
        s/time stamp/timestamp/, for consistency with majority use
        in other pages, and in POSIX.1.

madvise.2
mbind.2
mincore.2
mmap.2
mmap2.2
msync.2
remap_file_pages.2
    mtk
        Change name of 'start' argument to 'addr' for consistency
        with:
            * other memory-related interfaces
            * POSIX specification (for those interfaces in POSIX)
            * Linux and glibc source code (in at least some cases)

Various pages
    mtk
        s/filesystem/file system/, for consistency with majority use
        in other pages, and in POSIX.1.

Various pages
    mtk
        s/zeroes/zeros/, for consistency with majority use
        in other pages, and in POSIX.1.

abs.3
proc.5
    mtk
        s/builtin/built-in/, for consistency with majority use
        in other pages, and in POSIX.1.

mknod.2
ftw.3
    mtk
        s/normal file/regular file/

Various pages
    mtk
        s/nonempty/non-empty/

Various pages
    mtk
        s/nonzero/non-zero/

Various pages
    mtk
        s/realtime/real-time/, for consistency with majority usage.

Various pages
    mtk
        s/command line/command-line/ when used attributively.

Various pages
    mtk
        Use "run time" when non-attributive, "run-time" when attributive.

Various pages
    mtk
        Various pages that I wrote carried a slightly modified version
        of the "verbatim" license.  In the interests of minimizing
        license proliferation, I've reverted the modified form
        so that the license is exactly the same as on other pages
        carrying the verbatim license.

epoll_ctl.2
getitimer.2
getrlimit.2
unix.7
    mtk
        s/since kernel x.y.z/since Linux x.y.z/

wait.2
inotify.7
    mtk
        Reformat kernel version information for flags.

Typographical or grammatical errors have been corrected in several places.
(Special thanks to Nicolas François.)


New pages
---------

random_r.3
    mtk, after a suggestion by aeb
        Documents random_r(3), srandom_r(3), initstate_r(3), and
        setstate_r(3), which are the reentrant equivalents of
        random(3), srandom(3), initstate(3), and setstate(3).


New links
---------

lutimes.3
    mtk
        Link to futimes.3.

initstate_r.3
setstate_r.3
srandom_r.3
    mtk
        Links to random_r.3.

daylight.3
timezone.3
tzname.3
    mtk
        Links to tzset.3.

isnanf.3
isnanl.3
    mtk
        Links to finite.3.

encrypt_r.3
setkey_r.3
    mtk
        Links to encrypt.3.


Changes to individual pages
---------------------------

clone.2
    mtk
        Added note that CLONE_STOPPED (which no-one uses anyway) is
        now deprecated.

epoll_create.2
    mtk
        Add NOTES section pointing out that 'size' argument is unused
        since kernel 2.6.8.

epoll_ctl.2
    mtk
        Added portability note to BUGS text for EPOLL_CTL_DEL.

epoll_wait.2
    mtk
        If the 'sigmask' is NULL, then epoll_pwait() is equivalent
        to epoll_wait().

fork.2
    mtk
        NOTES: since glibc 2.3.3, the glibc NPTL fork() wrapper
        bypasses the fork() system call to invoke clone() with
        flags providing equivalent functionality.

futex.2
    mtk, after a note from Adrian Bunk
        FUTEX_FD has been removed, as of kernel 2.6.26.

futimesat.2
    mtk
        Note that this system call is made obsolete by utimensat(2).

getgroups.2
    Petter Reinholdtsen
        SEE ALSO: Add getgrouplist(3).
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=479284.
    mtk
        NGROUPS_MAX increased in kernel 2.6.4.
        SEE ALSO: Add credentials(7).
    mtk
        Reformat DESCRIPTION and RETURN VALUE sections to be more
        consistent with man-pages style.
        Add some more detail to descriptions of system calls.
        Clarified what happens if caller of getgroups() is a member of
        more than 'size' supplementary groups.
        ERRORS: Add ENOMEM.

getpriority.2
    mtk, after a note from Ingo Molnar
        Add text in NOTES about the punchier effect of nice values in
        kernel 2.6.23 and later.
        Add Documentation/scheduler/sched-nice-design.txt to SEE ALSO list.

gettid.2
    mtk
        Added VERSIONS section noting that this system call first
        appeared in 2.4.11.

kill.2
    Marty Leisner / mtk
        Add text explicitly noting that sig==0 can be used to check for
        the existence of a PID or PGID.
    mtk
        A few minor rewordings.

mbind.2
    mtk
        The location of the numactl package has changed.

mmap.2
    mtk
        Added some .SS headings to make structure of page a little
        more obvious.
    mtk, with input from Nick Piggin
        MAP_POPULATE supports both file and anonymous mappings.
        Since 2.6.23, MAP_POPULATE supports private mappings.
        Since 2.6.23, MAP_NONBLOCK causes MAP_POPULATE to be a no-op.
    mtk
        NOTES: Added details on mapping address that is selected by
        kernel when MAP_FIXED is / isn't specified.

mount.2
    mtk
        The MS_REMOUNT changes in 2.4 were at 2.4.10 (not 2.4).
    mtk
        Minor wording change.

msgctl.2
    mtk
        Clarify that "unused" fields in msginfo structure are
        "unused within the kernel".
        msginfo.msgpool is measured in kilobytes, not bytes.
        Minor rewordings in comments for msginfo structure.

msgop.2
    mtk
        Various minor rewordings and restructurings for clarity.
    mtk, after a note from Reuben Thomas
        Remove "msgop" from NAME section.

mkdir.2
    mtk
        Clarify meaning of "BSD group semantics".
        SEE ALSO: add chown(2).

mknod.2
    mtk
        SEE ALSO: add chown(2) and chmod(2).

mmap.2
    mtk
        SEE ALSO: add mprotect(2) and shmat(2).

mprotect.2
    Hamaji Shinichiro
        SYNOPSIS: s/size_t \*len/size_t len/

open.2
    mtk
        Note that O_CLOEXEC should be in the next POSIX.1 revision.
    mtk
        More than just ext2 supports "mount -o bsdgroups" nowadays,
        so make the discussion about group ownership of new files a bit
        more generic.
    mtk
        SEE ALSO: add chown(2) and chmod(2).

poll.2
    mtk
        If the 'sigmask' is NULL, then ppoll() is equivalent to poll()
        with respect to signal mask manipulations.

posix_fadvise.2
    mtk
        s/posix_madvise (2)/posix_madvise (3)/;
        (The referred-to page still doesn't exist yet, but hopefully
        will do sometime soon.)

ptrace.2
    Anoop, Acked by Roland McGrath.
        Re PTRACE_PEEKUSER: the offsets and data returned might not
        match with the definition of struct user.
        See also http://lkml.org/lkml/2008/5/8/375

recv.2
    Felix Kater / mtk
        Improve wording for EAGAIN error in discussion of MSG_DONTWAIT.

rmdir.2
    Martin Pitt
        POSIX.1 also allows EEXIST for the ENOTEMPTY error condition.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=467552.

sched_setscheduler.2
    mtk, with input from Ingo Molnar
        Add description of SCHED_IDLE policy (new in 2.6.23).
        Tweak description of SCHED_BATCH.
        Minor rewordings.

select_tut.2
    Justin Pryzby
        Various wording clean-ups.

semctl.2
    mtk
        Clarify that "unused" fields in seminfo structure are
        "unused within the kernel".
        Minor rewordings in comments for seminfo structure.

semop.2
    Aurelien Gerome
        Small fix in example code.

setpgid.2
    mtk / Karsten Weiss
        Clarify description of setpgid() a little.

shmctl.2
    mtk
        Clarify that "unused" fields in shminfo structure are
        "unused within the kernel".
        Minor rewordings in comments for shminfo structure.

shmop.2
    mtk, after a note from Reuben Thomas
        Remove "shmop" from NAME section.

signalfd.2
    mtk
        Added BUGS text noting that before kernel 2.6.25, the ssi_int
        and ssi_ptr fields are not set.
        Added comments describing fields in signalfd_siginfo structure.
        Update field names in example program (s/signo/ssi_signo/).
        Various small fixes, and remove duplicated sentence.
        Minor edits to structure definition.

sigqueue.2
    mtk
        Added some comments to code in NOTES.

stat.2
    mtk
        Minor wording change.

symlink.2
    mtk
        SEE ALSO: add lchown(2).

sync_file_range.2
    mtk / Andrew Morton
        Remove statement that (SYNC_FILE_RANGE_WAIT_BEFORE |
        SYNC_FILE_RANGE_WRITE | SYNC_FILE_RANGE_WAIT_AFTER) is
        a traditional fdatasync(2) operation.
        See https://bugzilla.mozilla.org/show_bug.cgi?id=421482
        comments 129 to 131.

syscalls.2
    mtk
        This page is now up to date as at kernel 2.6.25.

syslog.2
    mtk
        Small tidy up of language relating to permissions/capabilities.

timerfd_create.2
    mtk
        Minor change to example program.
        Minor wording change.

utime.2
    Reuben Thomas
        Remove unnecessary subheading for utimes().
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=477402.
    mtk
        Change description in NAME line ("or" is not correct: these calls
        always change *both* timestamps).
        CONFORMING TO: utimes() is in POSIX.1-2001.
    mtk
        Rename 'buf' argument of utime() to 'times' (like utimes()).
        Clarify explanation of EACCES and EPERM errors.
        Remove BUGS section, since it doesn't seem to add useful
        information.
        Clarified discussion of capabilities, and noted that
        CAP_DAC_OVERRIDE also has a role.
        Other minor rewordings.

wait.2
    mtk, after a note by Justin Pryzby
        Add a sentence clarifying that even though the default disposition
        of SIGCHLD is "ignore", explicitly setting the disposition to
        SIG_IGN results in different treatment of zombies.

aio_cancel.3
aio_error.3
aio_fsync.3
aio_read.3
aio_return.3
aio_suspend.3
aio_write.3
    Kevin O'Gorman <kogorman@csc.calpoly.edu>
        Add "Link with -lrt" to SYNOPSIS.

backtrace.3
    Nicolas François
        s/backtrace_symbols/backtrace_symbols_fd/ in one sentence.
    mtk
        Fix bogus reference to variable 'strings': should be:
        "the array of pointers".

ctime.3
    mtk
        Add warning under NOTES that asctime(), ctime(), gmtime(), and
        localtime() may each overwrite the static object returned by any
        of the other calls.
        Other minor edits.

dlopen.3
    mtk
        Add more detail to the description of the fields in the
        structure returned by dladdr().

fexecve.3
    mtk
        Clean up SYNOPSIS after work by cut-and-paste-Pete:
        the necessary header file is <unistd.h> not <sys/time.h>!

futimes.3
    mtk
        Add documentation of lutimes(), which appeared in glibc 2.6.
    mtk
        Change description in NAME line ("or" is not correct: these calls
        always change *both* timestamps).
        CONFORMING TO: futimes() did not come from 4.2BSD.  (It came from
        FreeBSD; see the FreeBSD man page.)

getenv.3
    mtk
        Noted that caller must not modify returned value string.
        Noted that getenv() is not reentrant: the buffer may be statically
        allocated and overwritten by later calls to getenv(), putenv(),
        setenv(), or unsetenv().
        Other minor rewrites.

getgrent.3
    Petter Reinholdtsen
        SEE ALSO: Add getgrouplist(3).
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=479284.

gethostbyname.3
    mtk
        Add 'h_errno' to NAME list.

getopt.3
    mtk
        Add 'optarg', 'optind', 'opterr', and 'optopt' to NAME section.
        Add subheading for getopt_long() and getopt_long_only()
        description.

getpt.3
    mtk
        Point out that this function should be avoided in favor of
        posix_openpt().
        Add ERRORS section referring to open(2).

getsubopt.3
    Daniel Burr
        SYNOPSIS: Fix declaration of valuep.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=476672.

malloc.3
    mtk
        RETURN VALUE: Note circumstances in which successful malloc() and
        calloc() can return NULL.

mq_open.3
    mtk, after a note by Marty Leisner
        Note that <fcntl.h> is needed for O_* constants and <sys/stat.h>
        is needed for 'mode' constants.

opendir.3
    mtk
        Describe treatment of close-on-exec flag by opendir() and
        fdopendir().

openpty.3
    mtk
        SEE ALSO: add ttyname(3).

raise.3
    mtk / Timothy Baldwin
        Clarify semantics of raise() when called from a multithreaded
        program.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=476484.
    mtk
        Rewrites and additions to various parts of the page.

rand.3
    Tolga Dalman / aeb / mtk
        Remove outdated warning in NOTES; encourage the use of
        random(3) instead.
    Folkert van Heusden
        Clarify wording describing range of values returned by rand().

random.3
    aeb / mtk / Tolga Dalman
        Recommend use or random_r(3) for multithreaded applications
        that need independent, reproducible sequences of random numbers.

        Move references to "The Art of Computer Programming" and
        "Numerical Recipes", formerly in rand(3), to this page.

        Add drand48(93) to SEE ALSO list.

regex.3
    Heikki Orsila
        Clarify description of 'rm_eo' field.

sem_open.3
    mtk, after a note by Marty Leisner
        Note that <fcntl.h> is needed for O_* constants and <sys/stat.h> is
        needed for 'mode' constants.

sem_post.3
    mtk
        Added pointer to example in sem_wait(3).

sem_close.3
sem_destroy.3
sem_getvalue.3
sem_init.3
sem_open.3
sem_post.3
sem_unlink.3
sem_wait.3
    mtk, after a note from Marty Leisner
        Add text to SYNOPSIS noting the need to link with "-lrt" or
        "-pthread".

setenv.3
    mtk
        setenv() copies 'name' and 'value' (contrast with putenv()).
        unsetenv() of a nonexistent variable does nothing and is
        considered successful.
        Noted that setenv() and unsetenv() need not be reentrant.

shm_open.3
    mtk, after a note by Marty Leisner
        Note that <fcntl.h> is needed for O_* constants and <sys/stat.h> is
        needed for 'mode' constants.

undocumented.3
    mtk
        initstate_r(3), setkey_r(3), setstate_r(3) are now documented.

utmp.5
    Nicolas François
        Small rewording.

resolv.conf.5
    Nicolas François
        gethostname() is in Section 2, not section 3.

ascii.7
    Stuart Brady
        Fix rendering of ' (backtick) and apostrophe (') in tables

charsets.7
    Nicolas François
        s/unicode.com/unicode.org/

credentials.7
    mtk
        NOTES: Pthreads requires that all threads share the same UIDs and
        GIDs.  But the Linux kernel maintains separate UIDs and GIDs for
        every thread.  NPTL does some work to ensure that credential
        changes by any thread are carried through to all POSIX threads in
        a process.
    mtk
        sysconf(_SC_NGROUPS_MAX) can be used to determine the number of
        supplementary groups that a process may belong to.
        Clarify that supplementary group IDs are specified in POSIX.1-2001.

epoll.7
    mtk, after a note from Sam Varshavchik
        For answer A2, change "not recommended" to "careful programming
        may be required".

inotify.7
    mtk
        Document SIGIO feature (new in 2.6.25) for inotify file descriptors.
    mtk
        Note that select()/poll()/epoll_wait() indicate a ready inotify
        file descriptor as readable.
    mtk
        Document IN_ATTRIB in a little more detail.

pthreads.7
    Justin Pryzby
        Grammar fix, plus fix typo in script.
    mtk
        Add list of thread-safe functions.

standards.7
    mtk
        Add a section on the upcoming POSIX revision.

ld.so.8
    Justin Pryzby / mtk
        Various wording improvements.


==================== Changes in man-pages-3.00 ====================

Released: 2008-06-12, Konolfingen


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries Brouwer <Andries.Brouwer@cwi.nl>
Stuart Brady <sdbrady@ntlworld.com>

Apologies if I missed anyone!


Global changes
--------------

The POSIX.1 man pages (sections 0p, 1p, 3p) have been moved out
of this package into the separate man-pages-posix package.
This made sense because those pages are seldom changed (only formatting
fixes, etc.) so that it was unnecessary to redistribute them with each
man-pages release.


console_codes.4
random.4
dir_colors.5
proc.5
glob.7
    Stuart Brady
        s/`/\`/ for backquotes used in command substitution, for
        proper rendering in UTF-8.

Various pages
    mtk, after a note from Stuart Brady
        Using /'x'/ to denote a character (string) renders poorly in
        UTF-8, where the two ' characters render as closing single
        quotes.  On the other hand, using /`x'/ renders nicely on UTF-8,
        where proper opening and closing single quotes are produced by
        groff(1), but looks ugly when rendered in ASCII.  Using the
        sequence /\\aqx\\aq/ produces a reasonable rendering ('\\aq'
        is a vertical "apostrophe quote") in both UTF-8 and ASCII.
        So that change is made in a number of pages.
        See also http://www.cl.cal.ac.uk/~mgk25/ucs/quotes.html.

Various pages
    mtk
        Replace form /`string'/ by /"string"/, since the former renders
        poorly in ASCII.

termios.3
console_codes.4
tty_ioctl.4
termcap.5
charsets.7
    mtk
        Control character names (^X) are written boldface, without
        quotes.

printf.3
scanf.3
proc.5
glob.7
regex.7
    mtk
        Various edits to try and bring some consistency to the use of
        quotes.


Changes to individual pages
---------------------------

tty_ioctl.4
    mtk
        Small rewordings in description of packet mode.

locale.7
    mtk
        Minor formatting fixes.


==================== Changes in man-pages-3.01 ====================

Released: 2008-06-25, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andreas Herrmann <andreas.herrmann3@amd.comm>
Andrew P <ap@zip.com.au>
Andrew Clayton <andrew@digital-domain.net>
Bart Van Assche <bart.vanassche@gmail.com>
Christian Borntraeger <borntraeger@de.ib.com>
Christoph Hellwig <hch@infradead.org>
Daniele Giacomini <appunti2@gmail.com>
Dorin Lazar <dorin.lazar@gmail.com>
George Spelvin <linux@horizon.com>
Jason Englander <jason@englanders.cc>
Jeff Moyer <jmoyer@redhat.com>
Laurent Vivier <laurent.vivier@bull.net>
Masatake YAMOTO <yamoto@redhat.com>
Matt Mackall <mpm@selenic.com>
Neil Horman <nhorman@tuxdriver.com>
Pavel Machek <pavel@suse.cz>
Peter Zijlstra <a.p.zijlstra@chello.nl>
Petr Baudis <pasky@suse.cz>
Petr Gajdos <pgajdos@suse.cz>
Roman Zippel <zippel@linux-m68k.org>
Sam Varshavchik <mrsam@courier-mta.com>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Stephane Chazelas <stephane_chazelas@yahoo.fr>
Stuart Cunningham <stuartc@rd.bbc.co.uk>
Thomas Gleixner <tglx@linutronix.de>
Tolga Dalman <tdalman@project-psi.org>
Yao Zhao <dragonlinux@gmail.com>
WANG Cong <wcong@critical-links.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

acct.5
    mtk
        A complete rewrite of this page, now with much more detail.

hostname.7
    mtk
        A description of hostname resolution.  Taken from FreeBSD 6.2,
        and lightly edited for man-pages style.

symlink.7
    mtk
        A description of symbolic links.  Taken from FreeBSD 6.2, but
        heavily edited for Linux details, improved readability, and
        man-pages style.


Newly documented interfaces in existing pages
---------------------------------------------

getrlimit.2
    mtk / Peter Zijlstra
        Add description of RLIMIT_RTTIME limit, new in 2.6.25.

mkstemp.3
    mtk
        Add description of mkostemp(), new in glibc 2.7.

core.5
    mtk, after a note by Petr Gajdos; review by Neil Horman
        Document core_pattern pipe syntax, which appeared in
        kernel 2.6.19.
        Add an example program demonstrating use of core_pattern
        pipe syntax.
    mtk
        Document /proc/PID/coredump_filter, new in kernel 2.6.23.
        Documentation was based on the text in
        Documentation/filesystems/proc.txt, plus testing, and
        checking the kernel source.

proc.5
    mtk
        Document /proc/PID/oom_score, which was new in kernel 2.6.11.
        This file displays the "badness" score of the process, which
        provides the basis for OOM-killer decisions.
    mtk
        Document /proc/PID/oom_adj, which was new in kernel 2.6.11.
        This file influences the oom_score of a process.
    mtk
        Document /proc/PID/limits, which was new in 2.6.24.
        This file displays a process's resource limits.
    mtk
        Document /proc/PID/fdinfo/*, which was new in 2.6.22.
        These files display info about each descriptor opened by the
        process: the current file offset, and the file access mode +
        file status flags as set in open() or fcntl(F_SETFL).
    mtk
        Document /proc/PID/mountinfo, which was new in 2.6.26.
        This file displays information about mount points.
        Closely based on text from Documentation/filesystems/proc.txt.
    mtk
        Document /proc/PID/mountstats, which was new in 2.6.17.
        This file displays statistics about mount points.
    mtk
        Document /proc/PID/status.
    Samuel Thibault / mtk, review by Laurent Vivier,
                Christian Borntraeger, and Andrew P
        Document guest (virtual CPU) time field in /proc/stat.
        Document guest (virtual CPU) time fields in /proc/PID/stat.


New links
---------

mkostemp.3
    mtk
        Link to mkstemp.3.

getcwd.2
    mtk
        Link to getcwd.3, which describes several interfaces, among
        them getcwd(), which is in fact a system call.


Global changes
--------------

sched_setaffinity.2
sched_setscheduler.2
set_mempolicy.2
mbind.2
    mtk
        SEE ALSO: Add cpuset(7).

chown.2
faccessat.2
fchmodat.2
fchownat.2
fstatat.2
getxattr.2
link.2
linkat.2
listxattr.2
open.2
readlink.2
removexattr.2
rename.2
setxattr.2
stat.2
symlink.2
symlinkat.2
unlink.2
futimes.3
remove.3
path_resolution.7
    mtk
        SEE ALSO: Add symlink(7).

intro.1
time.1
fcntl.2
gethostbyname.3
ioctl_list.2
    mtk
        Wrap source lines so that new sentence starts on new line.

addseverity.3
backtrace.3
dlopen.3
fmtmsg.3
getnameinfo.3
getpt.3
grantpt.3
makecontext.3
ptsname.3
tcgetsid.3
unlockpt.3
wordexp.3
    mtk
        Added VERSIONS section.

msgctl.2
msgget.2
semget.2
semop.2
pciconfig_read.2
basename.3
cmsg.3
ftok.3
console_ioctl.4
tzfile.5
mq_overview.7
pty.7
    mtk
        For consistency, "fix" cases where argument of .B or .I was
        on the following source line.

adjtimex.2
getrusage.2
io_getevents.2
poll.2
select.2
semop.2
sigwaitinfo.2
aio_suspend.3
clock_getres.3
mq_receive.3
mq_send.3
sem_wait.3
proc.5
    mtk
        SEE ALSO: add time(7)

Typographical or grammatical errors have been corrected in several places.
(Special thanks to Nicolas François and Alain Portal.)


Changes to individual pages
---------------------------

acct.2
    mtk
        Add a few more words to DESCRIPTION.
        NOTES: Add pointer to acct(5).

alarm.2
    Alain Portal
        s/process/calling process/ so as to say that the alarm signal is
        delivered to the calling process.

brk.2
    Yao Zhao / mtk
        Clarify discussion of return value of sbrk().
    mtk
        DESCRIPTION: Add some sentences giving an overview of these
        interfaces.
        Add note recommending use of malloc(3).
        Change name of brk() argument to the simpler 'addr'.
        Add "(void *)" cast to "-1" for error return of sbrk().
        Removed some incorrect text about "brk(0)".
        Note that SUSv2 specified the return value of sbrk().
        Added a detail on the glibc brk() wrapper.
        Remove discussions of old standards (C89 and POSIX.1-1990);
        CONFORMING TO already discusses the situation with respect
        to more recent standards.

chmod.2
    mtk
        Clarify description of chmod() and fchmod().
        Add further detail on S_ISUID, S_ISGID, and S_ISVTX permissions.
        Reformat list of permissions bits.

chown.2
    mtk
        Describe rules governing ownership of new files (bsdgroups
        versus sysvgroups, and the effect of the parent directory's
        set-group-ID permission bit).

chroot.2
    Alain Portal
        Clarify description a little.
        s/changes the root directory/
          changes the root directory of the calling process/

execve.2
    mtk
        Fix text that warns against use of NULL argv and envp.
        Using a NULL envp does in fact seem to be portable (works
        on Solaris and FreeBSD), but the Linux semantics for a NULL
        argv certainly aren't consistent with other implementations.
        See http://bugzilla.kernel.org/show_bug.cgi?id=8408.

getdents.2
    mtk, after a note from George Spelvin
        Document d_type field, present since kernel 2.6.4.
        Other minor edits.

getitimer.2
    mtk
        Noted that POSIX.1 leaves interactions with alarm(), sleep(),
        and usleep() unspecified.
        Linux 2.6.16 removed the MAX_SEC_IN_JIFFIES ceiling on timer
        values.
        Other minor changes.

io_cancel.2
io_destroy.2
io_getevents.2
io_setup.2
io_submit.2
    mtk, after a note by Masatake YAMOTO and input from Jeff Moyer
        Describe the unconventional error return provided by the
        wrapper function in libaio (and contrast with behavior if
        the system call is invoked via syscall(2)).
        See http://thread.gmane.org/gmane.linux.ltp/4445/
    Alain Portal / mtk
        Re-order ERRORS and SEE ALSO entries to be alphabetical.

io_getevents.2
    Alain Portal
        Small wording fix.

io_submit.2
    Jeff Moyer
        s/AIO request blocks/AIO control blocks/

mknod.2
    mtk
        Note that EEXIST applies, even if the pathname is a
        (possibly dangling) symbolic link.

nanosleep.2
    mtk, after a report from Stephane Chazelas
        Remove crufty discussion of HZ, and replace with a pointer
        to time(7).
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=485636
    mtk, after some discussions with Bart Van Assche and Roman Zippel
        NOTES: describe CLOCK_REALTIME versus CLOCK_NANOSLEEP
        See also http://thread.gmane.org/gmane.linux.kernel/696854/
        "nanosleep() uses CLOCK_MONOTONIC, should be CLOCK_REALTIME?"
    mtk
        Replace mentions of "process' by "thread".
        NOTES: describe case where clock_nanosleep() can be preferable.
        Some minor rewrites.

open.2
    mtk, after a note from Christoph Hellwig
        NOTES: Note that access mode flags are not single bits,
        and document the Linuxism "access mode 3".
        See also http://thread.gmane.org/gmane.linux.kernel/653123.

readdir.2
    mtk
        Minor wording fixes.

recv.2
    Alain Portal
        Add comment to 'ee_pad' field in structure definition.

sched_setscheduler.2
    mtk
        Add pointer to discussion of RLIMIT_RTTIME in getrlimit.2.
    mtk, after a note by Andrew Clayton
        Rewrote and restructured various parts of the page for greater
        clarity.
    mtk
        Add more detail to the rules that are applied when an
        unprivileged process with a non-zero RLIMIT_RTPRIO limit
        changes policy and priority.
        SEE ALSO: Add Documentation/scheduler/sched-rt-group.txt

sync_file_range.2
    Pavel Machek
        SYNC_FILE_RANGE_WRITE can block on writes greater than request
        queue size.  For some background, see
        http://thread.gmane.org/gmane.linux.kernel/687713/focus=688340

syscalls.2
    mtk
        Added system call history back to version 1.2.
        Fix typo on kernel version for pivot_root().

syslog.2
    WANG Cong
        Document ENOSYS error, which can occur if kernel was built without
        CONFIG_PRINTK.

utime.2
    Nicolas François
        Clarify description of 'times' array for utimes().

adjtime.3
    mtk
        The longstanding bug that if delta was NULL, olddelta
        didn't return the outstanding clock adjustment, is now fixed
        (since glibc 2.8 + kernel 2.6.26).
        http://sourceware.org/bugzilla/show_bug?id=2449
        http://bugzilla.kernel.org/show_bug.cgi?id=6761

dprintf.3
    mtk
        Note that these functions are included in the next POSIX revision.
        Remove editorial discussion about what the functions should have
        been named.

ftime.3
    mtk
        Rewrote various pieces, and added some details.

getaddrinfo.3
    mtk
        Improve description or 'hints' and 'res' arguments.
        Add details on numeric strings that can be specified for 'node'.
        Other fairly major restructurings and rewrites to improve
        logical structure and clarity of the page.
        SEE ALSO: Add hostname(7).

gethostbyname.3
    mtk
        DESCRIPTION: Add reference to inet_addr(3) for dotted notation.
        SEE ALSO: add inet(3).
    mtk
        Added BUGS section noting that gethostbyname() does not
        recognize hexadecimal components in dotted address strings;
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=482973

getmntent.3
    mtk, after Stuart Cunningham pointed out the typo
        Remove statement that LSB deprecates the functions
        "endmntent(), setmntent() [sic] and setmntent()".
        This doesn't seem to be true (I can't find mention of it
        being deprecated in any of the LSB specs).  Rather, LSB simply
        doesn't specify these functions.  (LSB 1.3 had a spec of
        setmntent(), but not getmntent() or endmntent(), and noted
        that having a spec of setmntent() was of little use without
        also having a spec of getmntent().)
        See also https://lists.linux-foundation.org/pipermail/lsb-discuss/2006-October/003078.html

getnameinfo.3
    Tolga Dalman
        Remove mention of sa_len field from example code.
        That field is a BSDism not present on Linux.
    mtk
        Various minor changes.

inet.3
    mtk / Stephane Chazelas
        inet_aton() is *not* in POSIX.1.
        Rewrote discussion of why inet_addr() is disfavored.
        SEE ALSO: Add getaddrinfo(3).
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=482979.
    mtk, after a note by Stephane Chazelas
        Describe the various address forms supported by inet_aton().
    mtk
        Rewrite description of inet_network().
        Clarify discussion of inet_lnaof(), inet_netof(), and inet_makeaddr().
        Add discussion of Classful Addressing, noting that it is obsolete.
        Added an EXAMPLE program.
    mtk
        Relocate discussion of i386 byte order to NOTES.
        Note that inet_aton() returns an address in network byte order.
        SEE ALSO: Add byteorder(3) and getnameinfo(3).

inet_ntop.3
    mtk
        Remove unneeded header files from SYNOPSIS.
        SEE ALSO: Add inet(3) and getnameinfo(3).
        Make NAME line more precise.
        Move errors to an ERRORS section.
        Add EXAMPLE section pointing to inet_pton(3).

inet_pton.3
    mtk / Stephane Chazelas
        Remove statement that inet_pton() extends inet_ntoa();
        that's not really true, since inet_pton() doesn't support
        all of the string forms that are supported by inet_ntoa().
        SEE ALSO: Add getaddrinfo(3).
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=482987.
    mtk
        Describe IPv6 address formats.
        Describe dotted decimal format in more detail.
        Add an example program.
    mtk
        Remove unneeded header files from SYNOPSIS.
        Make NAME line more precise.
        Make description of return value more precise.
        SEE ALSO: Add inet(3).

mkfifo.3
    mtk
        Note that EEXIST applies, even if the pathname is a
        (possibly dangling) symbolic link.

mkstemp.3
    mtk
        Fix discussion of O_EXCL flag.
        These functions may also fail for any of the errors described
        in open(2).
        Various other rewordings.

readdir.3
    mtk
        Document DT_LNK (symbolic link) for d_type field.
        Reorder DT_ entries alphabetically.

remainder.3
    mtk
        Recommend against drem(), in favor of remainder().

scanf.3
    mtk, after a note from Stephane Chazelas
        Add an ERRORS section documenting at least some of the errors
        that may occur for scanf().
        See also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=487254.
    mtk, after a note from Stephane Chazelas; review by Stephane Chazelas
        Document the GNU 'a' modifier for dynamically allocating strings.
        See also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=487254.
        Document the GNU 'm' modifier for dynamically allocating strings.

strcat.3
    Andreas Herrmann
        s/strcat/strncat/ (a typo that changed the semantics in
        DESCRIPTION).

strerror.3
    mtk, after a note from Daniele Giacomini
        Modify SYNOPSIS to show prototypes of both versions of strerror_r(),
        and make other small clarifications of the description regarding
        the two versions.

random.4
    George Spelvin (taking time out from his busy Broadway schedule),
    with some tweaks by Matt Mackall and mtk
        Add a Usage subsection that recommends most users to use
        /dev/urandom, and emphasizes parsimonious usage of
        /dev/random.

locale.5
    Petr Baudis <pasky@suse.cz>
        LC_TIME: Describe first_weekday and first_workday.

proc.5
    mtk
        The various CPU time fields in /proc/stat and /proc/PID/stat
        return time in clock ticks (USER_HZ, cputime_to_clock_t(),
        sysconf(_SC_CLK_TCK)).
        Updated, clarified and expanded the description several
        fields in /proc/[number]/stat.
    mtk
        Clarified and expanded the description of /proc/[number]/fd.
    mtk
        Updated and clarified the description of /proc/[number]/statm.
    mtk
        Updated and clarified the description of /proc/sys/fs/dentry-state.
    mtk
        Many formatting, wording, and grammar fixes.

man-pages.7
    mtk
        Enhanced description of VERSIONS section.

mq_overview.7
    mtk
        Note that Linux does not currently support ACLs for POSIX
        message queues.

sem_overview.7
    mtk
        Note that Linux supports ACLs on POSIX named semaphores
        since 2.6.19.

time.7
    mtk, with some suggestions from Bart Van Assche and Thomas Gleixner
        Added some details about where jiffies come into play.
        Added section on high-resolution timers.
        Mentioned a few other time-related interfaces at various
        points in the page.
        See http://thread.gmane.org/gmane.linux.kernel/697378.

unix.7
    mtk, after a note by Samuel Thibault
        Provide a clear description of the three types of address that
        can appear in the sockaddr_un structure: pathname, unnamed,
        and abstract.


==================== Changes in man-pages-3.02 ====================

Released: 2008-07-02, Konolfingen


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Reuben Thomas <rrt@sc3d.org>
Sam Varshavchik <mrsam@courier-mta.com>
Stephane Chazelas <stephane_chazelas@yahoo.fr>
WANG Cong <xiyou.wangcong@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

clock_nanosleep.2
    mtk
        A description of the clock_nanosleep() system call,
        which was added in kernel 2.6.

getgrouplist.3
    mtk
        A near complete rewrite, including additional information and
        a new example program.

getutmp.3
    mtk
        Documents getutmp(3) and getutmpx(3).

gnu_get_libc_version.3
    mtk
        Documents gnu_get_libc_version(3) and gnu_get_libc_release(3).

sigwait.3
    mtk
        Documents sigwait(3).

shm_overview.7
    mtk
        An overview of the POSIX shared memory API.


Newly documented interfaces in existing pages
---------------------------------------------

updwtmp.3
    mtk
        Document updwtmpx(3).


New links
---------

getutmpx.3
    mtk
        Link to getutmp.3.

gnu_get_libc_release.3
    mtk
        Link to gnu_get_libc_version.3

updwtmpx.3
    mtk
        Link to updwtmp.3

utmpxname.3
    mtk
        Link to getutent.3.

utmpx.5
    mtk
        Link to utmp.5.


Global changes
--------------

Various pages
    mtk
        s/user name/username/

Various pages
    mtk
        s/host name/hostname/


Changes to individual pages
---------------------------

fchmodat.2
    Alain Portal
        SEE ALSO: add symlink.7.  (3.01 changelog wrongly said this
        had been done.)

io_setup.2
    Alain Portal
        Remove superfluous text from RETURN VALUE.

mmap.2
    mtk
        SEE ALSO: Add mmap(2), shm_overview(7).

shmget.2
shmop.2
    mtk
        SEE ALSO: add shm_overview(7).

sigreturn.2
    mtk
        Added a bit more detail on what sigreturn() actually does.

signalfd.2
sigsuspend.2
    mtk
        SEE ALSO: Add sigwait(3).

sigwaitinfo.2
    mtk
        Describe behavior when multiple threads are blocked in
        sigwaitinfo()/sigtimedwait().
        SEE ALSO: Add sigwait(3).

dirfd.3
    mtk
        RETURN VALUE: describe return value on success.
        Add an ERRORS section documenting POSIX.1-specified errors.

getaddrinfo.3
    mtk, after a note by Stephane Chazelas
        getaddrinfo() supports specifying IPv6 scope-IDs.

getlogin.3
    mtk
        ERRORS: add ENOTTY.
        SEE ALSO: add utmp(5).

getutent.3
    WANG Cong
        utmpname() does return a value.
    mtk
        Add paragraph to start of DESCRIPTION recommending
        use of POSIX.1 "utmpx" functions.
        CONFORMING TO: mention utmpxname().
        Add an ERRORS section.
        There are no utmpx equivalents of the _r reentrant functions.
        Clarify discussion of return values.
        Add pointer to definition of utmp structure in utmp(5).
        Clarify discussion of utmpx file on other systems (versus
        Linux situation).

getutent.3
    mtk
        SEE ALSO: add getutmp(3)

inet_pton.3
    Stephane Chazelas
        Fix error in description of IPv6 presentation format:
        s/x.x.x.x.x.x.x.x/x:x:x:x:x:x:x:x/.

setbuf.3
    Reuben Thomas / mtk
        Fix confused wording for return value of setvbuf().
        Fixes http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=488104.
    mtk
        Other minor rewordings.

shm_open.3
    mtk
        SEE ALSO: add shm_overview(7).

random.4
    mtk, after a note by Alain Portal
        Slight rewording to make life easier for non-native English
        speakers.

utmp.5
    mtk
        Add discussion of POSIX.1 utmpx specification.
        Provide a little more detail on fields of utmp structure.
        Added comments to macros for ut_type field.
        Correct the description of the ut_id field.
    mtk
        Consolidate duplicated information about ut_tv and ut_session
        on biarch platforms.
    mtk
        Move some text from CONFORMING TO to NOTES.
        Removed some crufty text.
        SEE ALSO: add login(3), logout(3), logwtmp(3).
        UT_LINESIZE is 32 (not 12).
    mtk
        SEE ALSO: add getutmp(3)

man-pages.7
    mtk
        Enhanced the discussion of font conventions.

signal.7
    mtk
        Note that the delivery order of multiple pending standard
        signals is unspecified.
        SEE ALSO: Add sigwait(3).


==================== Changes in man-pages-3.03 ====================

Released: 2008-07-08, Konolfingen


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andi Kleen <ak@muc.de>
Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
Li Zefan <lizf@cn.fujitsu.com>
Paul Jackson <pj@sgi.com>
Sam Varshavchik <mrsam@courier-mta.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

getcpu.2
    Andi Kleen, with some text and edits by mtk
        Documents the getcpu(2) system call, introduced in Linux 2.6.19.

sched_getcpu.3
    mtk
        Documents sched_getcpu(3), a wrapper for getcpu(2), provided
        since glibc 2.6.

cpuset.7
    Paul Jackson, with review and editing by mtk, and comments by
    Hidetoshi Seto and Li Zefan
        A description of the cpuset file system, the mechanism introduced
        kernel 2.6.12 for confining processes to designated processors
        and nodes.  (Becomes the fourth largest page in man-pages!)


Newly documented interfaces in existing pages
---------------------------------------------

readdir.3
    mtk
        Add documentation of readdir_r().


New links
---------

updwtmpx.3
    Alain Portal
        Link to updwtmp.3 (3.02 changelog wrongly said this had been done).

readdir_r.3
    mtk
        Link to readdir.3.


Global changes
--------------

get_mempolicy.2
mbind.2
sched_setaffinity.2
set_mempolicy.2
    mtk
        SEE ALSO: Add getcpu(2).

accept.2
close.2
connect.2
dup.2
epoll_wait.2
fcntl.2
flock.2
futex.2
msgop.2
poll.2
read.2
recv.2
select.2
semop.2
send.2
sigwaitinfo.2
spu_run.2
wait.2
write.2
aio_suspend.3
mq_receive.3
mq_send.3
scanf.3
sem_wait.3
usleep.3
inotify.7
    mtk
        ERRORS: Added reference to signal(7) in discussion of EINTR.

Various pages
    mtk
        Wrapped very long source lines.


Changes to individual pages
---------------------------

accept.2
    mtk
        Small wording change.

io_getevents.2
    mtk
        ERRORS: Add EINTR error.

open.2
    mtk
        ERRORS: Add EINTR error.

sigaction.2
    mtk
        Note circumstances in which each SA_* flag is meaningful.
    mtk
        Describe POSIX specification, and Linux semantics for
        SA_NOCLDWAIT when establishing a handler for SIGCHLD.
    mtk
        Add pointer under SA_RESTART to new text in signal(7)
        describing system call restarting.
    mtk
        Other minor edits.

truncate.2
    mtk
        ERRORS: Added EINTR error.
        A few minor rewordings.

wait.2
    mtk
        Remove statement that WUNTRACED and WCONTINUED only have effect
        if SA_NOCLDSTOP has not been set for SIGCHLD.  That's not true.

errno.3
    mtk
        Add a pointer to signal(7) for further explanation of EINTR.

getgrouplist.3
    mtk
        SEE ALSO: Add passwd(5).

readdir.3
    mtk
        Remove <sys/types.h> from SYNOPSIS; POSIX.1-2001 does not
        require it.
        Some minor rewordings.

sleep.3
    mtk
        RETURN VALUE: explicitly mention interruption by signal handler.
        SEE ALSO: add signal(7).

usleep.3
    mtk
        POSIX.1-2001 also only documents EINVAL.

group.5
    mtk
        SEE ALSO: Add getgrent(3), getgrnam(3).

passwd.5
    mtk
        SEE ALSO: Add getpwent(3), getpwnam(3).

proc.5
    mtk
        Add pointer to description of /proc/PID/cpuset in cpuset(7).

signal.7
    mtk
        Add a section describing system call restarting, and noting
        which system calls are affected by SA_RESTART, and which
        system calls are never restarted.
    mtk
        Describe the aberrant Linux behavior whereby a stop signal
        plus SIGCONT can interrupt some system calls, even if no
        signal handler has been established, and note the system
        calls that behave this way.
    mtk
        Note a few more architectures on which signal numbers are valid.
        SEE ALSO: added a number of pages.
    mtk
        Update async-signal-safe function list for POSIX.1-2004 (which
        adds sockatmark()).


==================== Changes in man-pages-3.04 ====================

Released: 2008-07-15, Konolfingen


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andrea Arcangeli <andrea@cpushare.com>
Andreas Mohr <andi@lisas.de>
Andrew Morgan <morgan@kernel.org>
Erik Bosman <ejbosman@cs.vu.nl>
John Brooks <aspecialj@gmail.com>
Nikanth Karthikesan <knikanth@suse.de>
Pavel Heimlich <tropikhajma@seznam.cz>
Petr Gajdos <pgajdos@suse.cz>
Sam Varshavchik <mrsam@courier-mta.com>
Serge Hallyn <serue@us.ibm.com>
Sripathi Kodi <sripathik@in.ibm.com>
Vincent Lefevre <vincent@vinc17.org>

Apologies if I missed anyone!


Web site
--------

licenses.html
    mtk
        A page describing the preferred licenses for new pages that
        are contributed to man-pages.


New and rewritten pages
-----------------------

utimensat.2
    mtk
        New page documenting the utimensat() system call, new in 2.6.22,
        and futimens() library function.

end.3
    mtk
        Documents etext, edata, and end symbols.


Newly documented interfaces in existing pages
---------------------------------------------

memchr.3
    mtk
        Add description of rawmemchr().

proc.5
    mtk
        Document /proc/config.gz (new in kernel 2.6).
    mtk, based on text from Documentation/vm/sysctl.txt
        Document /proc/sys/vm/oom_kill_allocating_task
        (new in Linux 2.6.24).
        Document /proc/sys/vm/oom_dump_tasks
        (new in Linux 2.6.25).
        Document /proc/sys/vm/panic_on_oom
        (new in Linux 2.6.18).


New links
---------

edata.3
etext.3
    mtk
        Links to end.3.

futimens.3
    mtk
        Link to new utimensat.2.

getdate_err.3
    mtk
        Link to getdate.3.

h_errno.3
    mtk
        Link to gethostbyname.3.

optarg.3
opterr.3
optind.3
optopt.3
    mtk
        Links to getopt.3.

rawmemchr.3
    mtk
        Link to memchr.3.

sys_errlist.3
sys_nerr.3
    mtk
        Links to perror.3.


Global changes
--------------

Various pages
    mtk
        s/parameter/argument/ when talking about the things given
        to a function call, for consistency with majority usage.

Various pages
    mtk
        s/UNIX/Unix/, when not used as part of a trademark,
        for consistency with majority usage in pages.

Various pages
    mtk, after a note from Alain Portal
        Put SEE ALSO entries into alphabetical order.

Various pages
    mtk
        Remove period at end of SEE ALSO list.

Various pages
    mtk, after a note by Alain Portal
        Even when the CONFORMING TO section is just a list of standards,
        they should be terminated by a period.

getpriority.2
MB_LEN_MAX.3
MB_CUR_MAX.3
fwide.3
mblen.3
rtime.3
st.4
proc.5
bootparam.7
man-pages.7
utf-8.7
tcp.5
    mtk / Alain Portal
        Small wording fixes -- express <=, <, >=, > in words when in
        running text.

sched_setparam.2
sched_setscheduler.2
getgrent_r.3
hash.3
    mtk
        Minor rewording w.r.t. use of the term "parameter".

Typographical or grammatical errors have been corrected in several
other places.  (Many, many thanks to Alain Portal!)


Changes to individual pages
---------------------------

capget.2
    Andrew Morgan
        Update in line with addition of file capabilities and
        64-bit capability sets in kernel 2.6.2[45].

clock_nanosleep.2
    mtk
        Add "Link with -lrt" to SYNOPSIS.

getrusage.2
    Sripathi Kodi
        Document RUSAGE_THREAD, new in 2.6.26.
    mtk
        Improve description of RUSAGE_CHILDREN.
        Add pointer to /proc/PID/stat in proc(5).
        Other minor clean-ups.

ioprio_set.2
    Nikanth Karthikesan
        Since Linux 2.6.25, CAP_SYS_ADMIN is longer required to set
        a low priority (IOPRIO_CLASS_IDLE).

mount.2
    mtk
        Since Linux 2.6.26, MS_RDONLY honors bind mounts.

openat.2
    mtk
        SEE ALSO: add utimensat(3).

prctl.2
    Serge Hallyn, with some edits/input from mtk
        Document PR_CAPBSET_READ and PR_CAPBSET_DROP.
    Erik Bosman
        Document PR_GET_TSC and PR_SET_TSC.
    mtk, reviewed by Andrea Arcangeli
        Document PR_SET_SECCOMP and PR_GET_SECCOMP.
    mtk
        PR_SET_KEEPCAPS and PR_GET_KEEPCAPS operate on a per-thread
        setting, not a per-process setting.
    mtk
        Clarify fork(2) details for PR_SET_PDEATHSIG.
    mtk
        Add description of PR_SET_SECUREBITS and PR_GET_SECUREBITS,
        as well as pointer to further info in capabilities(7).
    mtk
        PR_GET_ENDIAN returns endianness info in location pointed to by
        arg2 (not as function result, as was implied by previous text).
    mtk
        Expand description of PR_SET_NAME and PR_GET_NAME.
    mtk
        RETURN VALUE: bring up to date for various options.
    mtk
        Various improvements in ERRORS.
    mtk
        Note that PR_SET_TIMING setting of PR_TIMING_TIMESTAMP is not
        currently implemented.
    mtk
        Minor changes:
        * Clarify wording for PR_GET_UNALIGN, PR_GET_FPEMU, and
          PR_GET_FPEXC.
        * Some reformatting of kernel version information.
        * Reorder PR_GET_ENDIAN and PR_SET_ENDIAN entries.

readlinkat.2
    John Brooks / mtk
         Fix and reword erroneous RETURN VALUE text.

recv.2
    mtk
        Noted which flags appeared in Linux 2.2.

sched_setaffinity.2
    mtk, after a Fedora downstream patch
        Update type used for cpusetsize argument in SYNOPSIS.

select.2
    Andreas Mohr / mtk
        Clarify "zero timeout" case.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=490868.

send.2
    mtk
        Noted which flags appeared in Linux 2.2.

sigaction.2
    mtk
        Document si_overrun and si_tid fields of siginfo structure.
        Add some text for si_trapno field.
        The si_errno field is *generally* unused.
    mtk
        Put descriptions of SA_* constants in alphabetical order.

signal.2
    mtk
        Rewrote and expanded portability discussion.
        NOTES: Show the raw prototype of signal() (without use of
        sighandler_t).

signalfd.2
    mtk
        Modify description of ssi_trapno field.

swapon.2
    mtk
        Fix two version number typos for MAX_SWAPFILES discussion:
        s/2.6.10/2.4.10/

utime.2
    mtk
         SEE ALSO: add utimensat(2), futimens(3).

dl_iterate_phdr.3
    Alain Portal
        SEE ALSO: Add elf(5).

crypt.3
    mtk, after a Fedora downstream patch
        Describe additional encryption algorithms.
	See also: https://bugzilla.redhat.com/show_bug.cgi?id=428280.

errno.3
    mtk
        Small rewrites in DESCRIPTION.

exec.3
    mtk, after a note from Alain Portal
        Small rewording.

exp10.3
    Alain Portal
        SEE ALSO: Add log10(3).

exp2.3
    Alain Portal
        Add C99 to CONFORMING TO.

fgetgrent.3
    Alain Portal
        Add references to group(5).
    mtk
        Minor rewordings.
        SEE ALSO: add fopen(3).

fgetpwent.3
    Alain Portal
        Add reference to passwd(5).
    mtk
        Minor rewordings.
        SEE ALSO: add fopen(3).

frexp.3
    Alain Portal
        Add C99 to CONFORMING TO.

futimes.3
    mtk
         SEE ALSO: remove futimesat(2); add utimensat(2).

getopt.3
    mtk
        Add details on initial value of optind, and note that it can
        be reset (to 1) to restart scanning of an argument vector.
        Add a NOTES section describing the glibc-specific behavior
        when optind is reset to 0 (rather than 1).
        See http://groups.google.com/group/comp.unix.programmer/browse_thread/thread/be0d0b7a07a165fb
    mtk
        Note glibc extensions under CONFORMING TO.

getspnam.3
    mtk
        Improve comments on struct spwd.

getpw.3
    Alain Portal
        RETURN VALUE: note that errno is set on error.
    mtk
        Add EINVAL error.

insque.3
    mtk / Alain Portal
        Minor rewordings.

log.3
    Alain Portal
        Remove unnecessary sentence in ERRORS.

log10.3
    mtk
        SEE ALSO: Add exp10(3).

offsetof.3
    Alain Portal
        Small wording improvement.

pow.3
    Alain Portal
        Remove unnecessary sentence in ERRORS.

printf.3
    mtk / Alain Portal
        Many small formatting fixes.

proc.5
    mtk
        Remove redundant summary list of files in description of
        /proc/sys/kernel.
        Make kernel version for /proc/sys/kernel/panic_on_oops more precise.
        Make kernel version for /proc/sys/kernel/pid_max more precise.
        Add Documentation/sysctl/vm.txt to SEE ALSO.
        Other minor edits.

profil.3
    mtk / Alain Portal
         Small wording improvement.

rtime.3
    mtk, after a note by Alain Portal
        Clarify meaning of midnight on 1 Jan 1900/1970.
    mtk
        Remove netdate(1) and rdate(1) from SEE ALSO, since these pages
        don't seem to exist on Linux systems.

scanf.3
    Vincent Lefevre / mtk
        Clarify treatment of initial white space by %% conversion
        specification.
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=435648.
    mtk
        Many small formatting fixes.

stdin.3
    Alain Portal
        Rename CONSIDERATIONS section to NOTES, and relocate
        to appropriate place on page.

tmpfile.3
    mtk, after a note by Alain Portal
        Prepend "POSIX.1-2001 specifies that: " to the sentence stating
        that tmpfile() may write to stdout.  (AFAICS, glibc's tmpfile()
        does not do this.)

ttyname.3
    Alain Portal
        Remove unnecessary sentence in ERRORS.

wcsdup.3
    Alain Portal
        Make wording more precise: the memory allocated by wcsdup(3)
        *should* be freed with free(3).

wordexp.3
    Alain Portal / mtk
        Move example into proper EXAMPLE section.

tty_ioctl.4
    mtk / Petr Gajdos
        The features in the "Get and Set Window Size" subsection
        require the inclusion of <sys/ioctl.h>.

capabilities.7
    Serge Hallyn, plus a bit of work by mtk
        Document file capabilities, per-process capability bounding set,
        changed semantics for CAP_SETPCAP, and other changes in 2.6.2[45].
        Add CAP_MAC_ADMIN, CAP_MAC_OVERRIDE, CAP_SETFCAP.
        Various smaller fixes.
    mtk, plus review by Serge Hallyn and Andrew Morgan
        Add text detailing how CAP_SETPCAP (theoretically) permits -- on
        pre-2.6.25 kernels, and 2.6.25 and later kernels with file
        capabilities disabled -- a thread to change the capability sets
        of another thread.
        Add section describing rules for programmatically adjusting
        thread capability sets.
        Add some words describing purpose of inheritable set.
        Note existence of CONFIG_SECURITY_CAPABILITIES config option.
        Describe rationale for capability bounding set.
        Document securebits flags (new in 2.6.26).
        Remove obsolete BUGS section.
        SEE ALSO: Add getcap(8), setcap(8), and various libcap pages.
    mtk
        Add text noting that if we set the effective flag for one
        file capability, then we must also set the effective flag for all
        other capabilities where the permitted or inheritable bit is set.
    mtk
        Since Linux 2.6.25, CAP_SYS_ADMIN is no longer required for
        ioprio_set() to set IOPRIO_CLASS_IDLE class.
    mtk
        Reword discussion of CAP_LINUX_IMMUTABLE to be file-system neutral.

man-pages.7
   mtk
       A list of standards in the CONFORMING TO list should be
       terminated by a period.
       The list of pages in a SEE ALSO list should not be
       terminated by a period.

tcp.7
    mtk
        Correct a detail for sysctl_tcp_adv_win_scale.
        Formatting fixes.


==================== Changes in man-pages-3.05 ====================

Released: 2008-07-23, Konolfingen


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Brian M. Carlson <sandals@crustytoothpaste.ath.cx>
Fabian Kreutz <kreutz@dbs.uni-hannover.de>
Franck Jousseaume <franck.jousseaume@gmail.com>
Sam Varshavchik <mrsam@courier-mta.com>
Uli Schlacter <psychon@znc.in>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

matherr.3
    mtk, with review by Andries Brouwer
        A description of the SVID-specified mechanism for reporting
        math exceptions.
        See http://thread.gmane.org/gmane.linux.man/266.

math_error.7
    mtk, with review and suggested input from Andries Brouwer
        A description of how math functions report errors.
        See http://thread.gmane.org/gmane.linux.man/249.


Global changes
--------------

Various pages
    mtk
        s/floating point/floating-point/ when used attributively.

Various pages
    mtk
        For consistency with majority usage:
        s/plus infinity/positive infinity/
        s/minus infinity/negative infinity/

Typographical or grammatical errors have been corrected in several
other places.


Changes to individual pages
---------------------------

brk.2
    mtk
        SEE ALSO: add end(3).

open.2
    Brian M. Carlson / mtk
        Remove ambiguity in description of support for O_EXCL on NFS.
        As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=491791.

prctl.2
    mtk
        Place options in some semblance of alphabetical order.
        (No content or formatting changes were made.)

cerf.3
    mtk
        Bump version number: these functions are still missing in
        glibc 2.8.

fenv.3
    mtk
        SEE ALSO: Add math_error(7).

INFINITY.3
    mtk
        SEE ALSO: Add math_error(7).

nan.3
    mtk
        Remove unneeded "Compile with" piece in SYNOPSIS.
        SEE ALSO: Add math_error(7).

rpc.3
    mtk / Franck Jousseaume
        Fix errors introduced into a few prototypes when converting
        function declarations to use modern C prototypes in man-pages-2.75.

ipv6.7
    mtk, after a report from Uli Schlacter
        Document the IPV6_V6ONLY flag.


==================== Changes in man-pages-3.06 ====================

Released: 2008-08-05, Konolfingen


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andreas Jaeger <aj@novell.com>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Fabian Kreutz <kreutz@dbs.uni-hannover.de>
Gernot Tenchio <g.tenchio@telco-tech.de>
Sam Varshavchik <mrsam@courier-mta.com>
Tolga Dalman <tdalman@project-psi.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

erfc.3
    mtk
        Created after removing the erfc() material from erf.3.
        Documents the complementary error function.

y0.3
    mtk
        Created after removing the y*() material from j0.3.
        Documents the Bessel functions of the second kind.
        Included ERRORS section; noted that an exception is not
        raised on underflow, see also
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6806;
        and errno is not set on overflow, see also
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6808;
        Included BUGS section noting that errno is incorrectly
        set for pole error; see also
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6807.

scalbln.3
    mtk
        Created after removing the scalbln*() and scalbn*() material
        from scalb.3.  Documents scalbln() and scalbn() functions.
        Included ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6803.


New and changed links
---------------------

erfcf.3
erfcl.3
    mtk
        Changed these links to point to new erfc.3 page.

scalblnf.3
scalblnl.3
scalbn.3
scalbnf.3
scalbnl.3
    mtk
        Changed these links to point to new scalbln.3 page.

y0f.3
y0l.3
y1.3
y1f.3
y1l.3
yn.3
ynf.3
ynl.3
    mtk
        Changed these links to point to new y0.3 page.


Global changes
--------------

Various pages
    mtk
        s/floating point/floating-point/ when used attributively.

Typographical or grammatical errors have been corrected in several
other places.


Changes to individual pages
---------------------------

crypt.3
    mtk
        Tweak discuss text describing support for Blowfish.

ctime.3
    mtk / Gernot Tenchio
        Added some words to make clear that the string returned by
        ctime() and asctime() is null-terminated.

math_error.7
    Sam Varshavchik
        Reverse order of SYNOPSIS and NAME sections.
    mtk
        NOTES: Summarize the state of glibc support for exceptions
        and errno for error reporting.


Changes to individual pages (math functions)
--------------------------------------------

Almost all of the changes in this release relate to math man pages.
Very many changes were made to the math pages, including:

* Fixed feature test macros (FTMs).  Often, the FTM requirements
  for the "float" and "long double" versions of a math function are
  different from the requirements for the "double" version.  Each math
  page now shows the correct FTM requirements for all three versions
  of the function(s) it describes.  This may have required either
  a change to the existing FTM text (if the requirements for the
  "double" function were already described), or the addition of an FTM
  description to a SYNOPSIS where one was not previously present
  (typically because the "double" version of the function does not
  require any FTMs to be defined).
* CONFORMING TO: in many cases, POSIX.1-2001 was not mentioned.
  Where a function is specified in POSIX.1-2001, this is now noted.
  Also, statements about what other standards a function conforms to
  were generally clarified.  (The wording about which functions conformed
  to C99 was previously often done as an add on sentence; now it is made
  part of the first sentence of the CONFORMING TO section, along with
  POSIX.1-2001.)
* RETURN VALUE: in many cases, pages lacked descriptions of the return
  value when the function arguments are special values such as +0, -0,
  NaN (not-a-number), +infinity, -infinity, etc.  This has been fixed.
  I carried out tests on glibc 2.8 to ensure that all of these
  functions match the RETURN VALUE descriptions (and the POSIX.1-2001
  requirements).
* ERRORS: many pages lacked a clear (or indeed any) description of
  how errno is set on error and what exception is raised for each error.
  This has been fixed.  The ERRORS sections are now generally headed up
  as per the POSIX.1 way of doing things, describing Pole / Range /
  Domain errors, as applicable.
  I carried out tests on glibc 2.8 to ensure that all of these
  functions match the ERRORS descriptions.  Deviations from POSIX.1-2001
  requirements have been filed as glibc bug reports, and noted in the
  man pages.  (The pages now describe the situation for ERRORS as at glibc
  2.8; I may eventually try and extend the text with descriptions of
  changes in older versions of glibc.)
  NOTE: one point that has not been covered in any page is the
  circumstances that generate inexact (FE_INEXACT) exceptions.
  (The details for these exceptions are not specified in POSIX.1-2001,
  and I haven't gone looking for the standards that describe the details.)

acos.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section.
        Updated CONFORMING TO.

acosh.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        Added RETURN VALUE section.
        Rewrote ERRORS section.
        Updated CONFORMING TO.

asin.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section.
        Updated CONFORMING TO.

asinh.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        DESCRIPTION: Some rewording.
        RETURN VALUE: Added details for special argument cases.
        Added (null) ERRORS section.
        Updated CONFORMING TO.

atan.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        DESCRIPTION: Some rewording.
        RETURN VALUE: Added details for special argument cases.
        Added (null) ERRORS section.
        Updated CONFORMING TO.

atan2.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        DESCRIPTION: Some rewording.
        RETURN VALUE: Added details for special argument cases.
        Added (null) ERRORS section.
        Updated CONFORMING TO.

atanh.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        Added RETURN VALUE section.
        Rewrote ERRORS section.
        Updated CONFORMING TO.
        Added BUGS section noting that pole error sets errno to EDOM,
        when it should be ERANGE instead; see also
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6759.

cbrt.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        Added RETURN VALUE section.
        Added (null) ERRORS section.
        Updated CONFORMING TO.

ceil.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        DESCRIPTION: Enhanced.
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section.
        Updated CONFORMING TO.
        NOTES: Added some details.

copysign.3
    mtk
        Added RETURN VALUE section.
        Updated CONFORMING TO.

cos.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Rewrote RETURN VALUE section.
        Added ERRORS section; noted errno is not set:
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6780.
        Updated CONFORMING TO.

cosh.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section.
        Updated CONFORMING TO.

erf.3
    mtk
        Removed the erfc() material (there is now a new erfc page).
        Reason: the functions are logically separate; also their
        return values differ, and it would have been confusing
        to document them on the same page.
        SYNOPSIS: Fixed feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set; see
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6785.
        Updated CONFORMING TO.

exp.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set; see
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6786.
        Updated CONFORMING TO.

exp10.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set for underflow;
        see http://sources.redhat.com/bugzilla/show_bug.cgi?id=6787.

exp2.3
    mtk
        Added RETURN VALUE and ERRORS sections.
        Updated CONFORMING TO.

expm1.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set for overflow;
        see http://sources.redhat.com/bugzilla/show_bug.cgi?id=6788.
        Updated CONFORMING TO.
        Added BUGS section, describing bogus underflow exception for -large,
        see http://sources.redhat.com/bugzilla/show_bug.cgi?id=6778;
        and describing bogus invalid exception for certain +large,
        see http://sources.redhat.com/bugzilla/show_bug.cgi?id=6814.

fabs.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Updated CONFORMING TO.

fdim.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        DESCRIPTION: Some rewording.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6796.
        Updated CONFORMING TO.

fenv.3
    mtk
        Make style of writing exception names consistent with other
        pages and POSIX.1-2001.
        Updated CONFORMING TO.

finite.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.

floor.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        DESCRIPTION: Enhanced.
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section.
        Updated CONFORMING TO.

fma.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        DESCRIPTION: Some rewording.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6801.
        Updated CONFORMING TO.

fmax.3
fmin.3
    mtk
        NAME: Make description clearer
        SYNOPSIS: Added feature test macro requirements.
        SYNOPSIS: Remove unneeded "Compile with" piece.
        CONFORMING TO: Added POSIX.1-2001.
        Added RETURN VALUE and ERRORS sections.

fmod.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section; noted that errno is not always set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6783.
        Updated CONFORMING TO.

fpclassify.3
    mtk
        Minor wording changes.
        CONFORMING TO: Added POSIX.1-2001.
        SEE ALSO: Add signbit(3).

frexp.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added details to RETURN VALUE section.
        Added (null) ERRORS section.
        CONFORMING TO: Added POSIX.1-2001.

gamma.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        Added (null) RETURN VALUE section referring to tgamma(3).
        Added (null) ERRORS section referring to tgamma(3).
        CONFORMING TO: Rewrote.

hypot.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        DESCRIPTION: note that calculation is done without causing
        undue overflow or underflow.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not always set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6795.
        Updated CONFORMING TO.

ilogb.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Rewrote RETURN VALUE section.
        Rewrote ERRORS section; noted that errno is not set, and in some
        cases an exception is not raised; see also
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6794.
        CONFORMING TO: Added POSIX.1-2001.

isgreater.3
    mtk
        NAME: Make description clearer
        Improve the description of isunordered().
        Added RETURN VALUE and ERRORS sections.
        Formatting fixes.
        A few wording improvements.

j0.3
    mtk
        Removed material for the y*() functions to a separate y0.3 page.
        Reason: the return values and errors/exceptions differ, and it
        would have been confusing to document them on the same page.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6805.

ldexp.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE and ERRORS sections.
        Updated CONFORMING TO.

lgamma.3
    mtk
        Note that these functions are deprecated.
        SYNOPSIS: Fixed feature test macro requirements.
        Added RETURN VALUE and ERRORS sections referring to lgamma(3).
        Added BUGS section noting that pole error sets errno to EDOM,
        when it should be ERANGE instead; see also
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6777.

log.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Rewrote ERRORS section.
        Updated CONFORMING TO.

log10.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Rewrote ERRORS section.
        Updated CONFORMING TO.

log1p.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6792.
        Updated CONFORMING TO.

log2.3
    mtk
        Added RETURN VALUE section.
        Rewrote ERRORS section.
        Updated CONFORMING TO.

logb.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        DESCRIPTION: added a little detail; some rewordings.
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6793.
        CONFORMING TO: Added POSIX.1-2001.

lrint.3
    mtk
        DESCRIPTION: some rewording.
        RETURN VALUE: Added details for special argument cases.
        Added ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6798.
        CONFORMING TO: Added POSIX.1-2001.

lround.3
    mtk
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6797.
        CONFORMING TO: Added POSIX.1-2001.

modf.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        RETURN VALUE: Added details for special argument cases.
        Added (null) ERRORS section.
        CONFORMING TO: Added POSIX.1-2001.

nan.3
    mtk
        Small wording changes.
        CONFORMING TO: Added POSIX.1-2001.

nextafter.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        RETURN VALUE: Added details for special argument cases.
        Added ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6799.
        CONFORMING TO: Added POSIX.1-2001.

pow.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Rewrote ERRORS section.
        Updated CONFORMING TO.
        Added BUGS section noting that pole error sets errno to EDOM,
        when it should be ERANGE instead; see also
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6776.

remainder.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        DESCRIPTION: added some details.
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section; noted that errno is not always set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6783.
        Updated CONFORMING TO.
        Added BUGS section noting that remainder(nan(""), 0)
        wrongly causes a domain error; see
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6779

remquo.3
   mtk
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6801.
        Updated CONFORMING TO.

fmax.3
fmin.3
    mtk
        NAME: Make description clearer
        SYNOPSIS: Added feature test macro requirements.
        SYNOPSIS: Remove unneeded "Compile with" piece.
        CONFORMING TO: Added POSIX.1-2001.
        Added RETURN VALUE and ERRORS sections.

fmod.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        RETURN VALUE: Added details for special argument cases.
        Rewrote ERRORS section; noted that errno is not always set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6783.
        Updated CONFORMING TO.

fpclassify.3
        CONFORMING TO: Added POSIX.1-2001.

rint.3
    mtk
        SYNOPSIS: Fixed feature test macro requirements.
        DESCRIPTION: added some details.
        RETURN VALUE: Added details for special argument cases.
        ERRORS: no errors can occur (previous text was misleading).
        CONFORMING TO: Added POSIX.1-2001.
        NOTES: point out that lrint() may be preferred in some cases.

round.3
    mtk
        DESCRIPTION: added some details.
        RETURN VALUE: Added details for special argument cases.
        ERRORS: no errors can occur (previous text was misleading).
        CONFORMING TO: Added POSIX.1-2001.
        NOTES: point out that lround() may be preferred in some cases.

scalb.3
    mtk
        Removed the scalbn() and scalbln() material to a separate
        scalbln.3 page.  Reason: scalb() is obsolete; also the
        exception/error conditions differ somewhat, so that it
        would have been confusing to document them on the same page.
        SYNOPSIS: Fixed feature test macro requirements.
        DESCRIPTION: some rewrites and added details.
        Added RETURN VALUE section.
        Added ERRORS section; noted that errno is not set; see
        also http://sources.redhat.com/bugzilla/show_bug.cgi?id=6803
        and http://sources.redhat.com/bugzilla/show_bug.cgi?id=6804.
        CONFORMING TO: Rewrote.

signbit.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        SYNOPSIS: Remove unneeded "Compile with" piece.
        Added RETURN VALUE section.
        Added (null) ERRORS section.
        CONFORMING TO: Added POSIX.1-2001.

sin.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section; noted errno is not set:
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6781.
        Updated CONFORMING TO.

sincos.3
    mtk
        DESCRIPTION: Added details for special argument cases.
        Added (null) RETURN VALUE section.
        Added ERRORS section.

sinh.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section.
        Updated CONFORMING TO.

sqrt.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Rewrote ERRORS section.
        Updated CONFORMING TO.

tan.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Added ERRORS section.
        Added ERRORS section; noted errno is not set:
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6782.
        Updated CONFORMING TO.

tanh.3
    mtk
        SYNOPSIS: Added feature test macro requirements.
        Added RETURN VALUE section.
        Added (null) ERRORS section.
        Updated CONFORMING TO.

tgamma.3
    mtk
        Added RETURN VALUE section.
        Rewrote ERRORS section; noted that errno is not set /
        incorrectly set in some cases; see also
        http://sources.redhat.com/bugzilla/show_bug.cgi?id=6809
        and http://sources.redhat.com/bugzilla/show_bug.cgi?id=6810.
        CONFORMING TO: Added POSIX.1-2001.
        Added NOTES section to hold text explaining origin of tgamma().

trunc.3
    mtk
        RETURN VALUE: small rewording.
        CONFORMING TO: Added POSIX.1-2001.
        Added NOTES section explaining that result may be too large
        to store in an integer type.


==================== Changes in man-pages-3.07 ====================

Released: 2008-08-12, Konolfingen


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alain Portal <aportal@univ-montp2.fr>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Christoph Lameter <cl@linux-foundation.org>
Cliff Wickman <cpw@sgi.com>
Fabian Kreutz <kreutz@dbs.uni-hannover.de>
Filippo Santovito <filippo.santovito@email.it>
Gerrit Renker <gerrit@erg.abdn.ac.uk>
Heikki Orsila <shd@modeemi.cs.tut.fi>
Khalil GHORBAL <khalil.ghorbal@cea.fr>
Lee Schermerhorn <lee.schermerhorn@hp.com>
Maxin John <maxin.john@gmail.com>
Reuben Thomas <rrt@sc3d.org>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Sam Varshavchik <mrsam@courier-mta.com>
Soh Kam Yung <sohkamyung@gmail.com>
Stephane Chazelas <stephane_chazelas@yahoo.fr>
Pavel Heimlich <tropikhajma@seznam.cz>
Reuben Thomas <rrt@sc3d.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

move_pages.2
    Christoph Lameter, various edits and improvements by mtk
        Documentation of the move_pages() system call.
        This page was formerly part of the numactl package, but really
        belongs in man-pages (since it describes a kernel interface).

clock_getcpuclockid.3
    mtk
        New page documenting the clock_getcpuclockid() library function,
        available since glibc 2.2.

udplite.7
    Gerrit Renker
        Document the Linux implementation of the UDP-Lite protocol,
        new in Linux 2.6.20.


Newly documented interfaces in existing pages
---------------------------------------------

proc.5
    Christoph Lameter, minor edits and improvements by mtk
        Documentation of the /proc/PID/numa_maps file.
        This material was formerly the numa_maps.5 page in the numactl
        package, but really belongs in man-pages (since it describes
        a kernel interface).


Global changes
--------------

nanosleep.2
inet_ntop.3
inet_pton.3
scanf.3
initrd.4
    mtk
        Fix mis-ordered (.SH) sections.

connect.2
socket.2
rtnetlink.3
arp.7
ddp.7
ip.7
ipv6.7
netlink.7
packet.7
raw.7
rtnetlink.7
socket.7
tcp.7
udp.7
unix.7
x25.7
    mtk
        s/PF_/AF_/ for socket family constants.  Reasons: the AF_ and
        PF_ constants have always had the same values; there never has
        been a protocol family that had more than one address family,
        and POSIX.1-2001 only specifies the AF_* constants.

Typographical or grammatical errors have been corrected in several
other places.


Changes to individual pages
---------------------------

execve.2
    mtk
        The floating-point environment is reset to the default
        during an execve().

get_mempolicy.2
    Lee Schermerhorn
        Misc cleanup of get_mempolicy(2):
        + mention that any mode flags will be saved with mode.
          I don't bother to document mode flags here because we
          already have a pointer to set_mempolicy(2) for more info
          on memory policy.  mode flags are discussed there.
        + remove some old, obsolete [IMO] NOTES and 'roff comments.
    Lee Schermerhorn
        Update the get_mempolicy(2) man page to add in the description of
        the MPOL_F_MEMS_ALLOWED flag, added in 2.6.23.
    mtk
        Document additional EINVAL error that occurs is MPOL_F_MEMS_ALLOWED
        is specified with either MPOL_F_ADDR or MPOL_F_NODE.

getitimer.2
    mtk
        CONFORMING TO: POSIX.1-2008 marks getitimer() and setitimer()
        obsolete.

mbind.2
    Lee Schermerhorn
        Fix error conditions, now that the kernel silently ignores
        nodes outside the task's cpuset, as long as one valid node
        remains.

        Now that cpuset man page exists, we can refer to it.  Remove
        stale comment regarding lack thereof.
    Lee Schermerhorn
        Add brief discussion of mode flags.
    Lee Schermerhorn
        Attempt to clarify discussion of MPOL_DEFAULT.
    mtk
        Fix URI reference for libnuma.

mprotect.2
    mtk / Maxin John
        Remove EFAULT from errors.  Under ENOMEM error, note that
        EFAULT was the error produced in some cases for kernels before
        2.4.19.

msgctl.2
    mtk, after a note from Filippo Santovito
        In the ipc_perm structure definition, some fields were
        incorrectly named: s/key/__key/ and s/seq/__seq/.

set_mempolicy.2
    Lee Schermerhorn
        Fix up the error return for nodemask containing nodes disallowed by
        the process' current cpuset.  Disallowed nodes are now silently ignored,
        as long as the nodemask contains at least one node that is on-line,
        allowed by the process' cpuset and has memory.

        Now that we have a cpuset man page, we can refer to cpusets directly
        in the man page text.

    Lee Schermerhorn
        Another attempt to rationalize description of MPOL_DEFAULT.

        Since ~2.6.25, the system default memory policy is "local allocation".
        MPOL_DEFAULT itself is a request to remove any non-default policy and
        "fall back" to the surrounding context.  Try to say that without delving
        into implementation details.

    Lee Schermerhorn
        Add discussion of mempolicy mode flags to set_mempolicy(2).
        This adds another reason for EINVAL.

setpgid.2
    mtk
        CONFORMING TO: POSIX.1-2008 marks setpgrp() obsolete.

semctl.2
    mtk, after a note from Filippo Santovito
        In the ipc_perm structure definition, some fields were
        incorrectly named: s/key/__key/ and s/seq/__seq/.

shmctl.2
    Filippo Santovito / mtk
        In the ipc_perm structure definition, some fields were
        incorrectly named: s/key/__key/ and s/seq/__seq/.

utime.2
    mtk
        CONFORMING TO: POSIX.1-2008 marks utime() obsolete.
        CONFORMING TO: POSIX.1-2008 removes the POSIX.1-2001 LEGACY
        marking of utimes(), so mention of this point has been
        removed from the page.

vfork.2
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of vfork().

atan2.3
    Fabian Kreutz
        SEE ALSO Add carg(3).

bcmp.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of bcmp().

bsd_signal.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification ofcw
        bsd_signal().

bzero.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of bzero().

cexp2.3
    mtk
        AVAILABILITY: These functions are still not in glibc
        as at version 2.8.

clock_getres.3
    mtk
         SEE ALSO: Add clock_getcpuclockid(3).

clog2.3
    mtk
        AVAILABILITY: These functions are still not in glibc
        as at version 2.8.

ctime.3
    mtk
        POSIX.1-2008 marks asctime(), asctime_r(), ctime(), and ctime_r()
        as obsolete.

dprintf.3
    mtk
       CONFORMING TO: These functions are nowadays in POSIX.1-2008.

ecvt.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specifications of
        ecvt() and fcvt().

ftime.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of ftime().

ftw.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks ftw() as obsolete.

gcvt.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of gcvt().

getcwd.3
    Reuben Thomas / mtk
        Clarify description of getcwd() for buf==NULL case;
        CONFORMING TO: According to POSIX.1, the behavior of getcwd()
        is unspecified for the buf==NULL case.
    mtk
        Add an introductory paragraph giving an overview of what these
        functions do.
        Fix error in description of getwd(): it does not truncate the
        pathname; rather, it gives an error if the pathname exceeds
        PATH_MAX bytes.
        Rewrote RETURN VALUE section.
        Add EINVAL ENAMETOOLONG errors for getwd().
        Various other clarifications and wording fixes.
        CONFORMING TO: POSIX.1-2001 does not define any errors for
        getwd().
        CONFORMING TO: POSIX.1-2008 removes the specification of getwd().

gethostbyname.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specifications of
        gethostbyname(), gethostbyaddr(), and h_errno.

gets.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of gets().

iconv.3
iconv_close.3
iconv_open.3
    mtk
        VERSIONS: These functions are available in glibc since version 2.1.

index.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specifications of
        index() and rindex().

isalpha.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks isalpha() as obsolete.

makecontext.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specifications of
        makecontext() and swapcontext().

memchr.3
    mtk
        VERSIONS: memrchr() since glibc 2.2; rawmemchr() since glibc 2.1.

mempcpy.3
    mtk
        VERSIONS: mempcpy() since glibc 2.1.

mktemp.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of mktemp().

opendir.3
    mtk
        CONFORMING TO: POSIX.1-2008 specifies fdopendir().

rand.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks rand_r() as obsolete.

siginterrupt.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks siginterrupt() as obsolete.

sigset.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks sighold(), sigignore(),
        sigpause(), sigrelse(), and sigset() as obsolete.

strchr.3
    mtk
        VERSIONS: strchrnul() since glibc 2.1.1.

tempnam.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks tempnam() as obsolete.

tmpnam.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks tmpnam() as obsolete.

toascii.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks toascii() as obsolete.

ualarm.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of ualarm().

ulimit.3
    mtk
        CONFORMING TO: POSIX.1-2008 marks ulimit() as obsolete.

usleep.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of usleep().

standards.7
    mtk
        Updated details for POSIX.1-2008, and noted that if
        POSIX.1-2001 is listed in the CONFORMING TO section of a man
        page, then the reader can assume that the interface is also
        specified in POSIX.1-2008, unless otherwise noted.

time.7
    mtk
         SEE ALSO: Add clock_getcpuclockid(3).

udp.7
    mtk
        SEE ALSO: add udplite(7).


Changes to individual pages (math functions)
--------------------------------------------

Various changes here following on from the big update to the
math pages in the previous release.  Test results going back
glibc 2.3.2 (so far) allowed updates to various pages to note
changes in historical behavior for error reporting by math
functions.  Thanks to the following people for providing me
with test results on various distributions and glibc versions:
Alain Portal, Andries Brouwer, Fabian Kreutz, Heikki Orsila,
Khalil GHORBAL, Pavel Heimlich, Reuben Thomas, Samuel Thibault,
Soh Kam Yung, and Stephane Chazelas

cabs.3
cacos.3
cacosh.3
carg.3
casin.3
casinh.3
catan.3
catanh.3
ccos.3
ccosh.3
cexp.3
cimag.3
clog.3
clog10.3
conj.3
cpow.3
cproj.3
creal.3
csin.3
csinh.3
csqrt.3
ctan.3
ctanh.3
exp10.3
exp2.3
fdim.3
fenv.3
fma.3
fmax.3
fmin.3
log2.3
lrint.3
lround.3
nan.3
pow10.3
remquo.3
round.3
scalbln.3
sincos.3
tgamma.3
trunc.3
    mtk
        Added VERSIONS section noting that these functions first
        appeared in glibc in version 2.1.

cosh.3
    mtk
        BUGS: In glibc 2.3.4 and earlier, an FE_OVERFLOW exception is not
        raised when an overflow occurs.

fenv.3
    mtk / Fabian Kreuz
        Provide more detail in the description of rounding modes.
        Add text describing FLT_ROUNDS (formerly in fma.3).
        Add BUGS section pointing out the FLT_ROUNDS does not reflect
        changes by fesetround().

fma.3
    mtk
        Remove text about FLT_ROUNDS, replacing with a cross-reference
        to fenv(3).

fpclassify.3
    mtk
        CONFORMING TO: Note that the standards provide a weaker guarantee
        for the return value of isinf().

log.3
    mtk
        BUGS: In glibc 2.5 and earlier, log(nan("")) produces a bogus
        FE_INVALID exception.

lround.3
    mtk
        Add reference to fenv(3) for discussion of current rounding mode.

nextafter.3
    mtk
        BUGS: In glibc 2.5 and earlier these functions do not raise an
        FE_UNDERFLOW exception on underflow.

pow.3
    mtk
        BUGS: described buggy NaN return when x is negative and y is large.
        See also: http://sources.redhat.com/bugzilla/show_bug.cgi?id=3866.
        BUGS: Note the bogus FE_INVALID exception that occurred in glibc
        2.3.2 and earlier on overflow and underflow.

remainder.3
    mtk
        Add reference to fenv(3) for discussion of current rounding mode.

round.3
    mtk
        Add reference to fenv(3) for discussion of current rounding mode.

scalb.3
    mtk
        CONFORMING TO: POSIX.1-2008 removes the specification of scalb().

tgamma.3
    mtk
        BUGS: In glibc 2.3.3, tgamma(+-0) produced a domain error
        instead of a pole error.

y0.3
    mtk
        In glibc 2.3.2 and earlier, these functions do not raise an
        FE_INVALID exception for a domain error.

math_error.7
    mtk
        Rewrite introductory paragraph.
        Point out that a NaN is commonly returned by functions that report
        a domain error.


==================== Changes in man-pages-3.08 ====================

Released: 2008-08-27, Zurich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Gerrit Renker <gerrit@erg.abdn.ac.uk>
Li Zefan <lizf@cn.fujitsu.com>
Mike Bianchi <MBianchi@foveal.com>
Sam Varshavchik <mrsam@courier-mta.com>
Venkatesh Srinivas <me@acm.jhu.edu>
Vijay Kumar <vijaykumar@bravegnu.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

getnetent_r.3
    mtk
        Documents getnetent_r(), getnetbyname_r(),
        and getnetbyaddr_r(), the reentrant equivalents of
        getnetent(), getnetbyname(), and getnetbyaddr().

getprotoent_r.3
     mtk
        Documents getprotoent_r(), getprotobyname_r(), and
        getprotobynumber_r(), the reentrant equivalents of
        getprotoent(), getprotobyname(), and getprotobynumber().

getrpcent_r.3
     mtk
        Documents getrpcent_r(), getrpcbyname_r(), and
        getrpcbynumber_r(), the reentrant equivalents of
        getrpcent(), getrpcbyname(), and getrpcbynumber().

getservent_r.3
     mtk
        Documents getservent_r(), getservbyname_r(), and
        getservbyport_r(), the reentrant equivalents of
        getservent(), getservbyname(), and getservbyport().

numa.7
    mtk
        A new page giving overview details for the Linux NUMA interfaces.
        Incorporates some material from mbind.2, and the description
        of /proc/PID/numa_maps from proc.5.


Newly documented interfaces in existing pages
---------------------------------------------

crypt.3
    mtk
        Add description of crypt_r().


New and changed links
---------------------

crypt.3
    mtk
        New link to crypt.3.

getnetbyname_r.3
getnetbyaddr_r.3
    mtk
        New links to new getnetent_r.3.

getprotobyname_r.3
getprotobynumber_r.3
    mtk
        New links to new getprotoent_r.3.

getrpcbyname_r.3
getrpcbynumber_r.3
    mtk
        New links to new getrpcent_r.3.

getservbyname_r.3
getservbyport_r.3
    mtk
        New links to new getservent_r.3.

numa_maps.5
    mtk
        Link to new numa(7) page, which incorporates the
        /proc/PID/numa_maps description.
        As part of the numactl() package, the /proc/PID/numa_maps
        documentation was in a numa_maps.5 page; this link
        ensures that "man 5 numa_maps" still works.
        (Eventually, we may want to remove this link.)


Global changes
--------------

get_mempolicy.2
mbind.2
move_pages.2
set_mempolicy.2
    mtk
        Add reference to numa(7) for information on library support.
        Added  a VERSIONS section.
        SEE ALSO: Add numa(7).

faccessat.2
fchmodat.2
fchownat.2
fstatat.2
mkdirat.2
mknodat.2
linkat.2
openat.2
readlinkat.2
renameat.2
symlinkat.2
unlinkat.2
mkfifoat.3
psignal.3
strsignal.3
    mtk
        These interfaces are specified in POSIX.1-2008.


Changes to individual pages
---------------------------

eventfd.2
    Vijay Kumar
        When an eventfd overflows, select() indicates the file as both
        readable and writable (not as having an exceptional condition).

fcntl.2
    mtk
        F_DUPFD_CLOEXEC is specified in POSIX.1-2008.

getrlimit.2
    mtk
        NOTES: Add text mentioning the shell 'ulimit' (or 'limit')
        built-in command for setting resource limits.

gettimeofday.2
    mtk
        CONFORMING TO: POSIX.1-2008 marks gettimeofday() as obsolete.

link.2
    mtk
        Note kernel version where Linux stopped following symbolic
        links in 'oldpath'; see also http://lwn.net/Articles/294667.
        POSIX.1-2008 makes it implementation-dependent whether or not
        'oldpath' is dereferenced if it is a symbolic link.
        Add a reference to linkat(2) for an interface that allows
        precise control of the treatment of symbolic links.

mbind.2
    mtk
        Remove material on library support and numactl; that material
        is now in numactl.7.

mmap.2
    mtk
        Add kernel version numbers for MAP_32BIT.
        Add some details on MAP_32BIT (see http://lwn.net/Articles/294642).

move_pages.2
    mtk
        Added VERSIONS (from kernel 2.6.18) and CONFORMING TO sections.

open.2
    mtk
        O_CLOEXEC is specified in POSIX.1-2008.

socket.2
    mtk
        s/d/domain/ for name of argument.
        Add reference to socket(2) for further information on
        domain, type, and protocol arguments.

utimensat.2
    mtk
        CONFORMING TO: POSIX.1-2008 specifies utimensat() and futimens().

dirfd.3
    mtk
        CONFORMING TO: Add POSIX.1-2008; other minor changes.

exec.3
    mtk
        Small rewording: "s/returned/failed with/ [an error]".

fmemopen.3
    mtk
        Since glibc 2.7, it is possible to seek past the end of
        a stream created by open_memstream().  Add a BUGS section
        describing the bug in earlier glibc versions.

gethostbyname.3
    mtk
        Clarify exactly which functions are obsoleted by getnameinfo()
        and getaddrinfo().

getnetent.3
    mtk
        Rephrase description in terms of a database, rather than a file.
        Note that each of the get*() functions opens a connection to
        the database if necessary.
        The database connection is held open between get*() calls if
        'stayopen' is non-zero (not necessarily 1).
        s/zero terminated list/NULL-terminated list/
    mtk
        In glibc 2.2, the type of the 'net' argument for getnetbyaddr()
        changed from 'long' to 'uint32_t'.
    mtk
        Note that the gethostbyaddr() 'net' argument is in host byte order.
    mtk
        RETURN VALUE: emphasize that returned pointer points to a
        statically allocated structure.
        SEE ALSO: add getnetent_r.3.

getprotoent.3
    mtk
        Rephrase description in terms of a database, rather than a file.
        Note that each of the get*() functions opens a connection to
        the database if necessary.
        The database connection is held open between get*() calls if
        'stayopen' is non-zero (not necessarily 1).
        s/zero terminated list/NULL-terminated list/
    mtk
        RETURN VALUE: emphasize that returned pointer points to a
        statically allocated structure.
        SEE ALSO: add getprotoent_r.3.

getrpcent.3
    mtk
        s/rpc/RPC/.
        Rephrase description in terms of a database, rather than a file.
        Note that each of the get*() functions opens a connection to
        the database if necessary.
        s/zero terminated list/NULL-terminated list/
    mtk
        RETURN VALUE: emphasize that returned pointer points to a
        statically allocated structure.
        SEE ALSO: add getrpcent_r.3.

getservent.3
    mtk
        Rephrase description in terms of a database, rather than a file.
        Note that each of the get*() functions opens a connection to
        the database if necessary.
        The database connection is held open between get*() calls if
        'stayopen' is non-zero (not necessarily 1).
        s/zero terminated list/NULL-terminated list/
    mtk
        RETURN VALUE: emphasize that returned pointer points to a
        statically allocated structure.
        SEE ALSO: add getservent_r.3.

mkdtemp.3
    mtk
        CONFORMING TO: this function is specified in POSIX.1-2008.

mq_notify.3
    Venkatesh Srinivas
        s/sigev_notify_function/sigev_thread_function/
        as per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=494956.

realpath.3
    mtk
        Relocate text for resolved_path==NULL case to DESCRIPTION.
        POSIX.1-2001 leaves the resolved_path==NULL case as
        implementation-defined; POSIX.1-2008 specifies the behavior
        described in this man page.

sem_init.3
    mtk
        POSIX.1-2008 rectifies the POSIX.1-2001 omission, specifying
        that zero is returned by a successful sem_init() call.

core.5
    Mike Bianchi / mtk
        Make the page more helpful to non-programmers by referencing
        the documentation of the shell's 'ulimit' command in the
        discussion of RLIMIT_CORE and RLIMIT_FSIZE.
        SEE ALSO: Add bash(1).
    mtk
        Note that a core dump file can be used in a debugger.

proc.5
    mtk
        Remove /proc/PID/numa_maps material (it is now in numa(7)).

cpuset.7
    mtk
        SEE ALSO: Add numa(7).

inotify.7
    mtk / Li Zefan
         Explain bug that occurred in coalescing identical events in
         kernels before 2.6.25.
         (See commit 1c17d18e3775485bf1e0ce79575eb637a94494a2
         "A potential bug in inotify_user.c" in the 2.6.25 Changelog.)

pthreads.7
    mtk
        Update thread-safe functions list with changes in POSIX.1-2008.
        SEE ALSO: add proc(5).

signal.7
    mtk
        Update list of async-signal-safe functions for POSIX.1-2008.


==================== Changes in man-pages-3.09 ====================

Released: 2008-09-10, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Bernd Eckenfels <be-mail2006@lina.inka.de>
Bruno Haible <bruno@clisp.org>
Carsten Emde <Carsten.Emde@osadl.org>
Christopher Head <chead@telus.net>
H. Peter Anvin <hpa@zytor.com>
Jan Engelhardt <jengelh@medozas.de>
Joe Korty <joe.korty@ccur.com>
Marko Kreen <markokr@gmail.com>
Martin (Joey) Schulze <joey@infodrom.org>
Mats Wichmann <mats.d.wichmann@intel.com>
Michael Schurter <michael@susens-schurter.com>
Mike Bianchi <MBianchi@foveal.com>
Mike Frysinger <vapier@gentoo.org>
Sam Varshavchik <mrsam@courier-mta.com>
Suka <sukadev@us.ibm.com>
Timothy S. Nelson <wayland@wayland.id.au>
Tolga Dalman <tdalman@project-psi.org>
Török Edwin <edwintorok@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

fopencookie.3
    mtk
        Document fopencookie(3), a library function that allows
        custom implementation of a stdio stream.

networks.5
    Martin (Joey) Schulze, with a few light edits by mtk
        Documents the /etc/networks file.


Global changes
--------------

Various pages
    mtk
        s/time zone/timezone/ for consistency across pages and
        with POSIX.1.

kill.2
sigaction.2
sigpending.2
sigprocmask.2
sigsuspend.2
confstr.3
ctermid.3
ctime.3
ferror.3
flockfile.3
fopen.3
getaddrinfo.3
getgrnam.3
getnameinfo.3
getopt.3
getpwnam.3
longjmp.3
popen.3
rand.3
readdir.3
setjmp.3
sigsetops.3
sigwait.3
strtok.3
tzset.3
unlocked_stdio.3
    mtk
        Add/fix feature test macro requirements.


Changes to individual pages
---------------------------

fcntl.2
    mtk, after a note by Mike Bianchi
        More clearly and consistently describe whether
        or not the third argument to fcntl() is required,
        and what its type should be.
    mtk
        Move description of negative l_len  from NOTES, integrating
        it into the discussion of file locking.
        Minor rewrites of the text on file locking.

getrusage.2
    Bernd Eckenfels
        SEE ALSO: Add clock(3), clock_gettime(3).
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=353475

ioctl_list.2
    mtk
        Remove old sentence about where to send updates for this page.
        Add more detail on mount options that prevent updates to atime.

sched_setscheduler.2
    Carsten Emde
        Update kernel version numbers relating to real-time support.

stat.2
    H. Peter Anvin
        Note that lstat() will generally not trigger automounter
        action, whereas stat() will.

clock.3
    Bernd Eckenfels
        SEE ALSO: Add clock_gettime(3).
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=353475

clock_getres.3
    Tolga Dalman / mtk
        Add "Link with -lrt" to SYNOPSIS; remove now redundant
        sentence mentioning librt from NOTES.

getdate.3
    mtk
        Rewrite description of getdate_r() and integrate into main text
        (rather than describing in NOTES).
        Other parts rewritten for greater clarity.
        Make it clearer in the main text that glibc does not implement %Z;
        remove discussion of that point from NOTES.
        Added an example program.

hsearch.3
    mtk
        Noted that table size as specified by 'nel' is immutable.
        Described differences between hsearch() and hsearch_r().
        Added missing pieces to RETURN VALUE.
        Added a number of new entries under ERRORS.
        NOTES: added some basic advice on sizing the hash table;
        noted that when a table is destroyed, the caller is responsible
        for freeing the buffers pointed to by 'key' and 'data' fields.
        One of the BUGS was fixed in glibc 2.3.
        Rewrote and clarified various other pieces.
        Rename arguments for reentrant functions, using same name as
        glibc headers: s/ret/retval/; s/tab/htab/.
    mtk, after a suggestion by Timothy S. Nelson
        Integrate discussion of reentrant functions into main discussion
        (rather than as a short paragraph at the end).

iconv.3
    Bruno Haible
        Describe "shift sequence" input.

ptsname.3
    sukadev
        Fix return type of ptsname_r() in SYNOPSIS.

readdir.3
    H. Peter Anvin
        s/stat(2)/lstat(2)/ when discussing d_type (since we
        are talking about a case where we might be interested to
        whether the file itself is a symbolic link).

sigsetops.3
    Chris Head, signed-off-by: Mike Frysinger
        Fix typo: s/sigdelset/sigorset/

proc.5
    Mats Wichmann / mtk
        s/\[number]/[pid]/ in file names for /proc/PID files.
        And similar changes for task/[tid] sub-directories.
    mtk / Mats Wichmann
        In the description if /proc/[pid]/environ, remove reference to
        lilo(8)/grub(8) since there seems to be nothing in those pages
        that related to this /proc file.
    Michael Schurter / mtk
        Remove sentence wrongly saying that /proc/meminfo reports
        info in bytes;
        see http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=462969
    mtk
        Note that /proc/meminfo reports system-wide memory usage
        statistics.
    Joe Korty
        Document new fields in /proc/interrupts that were added in
        Linux 2.6.24.

unix.7
    Marko Kreen
        Since glibc 2.8, _GNU_SOURCE must be defined in order to get
        the definition of the ucred structure from <sys/socket.h>.


==================== Changes in man-pages-3.10 ====================

Released: 2008-09-23, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

André Goddard Rosa <andre.goddard@gmail.com>
George Spelvin <linux@horizon.com>
Pavel Heimlich <tropikhajma@seznam.cz>
Sam Varshavchik <mrsam@courier-mta.com>
John Reiser <jreiser@bitwagon.com>

Apologies if I missed anyone!


Global changes
--------------

closedir.3
dirfd.3
readdir.3
rewinddir.3
scandir.3
seekdir.3
telldir.3
    mtk
        Fix 'dir' argument name: should be 'dirp'.
        POSIX.1-2008 and glibc call this argument 'dirp' (consistent
        with the fact that it is a *pointer* to a DIR structure).


Changes to individual pages
---------------------------

clone.2
    mtk, after a comment by John Reiser
        Clarify text describing getpid() caching bug for clone() wrapper.
        See also:
        http://sourceware.org/bugzilla/show_bug.cgi?id=6910
        https://bugzilla.redhat.com/show_bug.cgi?id=417521

getpid.2
    mtk, after a comment by John Reiser
        Describe getpid()'s PID caching and its consequences.

timerfd_create.2
    Sam Varshavchik
        s/it_interval/it_value/ when talking about TIMERFD_ABSTIME.

closedir.3
    George Spelvin
        Clarify closedir()'s treatment of underlying file descriptor.

tsearch.3
    André Goddard Rosa
        Fix memory leak in example program.
        Add use of tdestroy to example program.
    mtk
        Add "#define _GNU_SOURCE" to example program.

protocols.5
    mtk, after a note from Pavel Heimlich
        Remove SEE ALSO references to nonexistent Guides to Yellow Pages

services.5
    mtk
        Remove some out-of-date bugs.
    mtk, after a note from Pavel Heimlich
        Remove SEE ALSO references to nonexistent Guides to Yellow Pages
        and Bind/Hesiod docs.
    mtk
        Remove crufty text about use of comma instead of slash to separate
        port and protocol.


==================== Changes in man-pages-3.11 ====================

Released: 2008-10-07, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

André Goddard Rosa <andre.goddard@gmail.com>
Eugene V. Lyubimkin <jackyf.devel@gmail.com>
Gergely Soos <sogerc1@gmail.com>
Kirill A. Shutemov <kirill@shutemov.name>
Marko Kreen <markokr@gmail.com>
Maxin B. John <maxin.john@ap.sony.com>
Maxin John <maxin.john@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Nicolas François <nicolas.francois@centraliens.net>
Pavel Heimlich <tropikhajma@seznam.cz>
Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
Sam Varshavchik <mrsam@courier-mta.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

umount.2
    Michael Kerrisk
        Create a new page for umount() and umount2() by extracting
        existing material from mount.2 page.


New and changed links
---------------------

umount2.2
    Michael Kerrisk
        Change link to point to new umount.2
            The umount2() material migrated from mount.2 to umount.2


Changes to individual pages
---------------------------

execve.2
    Michael Kerrisk
        _SC_ARG_MAX is no longer necessarily constant
            POSIX.1-2001 says that the values returned by sysconf()
            are constant for the life of the process.
            But the fact that, since Linux 2.6.23, ARG_MAX is settable
            via RLIMIT_STACK means _SC_ARG_MAX is no longer constant,
            since it can change at each execve().
    Michael Kerrisk
        Linux now imposes a floor on the ARG_MAX limit
            Starting with Linux 2.6.23, the ARG_MAX limit became
	    settable via (1/4 of) RLIMIT_STACK.  This broke ABI
	    compatibility if RLIMIT_STACK was set such that ARG_MAX
	    was < 32 pages.  Document the fact that since 2.6.25
	    Linux imposes a floor on ARG_MAX, so that the old limit
	    of 32 pages is guaranteed.

            For some background on the changes to ARG_MAX in
	    kernels 2.6.23 and 2.6.25, see:
                http://sourceware.org/bugzilla/show_bug.cgi?id=5786
                http://bugzilla.kernel.org/show_bug.cgi?id=10095
                http://thread.gmane.org/gmane.linux.kernel/646709/focus=648101,
                checked into 2.6.25 as
	        commit a64e715fc74b1a7dcc5944f848acc38b2c4d4ee2.

            Also some reordering/rewording of the discussion of ARG_MAX.

fallocate.2
    Michael Kerrisk
        Note lack of glibc wrapper; caller must use syscall(2)
            Glibc doesn't (and quite probably won't) include a
	    wrapper for this system call.  Therefore, point out that
	    potential callers will need to use syscall(2), and rewrite
	    the RETURN VALUE text to show things as they would be if
	    syscall() is used.

    Michael Kerrisk
        Refer reader to posix_fallocate(3) for portable interface
            Add a para to start of page that points out that this is the
            low-level, Linux-specific API, and point the reader to
	    posix_fallocate(3) for the portable API.

getdents.2
readdir.3
    Michael Kerrisk
        d_type is currently only supported on ext[234]
            As at kernel 2.6.27, only ext[234] support d_type.
            On other file systems, d_type is always set to DT_UNKNOWN (0).

getdents.2
    Michael Kerrisk
        Add an example program
    Michael Kerrisk
        comment out linux_dirent fields with varying location
            The location of the fields after d_name varies according to
            the size of d_name.  We can't properly declare them in C;
            therefore, put those fields inside a comment.
    Michael Kerrisk
        The DT_* constants are defined in <dirent.h>
    Michael Kerrisk
        Remove header files from SYNOPSIS
            None of the header files provides what is needed.
            Calls are made via syscall(2).
    Michael Kerrisk
        The programmer must define the linux_dirent structure
            Point out that this structure is not defined in glibc headers.
    Michael Kerrisk
        s/dirent/linux_dirent/
            The structure isn't currently defined in glibc headers,
	    and the kernel name of the structure is 'linux_dirent' (as
            was already used in some, but not all, places in this page).

getrlimit.2
    Michael Kerrisk
        Reword/relocate discussion of BSD's historical RLIMIT_OFILE
            The old sentence sat on its own in an odd place, and anyway the
            modern BSDs use the name RLIMIT_NOFILE.
    Michael Kerrisk
        Refer to execve(2) for RLIMIT_STACK's effect on ARG_MAX
            Refer the reader to new text in execve(2) that describes how
            (since Linux 2.6.23) RLIMIT_STACK determines the value of ARG_MAX.

getrusage.2
    Michael Kerrisk
        Rusage measures are preserved across execve(2)

mlock.2
    Maxin John
        Add EAGAIN error.

move_pages.2
    Nicolas François
        Make a detail of EPERM error more precise

mount.2
    Michael Kerrisk
        Add description of per-process namespaces
            Describe per-process namespaces, including discussion
            of clone() and unshare CLONE_NEWNS, and /proc/PID/mounts.
    Michael Kerrisk
        List a few other file systems that we may see in /proc/filesystems
            Add some modern file systems to that list (xfs, jfs, ext3,
            reiserfs).
    Michael Kerrisk
        Document MS_SILENT (and MS_VERBOSE)

mount.2
umount.2
    Michael Kerrisk
        Split umount*() out into a separate page
            The length of this page means that it's becoming difficult
	    to parse which info is specific to mount() versus
	    umount()/umount2(), so split the umount material out into
	    its own page.

pause.2
    Michael Kerrisk
        Remove mention of words "library function"
            This really is a system call.

readdir.2
    Michael Kerrisk
        The programmer must declare the old_linux_dirent structure
            Glibc does not provide a definition of this structure.
    Michael Kerrisk
        s/dirent/old_linux_dirent/
            Nowadays, this is the name of the structure in the
	    kernel sources.
    Michael Kerrisk
        Remove words "which may change"
            These words are slightly bogus: although the interface
	    is obsolete, for ABI-compatibility reasons, the kernel folk
	    should never be changing this interface.
    Michael Kerrisk
        Remove header files from SYNOPSIS
            glibc doesn't provide any support for readdir(2),
            so remove these header files (which otherwise suggest
            that glibc does provide the required pieces).

recv.2
    Nicolas François
        Move kernel version number to first mention to MSG_ERRQUEUE.

semop.2
    Kirill A. Shutemov
        Fix typo in example
            (The '&' before sop in the semop() call is unneeded.)

send.2
    Michael Kerrisk
        Make kernel version for MSG_CONFIRM more precise
            s/2.3+ only/Since Linux 2.3.15/

sigaction.2
    Michael Kerrisk
        Refer reader to signal(7) for an overview of signals
        Explain semantics of signal disposition during fork() and execve()
        Refer to signal(7) for more details on signal mask.

sigaltstack.2
    Michael Kerrisk
        Explain inheritance of alternate signal stack across fork(2)

sigwaitinfo.2
    Michael Kerrisk
        Distinguish per-thread and process-wide signals
            A sentence clarifying that pending signal set is union of
            per-thread and process-wide pending signal sets.

    Michael Kerrisk
        These interfaces have per-thread semantics
            The page was previously fuzzy about whether the these interfaces
            have process-wide or per-thread semantics.  (E.g., now the
            page states that the calling *thread* (not process) is suspended
            until the signal is delivered.)

sigpending.2
    Michael Kerrisk
        Explain effect of fork() and execve() for pending signal set
    Michael Kerrisk
        Explain how thread's pending signal set is defined
            The pending set is the union of per-thread pending signals
	    and process-wide pending signals.

sigprocmask.2
    Michael Kerrisk
        Explain effects of fork() and execve() for signal mask

splice.2
    Michael Kerrisk
        Note that SPLICE_F_MOVE is a no-op since kernel 2.6.21

syscall.2
    Michael Kerrisk
        Add more detail about wrapper functions
            Add a few more details about work generally done by wrapper
            functions.  Note that syscall(2) performs the same steps.

tkill.2
    Michael Kerrisk
        EINVAL error can also occur for invalid TGID
            The EINVAL error on an invalid TGID for tgkill() was
            not documented; this change documents it.

utimensat.2
    Michael Kerrisk
        POSIX.1-2008 revision will likely affect FTMs for futimens()
            Make it clear that the POSIX.1 revision that is likely
            to affect the feature test macro requirements for futimens()
            is POSIX.1-2008.
    Nicolas François
        Make various wordings a little more precise.
            The times argument point to *an array of* structures, and the
            man-page should say that consistently.

wait4.2
    Michael Kerrisk
        wait3() is a library function layered on wait4().
            On Linux wait3() is a library function implemented on top
            of wait4().  (Knowing this is useful when using strace(2),
            for example.)

atan2.3
    Nicolas François
        Fix error in description of range or return value
            In recent changes to the man page, mtk accidentally changed
            the description of the return value range to -pi/2..pi/2;
            the correct range is -pi..pi.

cmsg.3
    Nicolas François
        Add parentheses after macro names.

ctime.3
    Michael Kerrisk
        Clarify mktime()'s use of tm_isdst
            Describe use of tm_isdst for input to mktime();
            explain how mktime() modifies this field.
            (This field is left unchanged in case of error.)

            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=500178
    Michael Kerrisk
        Clarify wording for ctime_r() and asctime_r() to indicate that
        the buffer must be at least 26 *bytes*.
    Michael Kerrisk
        Minor rewording of mktime() description.

floor.3
    Nicolas François
        floor.3: Fix error in description: s/smallest/largest/

hsearch.3
    André Goddard Rosa
        Call hdestroy() after using hash table created by hcreate(),
	for the sake of completeness

mq_getattr.3
    Michael Kerrisk
        mq_getattr() and mq_setattr() are layered on mq_getsetattr(2)
            mq_getattr() and mq_setattr() are library functions layered on
            top of the mq_getsetattr(2) system call.
            (This is useful info for users of strace(1).)

mq_receive.3
    Michael Kerrisk
        mq_send() is a library function layered on mq_timedreceive() syscall
             This info is useful for users of strace(1).

mq_send.3
    Michael Kerrisk
        mq_send() is a library function layered on mq_timedsend() syscall
             This info is useful for users of strace(1).

nextafter.3
    Nicolas François
        Make description more precise: s/next/largest/

readdir.3
    Michael Kerrisk
        SEE ALSO: add getdents(2)
             Because readdir() is implemented on top of getdents(2).

realpath.3
    Michael Kerrisk
        Clarify that returned pathname is NULL terminated
            Also clarify that null-byte is included in PATH_MAX limit.

proc.5
    Michael Kerrisk
        Rewrite and simplify description of /proc/mounts
            Most of the relevant discussion is now under /proc/PID/mounts;
            all that needs to be here is a mention of the pre-2.4.19
            system-wide namespace situation, and a reference to the
            discussion under /proc/PID/mounts.
    Michael Kerrisk
        Add description of /proc/PID/mounts
            Largely cribbed from existing /proc/mounts discussion, which is
            about to be rewritten.

mq_overview.7
    Michael Kerrisk
        Add mq_notify() to list of lib. functions and syscalls in MQ API

signal.7
    Michael Kerrisk
        Improve description in NAME section
        Add mention of sigaltstack(2).
        Describe syscalls that synchronously wait for a signal,
        Give overview of syscalls that block until a signal is caught
        Add overview of interfaces for sending signals.

    Michael Kerrisk
        Describe semantics w.r.t. fork() and execve()
            Include text describing semantics of fork() and execve() for
            signal dispositions, signal mask, and pending signal set.


==================== Changes in man-pages-3.12 ====================

Released: 2008-10-29, Bucaramanga


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Bert Wesarg <bert.wesarg@googlemail.com>
Christian Grigis <glove@earthling.net>
Christoph Hellwig <hch@infradead.org>
Didier <did447@gmail.com>
Halesh S <halesh.s@india.com>
J.H.M. Dassen (Ray) <fsmla@xinara.org>
Jason Spiro <jasonspiro4@gmail.com>
Lefteris Dimitroulakis <edimitro@tee.gr>
Michael B. Trausch <mike@trausch.us>
Pierre Cazenave <pwc101@noc.soton.ac.uk>
Stefan Puiu <stefan.puiu@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

pthread_attr_init.3
    Michael Kerrisk
        New page for pthread_attr_init(3) and pthread_attr_destroy(3)

pthread_attr_setdetachstate.3
    Michael Kerrisk
        New page for pthread_attr_setdetachstate(3) and
        pthread_attr_getdetachstate(3)

pthread_attr_setguardsize.3
    Michael Kerrisk
        New page for pthread_attr_setguardsize(3) and
        pthread_attr_getguardsize(3)

pthread_attr_setscope.3
    Michael Kerrisk
        New page for pthread_attr_setscope(3) and pthread_attr_getscope(3)

pthread_attr_setstack.3
    Michael Kerrisk
        New page for pthread_attr_setstack(3) and pthread_attr_getstack(3)

pthread_attr_setstackaddr.3
    Michael Kerrisk
        New page for pthread_attr_setstackaddr(3) and
        pthread_attr_getstackaddr(3)

pthread_attr_setstacksize.3
    Michael Kerrisk
        New page for pthread_attr_setstacksize(3) and
        pthread_attr_getstacksize(3)

pthread_create.3
    Michael Kerrisk
        New page describing pthread_create(3)

pthread_detach.3
    Michael Kerrisk
        New page for pthread_detach(3)

pthread_equal.3
    Michael Kerrisk
        New page for pthread_equal(3)

pthread_exit.3
    Michael Kerrisk
        New page describing pthread_exit(3)

pthread_getattr_np.3
    Michael Kerrisk
        New page for pthread_getattr_np(3)

pthread_join.3
    Michael Kerrisk
        New page for pthread_join(3)

pthread_self.3
    Michael Kerrisk
        New page for pthread_self(3)

pthread_tryjoin_np.3
    Michael Kerrisk
        New page for pthread_tryjoin_np(3) and pthread_timedjoin_np(3)


Newly documented interfaces in existing pages
---------------------------------------------

dup.2
    Michael Kerrisk
        Add description of dup3()
            dup3() was added in kernel 2.6.27.

epoll_create.2
    Michael Kerrisk
        Add description of new epoll_create1()
            The new epoll_create1() system call appeared in Linux 2.6.27.

eventfd.2
    Michael Kerrisk
        Describe eventfd2() and EFD_NONBLOCK and EFD_CLOEXEC
            Linux 2.6.27 added eventfd(), which supports a flags argument
            that eventfd() did not provide.  The flags so far implemented
            are EFD_NONBLOCK and EFD_CLOEXEC,

inotify_init.2
    Michael Kerrisk
        Add description of inotify_init1()
            The inotify_init1() system call was added in Linux 2.6.27.

pipe.2
    Michael Kerrisk
        Add description of new pipe2() syscall
            pipe2() was added in 2.6.27.  Describe the O_NONBLOCK and
            O_CLOEXEC flags.

signalfd.2
    Michael Kerrisk
        Describe signalfd4() and SFD_NONBLOCK and SFD_CLOEXEC
            Linux 2.6.27 added signalfd4(), which supports a flags argument
            that signalfd() did not provide.  The flags so far implemented
            are SFD_NONBLOCK and SFD_CLOEXEC.


New and changed links
---------------------

dup3.2
    Michael Kerrisk
        New link to dup.2
            dup.2 now contains the description of the new dup3() syscall.

epoll_create1.2
    Michael Kerrisk
        New link to epoll_create.2
            epoll_create.2 now includes a description of the new
            epoll_create1() system call.

eventfd2.2
    Michael Kerrisk
        New link to eventfd.2
            The eventfd.2 page has some details on the eventfd2() system call,
            which was new in Linux 2.6.27.

inotify_init1.2
    Michael Kerrisk
        New link to inotify_init.2
            inotify_init.2 now includes a description of the new
            inotify_init1() system call.

pipe2.2
    Michael Kerrisk
        New link to pipe.2
            pipe(2) now contains a description of the new pipe2() syscall.

pthread_attr_destroy.3
    Michael Kerrisk
        New link to new pthread_attr_init.3

pthread_attr_getdetachstate.3
    Michael Kerrisk
        New link to new pthread_attr_setdetachstate.3

pthread_attr_getguardsize.3
    Michael Kerrisk
        New link to new pthread_attr_setguardsize.3

pthread_attr_getscope.3
    Michael Kerrisk
        New link to new pthread_attr_setscope.3

pthread_attr_getstack.3
    Michael Kerrisk
        New link to new pthread_attr_setstack.3

pthread_attr_getstackaddr.3
    Michael Kerrisk
        New link to new pthread_attr_setstackaddr.3

pthread_attr_getstacksize.3
    Michael Kerrisk
        New link to new pthread_attr_setstacksize.3

pthread_timedjoin_np.3
    Michael Kerrisk
        New link to new pthread_tryjoin_np.3

signalfd4.2
    Michael Kerrisk
        New link to signalfd.2
            signalfd.2 now includes text describing signalfd4() system call,
            new in Linux 2.6.27.


Global changes
--------------

eventfd.2, getdents.2, mprotect.2, signalfd.2, timerfd_create.2,
wait.2, backtrace.3, clock_getcpuclockid.3, end.3, fmemopen.3,
fopencookie.3, getdate.3, getgrouplist.3, getprotoent_r.3,
getservent_r.3, gnu_get_libc_version.3, inet.3, inet_pton.3,
makecontext.3, matherr.3, offsetof.3, pthread_attr_init.3,
pthread_create.3, pthread_getattr_np.3, sem_wait.3, strtol.3, core.5
    Michael Kerrisk
        Add ".SS Program source" to EXAMPLE
            Add ".SS Program source" to clearly distinguish shell session and
            descriptive text from actual program code.

eventfd.2, execve.2, getdents.2, ioprio_set.2, mprotect.2,
signalfd.2, timerfd_create.2, wait.2, backtrace.3,
clock_getcpuclockid.3, end.3, fmemopen.3, fopencookie.3, frexp.3,
getdate.3, getgrouplist.3, getprotoent_r.3, getservent_r.3,
gnu_get_libc_version.3, inet.3, inet_pton.3, makecontext.3,
malloc.3, matherr.3, offsetof.3, pthread_attr_init.3,
pthread_create.3, pthread_getattr_np.3, sem_wait.3, strftime.3,
strtok.3, strtol.3, core.5, proc.5, cpuset.7, mq_overview.7
    Michael Kerrisk
        Format user input in shell sessions in boldface

frexp.3, strftime.3, strtok.3
    Michael Kerrisk
        Relocate shell session above example program
            Move the shell session text that demonstrates the use of
            the example program so that it precedes the actual
            example program.  This makes the page consistent with the
            majority of other pages.


Changes to individual pages
---------------------------

epoll_create.2
    Michael Kerrisk
        Say more about unused epoll_create() 'size' arg
            Supply a little more explanation about why the 'size' argument
            of epoll_create() is nowadays ignored.

eventfd.2
    Michael Kerrisk
        Remove crufty text relating to flags argument
            Remove sentence saying that glibc adds a flags argument
            to the syscall; that was only relevant for the older
            eventfd() system call.
getdents.2
    Christoph Hellwig
        Fix text relating to DT_UNKNOWN and 'd_type' support
            Some file systems provide partial support for 'dt_type',
            returning DT_UNKNOWN for cases they don't support.
            Update the discussion of 'd_type' and DT_UNKNOWN to
            support this.

getpeername.2, getsockname.2
    Michael Kerrisk
        SEE ALSO: add ip(7) and unix(7)

getsockopt.2
    Michael Kerrisk
        EINVAL can also occur if 'optval' is invalid
            In some cases, EINVAL can occur if 'optval' is invalid.
            Note this, and point reader to an example in ip(7).
            In response to:
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=216092

inotify_init.2
pipe.2
timerfd_create.2
    Michael Kerrisk
        Clarify *_NONBLOCK description
            Make it clear that the NONBLOCK flag sets an attribute in the new
            open file description.

sched_yield.2
    Michael Kerrisk
        Rewrite description in terms of threads
            The text formerly described the operation of sched_yield() in
            terms of processes.  It should be in terms of threads.
    Michael Kerrisk
        Add NOTES text on appropriate use of sched_yield()
            Strategic calls to sched_yield() can be used to improve
            performance, but unnecessary use should be avoided.

sigaction.2
    Michael Kerrisk
        Clarify that sa_mask affects the *per-thread* signal mask
            The page didn't previously clearly explain the scope of the
            signal mask that is affected by sa_mask.

signalfd.2
    Michael Kerrisk
        Remove crufty text relating to flags argument
            Remove sentence saying that glibc adds a flags argument
            to the syscall; that was only relevant for the older
            signalfd() system call.

sigprocmask.2
    Michael Kerrisk
        Clarify that sigprocmask() operates on a per-thread mask
            The first sentence of the page was vague on the scope of the
            attribute changed by sigprocmask().  Reword to make this
            clearer and add a sentence in NOTES to explicitly state that
            the signal mask is a per-thread attribute.

socket.2
    Michael Kerrisk
        Document SOCK_NONBLOCK and SOCK_CLOEXEC flags
            These flags, specified in the 'type' argument, are supported
            since Linux 2.6.27.

socketpair.2
    Michael Kerrisk
        Refer to socket(2) for SOCK_CLOEXEC and SOCK_NONBLOCK
            Refer the reader to socket(2) for a description of the SOCK_CLOEXEC
            and SOCK_NONBLOCK flags, which are supported by socketpair() since
            Linux 2.6.27.

syscalls.2
    Michael Kerrisk
        Add new 2.6.27 system calls
            Add pipe2(), dup3(), epoll_create1(), inotify_init1(),
            eventfd2(), signalfd4().

timerfd_create.2
    Michael Kerrisk
        Document timerfd_create() TFD_CLOEXEC and TFD_NONBLOCK
            TFD_CLOEXEC and TFD_NONBLOCK are supported since LInux 2.6.27.

vfork.2
    Michael Kerrisk
        Clarify meaning of "child releases the parent's memory"
            The man page was not explicit about how the memory used by
            the child is released back to the parent.

ctime.3
    Michael Kerrisk
        ctime_r() and localtime_r() need not set 'timezone' and 'daylight'
            The man page already noted that these functions need not set
            'tzname', but things could be clearer: it tzset() is not called,
            then the other two variables also are not set.

            Also, clarify that ctime() does set 'timezone' and 'daylight'.

dlopen.3
    Michael Kerrisk
        LD_LIBRARY_PATH is inspected once, at program start-up
            Make it clear that LD_LIBRARY_PATH is inspected *once*, at
            program start-up.  (Verified from source and by experiment.)

fmemopen.3
    Michael Kerrisk
        Document binary mode (mode 'b')
            Glibc 2.9 adds support to fmemopen() for binary mode opens.
            Binary mode is specified by inclusion of the letter 'b' in
            the 'mode' argument.

getaddrinfo.3
    Michael Kerrisk
        Clarify error descriptions with some examples
            Clarify the description of some errors by giving examples
            that produce the errors.  (Text added for EAI_SERVICE and
            EAI_SOCKTYPE.)

            Also, add an error case for EAI_BADFLAGS.

gethostbyname.3
    Michael Kerrisk
        Rationalize text on POSIX.1-2001 obsolete interfaces
            POSIX.1 marks gethostbyname(), gethostbyaddr(), and 'h_errno'
            as obsolete.  The man page explained this, but with some
            duplication.  Remove the duplication, and otherwise tidy up
            discussion of this point.

popen.3
    Michael Kerrisk
        Change one-line description in NAME
            s%process I/O%pipe stream to or from a process%
    Michael Kerrisk
        Document 'e' (close-on-exec) flag
            glibc 2.9 implements the 'e' flag in 'type', which sets the
            close-on-exec flag on the underlying file descriptor.

raise.3
    Michael Kerrisk
        SEE ALSO: add pthread_kill(3)

readdir.3
    Christoph Hellwig
        Fix text relating to DT_UNKNOWN and 'd_type' support
            (This mirrors the previous change to getdents.2)
            Some file systems provide partial support for 'dt_type',
            returning DT_UNKNOWN for cases they don't support.
            Update the discussion of 'd_type' and DT_UNKNOWN to
            support this.

strcpy.3
    Jason Spiro
        Strengthen warning about checking against buffer overruns
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=413940

tty_ioctl.4
    Michael Kerrisk
        Explain capability requirements for TIOCCONS
            Explain capability requirements for TIOCCONS, and describe
            changes in 2.6.10 relating to capabilities.
    Michael Kerrisk
        Explain capability requirements for various ioctls
            For TIOCSLCKTRMIOS, TIOCSCTTY, TIOCEXCL, explain the exact
            capability that is required (the text formerly just said "root"
            in each case).

proc.5
    Michael Kerrisk
        Document /proc/sys/kernel/threads-max
            Defines the system-wide limit on the number of threads (tasks).

utmp.5
    Pierre Cazenave
        It is just "other" who should not have write perms on utmp
            The page was vague before, saying that utmp should not be
            writable by any user.  This isn't true: it can be, and
            typically is, writable by user and group.

epoll.7
    Michael Kerrisk
        Mention epoll_create1() as part of epoll API
            epoll_create1() was added in Linux 2.6.27, and extends the
            functionality of epoll_create().

inotify.7
    Michael Kerrisk
        Mention inotify_init1() in overview of API
            Discuss the new inotify_init1() system call in the overview of
            the inotify API.

ip.7
    Michael Kerrisk
        Detail EINVAL error for IP_ADD_MEMBERSHIP socket option
            In response to:
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=216092

iso_8859-7.7
    Lefteris Dimitroulakis
        Add Drachma, Euro, and Greek Ypogegrammeni
            Also, amend description of characters 0241 and 0242.

man-pages.7
    Michael Kerrisk
        Example shell sessions should have user input boldfaced

pthreads.7
    Michael Kerrisk
        Describe return value from pthreads functions
            Describe the usual success (0) and failure (non-zero) returns,
            and note that POSIX.1-2001 specifies that pthreads functions
            can never fail with the error EINTR.

signal.7
    Michael Kerrisk
        Timeouts make socket interfaces non-restartable
            If setsockopt() is used to set a timeout on a socket(),
            then the various socket interfaces are not automatically
            restarted, even if SA_RESTART is specified when
            establishing the signal handler.  Analogous behavior occurs
            for the "stop signals" case.

socket.7
    Michael Kerrisk
        SEE ALSO: add unix(7)

ld.so.8
    Michael Kerrisk
        Document LD_USE_LOAD_BIAS
            Drawing heavily on Jakub Jelinek's description in
            http://sources.redhat.com/ml/libc-hacker/2003-11/msg00127.html
            (Subject: [PATCH] Support LD_USE_LOAD_BIAS)
        --inhibit-rpath is ignored for setuid/setgid ld.so
            The --inhibit-rpath option is ignored if ld.so is setuid/setgid
            (not if the executable is setuid/setgid).
    Michael Kerrisk
        Since glibc 2.4, setuid/setgid programs ignore LD_ORIGIN_PATH
    Michael Kerrisk
        Fix description of LD_PROFILE and LD_PROFILE_OUTPUT
            Clarify that LD_PROFILE is pathname or a soname,
            and identify name of profiling output file.
            Fix description of LD_PROFILE_OUTPUT, which wasn't even close to
            the truth.  (But why did it remain unfixed for so many years?)
    Michael Kerrisk
        Since glibc 2.3.4, setuid/setgid programs ignore LD_DYNAMIC_WEAK
    Michael Kerrisk
        Since version 2.3.5, setuid/setgid programs ignore LD_SHOW_AUXV
    Michael Kerrisk
        Reorder lists of LD_* environment variables alphabetically
    Michael Kerrisk
        Since glibc 2.3.4, setuid/setgid programs ignore LD_DEBUG


==================== Changes in man-pages-3.13 ====================

Released: 2008-11-07, Bucaramanga


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Bert Wesarg <bert.wesarg@googlemail.com>
Karsten Weiss <knweiss@gmail.com>
Lefteris Dimitroulakis <edimitro@tee.gr>
Olaf van der Spek <olafvdspek@gmail.com>
Sam Varshavchik <mrsam@courier-mta.com>
Török Edwin <edwintorok@gmail.com>
Ulrich Mueller <ulm@gentoo.org>
Valdis Kletnieks <Valdis.Kletnieks@vt.edu>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

pthread_attr_setaffinity_np.3
    Michael Kerrisk
        New page for pthread_attr_setaffinity_np(3) and
        pthread_attr_getaffinity_np(3)

pthread_attr_setschedparam.3
    Michael Kerrisk
        New page for pthread_attr_setschedparam(3) and
        pthread_attr_getschedparam(3)

pthread_attr_setschedpolicy.3
    Michael Kerrisk
        New page for pthread_attr_setschedpolicy(3) and
        pthread_attr_getschedpolicy(3)

pthread_setaffinity_np.3
    Michael Kerrisk
        New page for pthread_setaffinity_np(3) and pthread_getaffinity_np(3)

pthread_setschedparam.3
    Michael Kerrisk
        New page for pthread_setschedparam(3) and pthread_getschedparam(3)

pthread_setschedprio.3
    Michael Kerrisk
        New page for pthread_setschedprio(3)


New and changed links
---------------------

pthread_attr_getaffinity_np.3
    Michael Kerrisk
        New link to new pthread_attr_setaffinity_np.3

pthread_attr_getschedparam.3
    Michael Kerrisk
        New link to new pthread_attr_setschedparam.3

pthread_attr_getschedpolicy.3
    Michael Kerrisk
        New link to new pthread_attr_setschedpolicy.3

pthread_getaffinity_np.3
    Michael Kerrisk
        New link to new pthread_setaffinity_np.3

pthread_getschedparam.3
    Michael Kerrisk
        New link to new pthread_setschedparam.3


Global changes
--------------

pthread_attr_setaffinity_np.3
pthread_getattr_np.3
pthread_setaffinity_np.3
pthread_tryjoin_np.3
    Michael Kerrisk
        Explain _np suffix
            Add text to CONFORMING TO explaining that the "_np"
            suffix is because these functions are non-portable.


Changes to individual pages
---------------------------

sched_setaffinity.2
    Michael Kerrisk
        SEE ALSO: add sched_getcpu(3)

sched_setaffinity.2
    Michael Kerrisk
        SEE ALSO: Add pthread_setaffinity_np(3)

sched_setaffinity.2
    Michael Kerrisk
        Clarify EINVAL error for cpusetsize < kernel mask size
            For sched_setaffinity(), the EINVAL error that occurs
            if 'cpusetsize' is smaller than the kernel CPU set size only
            occurs with kernels before 2.6.9.

vfork.2
    Michael Kerrisk
        Child holds parent's memory until execve() or *termination*
            The page was phrased in a few places to describe the child as
            holding the parent's memory until the child does an execve(2)
            or an _exit(2).  The latter case should really be the more
            general process termination (i.e., either _exit(2) or abnormal
            termination).

clock_getres.3
    Michael Kerrisk
        CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID not settable
            According to POSIX.1-2001, the CLOCK_PROCESS_CPUTIME_ID and
            CLOCK_THREAD_CPUTIME_ID clocks should be settable, but
            currently they are not.

pthread_attr_setstacksize.3
    Michael Kerrisk, after a report by Karsten Weiss
        EINVAL occurs on some systems if stacksize != page-size
            On MacOS X at least, pthread_attr_setstacksize(3) can fail
            with EINVAL if 'stacksize' is not a multiple of the system
            page size.  Best to mention this so as to aid people writing
            portable programs.

pthread_create.3
    Karsten Weiss
        Fix bug in EXAMPLE program
            The calloc() line should read like this instead:

                tinfo = calloc(num_threads, sizeof(struct thread_info));

pthread_exit.3
    Michael Kerrisk
        BUGS: thread group with a dead leader and stop signals
            Document the bug that can occur when a stop signal
            is sent to a thread group whose leader has terminated.
            http://thread.gmane.org/gmane.linux.kernel/611611
            http://marc.info/?l=linux-kernel&m=122525468300823&w=2

resolver.3
    Michael Kerrisk
        Fix prototype of dn_expand()
            The 4th argument is "char *", not "unsigned char *".
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=504708

epoll.7
    Michael Kerrisk
        Fix error handling after accept() in example code
            Simply continuing after an error is in most cases wrong,
            and can lead to infinite loops (e.g., for EMFILE).
            So handle an error by terminating.
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=504202

epoll.7
    Michael Kerrisk
        Add error handling for epoll_wait() call in example code

epoll.7
    Michael Kerrisk
        Improve example code
            Fill in some gaps in example code (variable declarations,
            adding listening socket to epoll set).
            Give variables more meaningful names.
            Other minor changes.
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=504202

iso_8859-7.7
    Lefteris Dimitroulakis
        Add characters for Drachma and Greek Ypogegrammeni
            Lines for these two characters were added in the previous patch,
            but the actual characters were not included in the 4th column
            of the table.  This fixes that.

pthreads.7
    Michael Kerrisk
        Add a section describing thread IDs
            In particular, note that in each pthreads function that takes
            a thread ID argument, that ID by definition refers to a thread
            in the same process as the caller.


==================== Changes in man-pages-3.14 ====================

Released: 2008-11-25, Bucaramanga


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andreas Henriksson <andreas@fatal.se>
Bert Wesarg <bert.wesarg@googlemail.com>
Cedric Le Goater <clg@fr.ibm.com>
Chris Heath <chris@heathens.co.nz>
Eric Biederman <ebiederm@xmission.com>
Eugen Dedu <Eugen.Dedu@pu-pm.univ-fcomte.fr>
Ivana Varekova <varekova@redhat.com>
Jen Axboe <jens.axboe@oracle.com>
Jens Axboe <jens.axboe@oracle.com>
Loïc Domaigne <tech@domaigne.com>
Masanari Iida <masanari.iida@hp.com>
Paul Evans <leonerd@leonerd.org.uk>
Pavel Emelyanov <xemul@openvz.org>
Pierre-Paul Paquin <pierrepaulpaquin@gmail.com>
Serge E. Hallyn <serge@hallyn.com>
Stefano Teso <teso@disi.unitn.it>
Stew Benedict <stewb@linux-foundation.org>
Vegard Nossum <vegard.nossum@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

CPU_SET.3
    Michael Kerrisk
        New page documenting CPU_* macros
            This page contains material moved out of sched_setscheduler(2).
            It overwrites a previously existing link file with the same name.
    Michael Kerrisk
        Add description of macros for dynamically allocated CPU sets
            Add descriptions of CPU_ALLOC(), CPU_ALLOC_SIZE(), CPU_FREE(),
            CPU_SET_S(), CPU_CLR_S(), CPU_ISSET_S(), CPU_ZERO_S(),
            CPU_COUNT_S(), CPU_AND_S(), CPU_OR_S(), CPU_XOR_S(), and
            CPU_EQUAL_S().
    Michael Kerrisk
        Add documentation of CPU_COUNT()
    Michael Kerrisk
        Add description of CPU_AND(), CPU_OR, CPU_XOR(), and CPU_EQUAL()
            Plus a few other small clean-ups of the text
    Michael Kerrisk
        Various improvements in DESCRIPTION
            After review comments by Bert Wesarg:
            * Explain that cpu_set_t is a bitset, but should be considered
              opaque.
            * A CPU set can be duplicated with memset().
            * Size of a CPU set is rounded up to size of long.
            * CPU_SETSIZE is in bits, but the setsize argument is in bytes.
    Michael Kerrisk
        Document CPU_ALLOC()/CPU_ALLOC_SIZE() bug
            These macros return twice what they should because of thinko
            in glibc 2.8 and earlier.  The bug is fixed for glibc 2.9.
            http://sourceware.org/bugzilla/show_bug.cgi?id=7029
    Michael Kerrisk
        NOTES: Discuss use of types in "prototypes" for these macros
            The SYNOPSIS shows types for arguments and return values, but
            these are really just suggestions: since the interfaces are
            macros, the compiler won't catch all violations of
            the "type rules".  Warn the reader of this.

pthread_attr_setinheritsched.3
    Michael Kerrisk
        New page for pthread_attr_setinheritsched(3) and
        pthread_attr_getinheritsched(3)

pthread_cancel.3
    Michael Kerrisk
        New page for pthread_cancel(3)

pthread_cleanup_push.3
    Michael Kerrisk
        New page for pthread_cleanup_push(3) and pthread_cleanup_pop(3)

pthread_setcancelstate.3
    Michael Kerrisk
        New page for pthread_setcancelstate(3) and pthread_setcanceltype(3)

pthread_testcancel.3
    Michael Kerrisk
        New page for pthread_testcancel(3)


Newly documented interfaces in existing pages
---------------------------------------------

clone.2
    Jens Axboe
        Document CLONE_IO (new in Linux 2.6.25)
            Some text also by mtk.
    Michael Kerrisk
        Document CLONE_NEWNET
    Michael Kerrisk
        Document CLONE_NEWUTS (new in Linux 2.6.19)
    Michael Kerrisk
        Document CLONE_NEWIPC flag (new in Linux 2.6.19)
    Michael Kerrisk
        Document CLONE_NEWPID flag (new in Linux 2.6.24)

mmap.2
    Michael Kerrisk
        Document MAP_STACK flag (new in Linux 2.6.27)

arp.7
    Michael Kerrisk
        Document /proc file retrans_time_ms (new in Linux 2.6.12)
    Michael Kerrisk
        Document /proc file base_reachable_time_ms (new in Linux 2.6.12)

icmp.7
    Michael Kerrisk
        Document icmp_ignore_bogus_error_responses (new in Linux 2.2)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document icmp_ratelimit and icmp_ratemask (new in Linux 2.4.10)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document icmp_echo_ignore_broadcasts (new in Linux 2.6.12)
            Text taken from Documentation/networking/ip-sysctl.txt

tcp.7
    Michael Kerrisk
        Document /proc file tcp_slow_start_after_idle (new in Linux 2.6.18)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_base_mss (new in Linux 2.6.17)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_frto_response (new in Linux 2.6.22)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_moderate_rcvbuf (new in Linux 2.4.17/2.6.7)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_congestion_control (new in Linux 2.4.13)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_no_metrics_save (new in Linux 2.6.6)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_mtu_probing (new in Linux 2.6.17)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_dma_copybreak (new in Linux 2.6.24)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_tso_win_divisor (new in Linux 2.6.9)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_allowed_congestion_control (new in Linux 2.4.20)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_workaround_signed_windows (new in Linux 2.6.26)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_available_congestion_control (new in Linux 2.4.20)
            Text taken from Documentation/networking/ip-sysctl.txt
    Michael Kerrisk
        Document /proc file tcp_abc (new in Linux 2.6.15)
            Text taken from Documentation/networking/ip-sysctl.txt

udp.7
    Michael Kerrisk
        Document /proc files udp_mem, udp_rmem_min, and udp_wmem_min
            All of these are new in Linux 2.6.25


New and changed links
---------------------

CPU_ALLOC.3
CPU_ALLOC_SIZE.3
CPU_AND.3
CPU_AND_S.3
CPU_CLR_S.3
CPU_COUNT.3
CPU_COUNT_S.3
CPU_EQUAL.3
CPU_EQUAL_S.3
CPU_FREE.3
CPU_ISSET_S.3
CPU_OR.3
CPU_OR_S.3
CPU_SET_S.3
CPU_XOR.3
CPU_XOR_S.3
CPU_ZERO_S.3
    Michael Kerrisk
        New link to new CPU_SET.3

CPU_CLR.3
CPU_ISSET.3
CPU_ZERO.3
    Michael Kerrisk
        Update links to point to CPU_SET.3
            The documentation of the CPU_* macros migrated to a new
            location: CPU_SET.3.

pthread_attr_getinheritsched.3
    Michael Kerrisk
        New link to new pthread_attr_setinheritsched.3

pthread_cleanup_pop.3
    Michael Kerrisk
        New link to new pthread_cleanup_push.3

pthread_setcanceltype.3
    Michael Kerrisk
        New link to new pthread_setcancelstate.3


Global changes
--------------

clone.2
mount.2
unshare.2
proc.5
path_resolution.7
    Michael Kerrisk
        Global fix: s/namespace/mount-point namespace/, as appropriate
            In recent times, a number of other namespace flags have been
            added to clone(2).  As such, it is no longer clear to use
            the generic term "namespace" to refer to the particular
            namespace controlled by CLONE_NEWNS; instead, use the
            term "mount-point namespace".
    Michael Kerrisk
        Global fix: s/mount-point namespace/mount namespace/
            This is more consistent with the term "mounts namespace"
            used in the 2008 ACM SIGOPS paper, "Virtual servers
            and checkpoint/restart in mainstream Linux".
            (I avoided the "s", because using the plural strikes me
            as klunky English, and anyway we don't talk about
            the "PIDs namespace" or the "networks namespace", etc..)

connect.2
listen.2
send.2
uname.2
cmsg.3
proc.5
arp.7
ddp.7
icmp.7
ip.7
raw.7
socket.7
tcp.7
udp.7
    Michael Kerrisk
        Global fix: eliminate mention of the obsolete sysctl(2) interface
            Many pages still mention use of the obsolete sysctl(2) system
            call, or used the term "sysctls"; rewrite these mentions to
            instead be in terms of /proc interfaces.

fcntl.2
signal.2
mbsnrtowcs.3
mbsrtowcs.3
mbtowc.3
wcrtomb.3
wcsnrtombs.3
wcsrtombs.3
wctomb.3
    Michael Kerrisk
        Global fix: s/multi-thread/multithread/

getdents.2
pthread_attr_init.3
pthread_create.3
pthread_getattr_np.3
pthread_setaffinity_np.3
pthread_setschedparam.3
pthread_tryjoin_np.3
    Michael Kerrisk
        Use consistent error-handling function names
            Many older pages use a handle_error() macro to do simple
            error handling from system and library function calls.
            Switch these pages to do similar.


Changes to individual pages
---------------------------

time.1
    Michael Kerrisk
        Note that some shells have a 'time' built-in command
            Therefore, to access the functionality described on this page,
            it may be necessary to specify the full pathname.

clone.2
    Michael Kerrisk
        Place list of CLONE_* flags in alphabetical order
            (No content changes.)
fsync.2
    Michael Kerrisk
        Update feature test macro requirements for fsync()
            Since glibc 2.8, the fsync() declaration is also exposed if
            _POSIX_C_SOURCE >= 200112L

sched_setaffinity.2
    Michael Kerrisk
        Add note on system-imposed restrictions on CPUs actually used
            After Loïc Domaigne's suggestion for pthread_setaffinity_np(3), add
            similar text to this page noting that the system silently
            limits the set of CPUs on which the process actually runs to
            the set of CPUs physically present and the limits imposed by
            cpuset(7).

sched_setaffinity.2
    Michael Kerrisk
        Removed discussion of CPU_* macros()
            These macros are now moving to a separate page.
    Michael Kerrisk
        Refer reader to pthread_setaffinity_np(3)
            pthread_setaffinity_np() is preferable for setting
            thread CPU affinity if using the POSIX threads API.

sysctl.2
    Michael Kerrisk
        Add prominent warning against using this system call
            This was already stated under NOTES, but make it even more
            prominent by adding a sentence at the start of the DESCRIPTION.

uname.2
    Michael Kerrisk
        Add C comments describing fields in utsname structure

atan2.3
    Stefano Teso
        Fix description of range of function value return
            The range is not [-pi/2, pi/2], but [-pi, pi].

            (mtk: This error was reported by Nicolas François, and
            should have been fixed in 3.11, but somewhere along the way,
            the fix got lost.)

            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=506299

bindresvport.3
    Michael Kerrisk
        Since glibc 2.8, EPFNOSUPPORT error is now EAFNOSUPPORT
            Glibc switched to using a POSIX-specified error code for
            this error case.

            http://bugs.linuxbase.org/show_bug.cgi?id=2375

clock_getres.3
    Michael Kerrisk
        CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID not settable
            According to POSIX.1-2001, the CLOCK_PROCESS_CPUTIME_ID and
            CLOCK_THREAD_CPUTIME_ID clocks should be settable, but
            currently they are not.

getgrnam.3
    Michael Kerrisk
        Clarify and add more detail in RETURN VALUE description
            The page was a bit fuzzy in describing the return values for
            various cases.  In particular, it needed to be more explicit
            in describing what happens for the "not found" case.

            This is an analogous change to the change for
            getpwnam.3, made after Andreas Henriksson's report.
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=504787
    Michael Kerrisk
        Rename arguments to getgrnam_r() and getgrgid_r()
            s/gbuf/grp/ and s/gbufp/result/, for consistency
            with POSIX.1 argument names.
    Michael Kerrisk
        Clarify RETURN VALUE description
            The page was a bit fuzzy in describing the return values for
            various cases.  In particular, it needed to be more explicit
            in describing what happens for the "not found" case.

            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=504708

getpwnam.3
    Michael Kerrisk
        Rename arguments to getpwnam_r() and getpwuid_r()
            s/pwbuf/pwd/ and s/pwbufp/result/, for consistency
            with POSIX.1 argument names.
    Michael Kerrisk
        Clarify and add more detail in RETURN VALUE description
            The page was a bit fuzzy in describing the return values for
            various cases.  In particular, it needed to be more explicit
            in describing what happens for the "not found" case.

            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=504787
    Michael Kerrisk
        Add an EXAMPLE program for getpwnam_r()

inet_ntop.3
    Michael Kerrisk
        Rename 'cnt' argument to 'size'
            This is consistent with POSIX.1, and also a more sensible name.
    Michael Kerrisk
        Rework text describing 'size' argument
            (After a suggestion by Vegard Nossum.)
            Also made a few other small rewordings to in the initial
            paragraph.

makecontext.3
    Michael Kerrisk
        Add text on use of pointer arguments to makecontext()
            Passing pointer arguments to makecontext() is possible,
            but only on some architectures, and with no guarantees
            of portability.

            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=504699

pthread_attr_setaffinity_np.3
    Michael Kerrisk
        Various fixes after review by Loïc Domaigne
            Reviewed-by: Loïc Domaigne

pthread_attr_setaffinity_np.3
pthread_setaffinity_np.3
    Michael Kerrisk
        Update to reflect new location of CPU_*() documentation
            The CPU_*() macros are now documented in CPU_SET.3;
            update to reflect that fact.
    Michael Kerrisk
        Remove redundant text relating to CPU sets
            Information about CPU_SETSIZE can be found in CPU_SET.3, so
            remove discussion of it here.

pthread_attr_setschedparam.3
pthread_setschedparam.3
    Michael Kerrisk
        Remove text saying that only sched_priority is required by POSIX.1
            Loïc Domaigne points out that if a system implements
            SCHED_SPORADIC (which Linux does not), then other
            fields are also specified in sched_param.  The simple
            solution is just to remove that phrase from the man
            page.

pthread_cancel.3
pthread_detach.3
pthread_join.3
pthread_setaffinity_np.3
    Michael Kerrisk
        Make text of ESRCH error consistent

pthread_setaffinity_np.3
    Michael Kerrisk
        Add text to EINVAL error mentioning cpuset(7)
    Michael Kerrisk
        Various improvements after review by Loïc Domaigne
            Various fix-ups after Loïc's review.

            Reviewed-by: Loïc Domaigne

pthread_setschedparam.3
    Michael Kerrisk
        PTHREAD_INHERIT_SCHED is default for inherit scheduler attribute
            In EXAMPLE, note that PTHREAD_INHERIT_SCHED is the default for
            the inherit scheduler attribute.

syslog.3
    Masanari Iida
        LOG_KERN messages can't be generated from user processes
            Masanari notes that this is an FAQ for logger(1) and that
            Solaris and FreeBSD document this point in syslog(3).
            The glibc info page also hides this comment in its source:

                Internally, there is also LOG_KERN, but LOG_KERN == 0,
                which means if you try to use it here, just selects default.

proc.5
    Ivana Varekova
        Fix reference to kernel source file
            Use relative reference to Documentation/mtrr.txt.

arp.7
    Michael Kerrisk
        Add kernel version numbers for /proc interfaces

cpuset.7
    Michael Kerrisk
        SEE ALSO: add CPU_SET(3)

epoll.7
    Michael Kerrisk
        Note glibc version that added epoll support

icmp.7
    Michael Kerrisk
        Add kernel version numbers to /proc file descriptions

inotify.7
    Vegard Nossum
        Fix description of max_user_watches
            It seems that inotify(7) is wrong here:

            "/proc/sys/fs/inotify/max_user_watches
                This specifies a limit on the number of watches that can be
                associated with each inotify instance."

            On my system, the default value for this variable is 8192. But I
            cannot create more than 8192 watches in total for the same UID
            even when they are on different inotify instances. So I suggest
            to rephrase this as: "This specifies an upper limit on the
            number of watches that can be created per real user ID."

ip.7
    Michael Kerrisk
        Reorder socket options alphabetically
    Michael Kerrisk
        Added kernel version numbers for IP_* socket options
    Michael Kerrisk
        Relocate kernel version information for IP_PMTUDISC_PROBE
    Michael Kerrisk
        Add kernel version numbers for /proc/sys/net/ipv4/ip_* files
    Michael Kerrisk
        Remove mention of kernel header from description of IP_RECVERR
            Looks like glibc has had this definition since about version 2.1.
    Michael Kerrisk
        Relocate kernel version information for ip_mreqn structure
    Michael Kerrisk
        Relocate info about Linux-specific sockopts to NOTES
            Also add some source comments about non-standard Linux-specific
            options that are not yet documented.

netlink.7
    Vegard Nossum
        Fix incorrect variable names in example code
            s/snl/sa/ * 2

pthreads.7
    Michael Kerrisk
        Add section on cancellation points
            This section includes a list of the functions that must and
            may be cancellation points.
    Michael Kerrisk
        Rework, and fix small error in, thread-safe function list
            Integrate the changes that occurred in POSIX.1-2008 into the
            main list (to be consistent with the list, elsewhere on this
            page, of functions that are cancellation points).

            Also, fix an error that said that strerror() was added to
            the list in POSIX.1-2008.  It was strsignal() that was
            added.  (strerror() was already in the list in POSIX.1-2001.)
    Michael Kerrisk
        Tweak text on sigpause() cancellation point
            In POSIX.1-2009, this function moves from the "must be"
            to the "may be" list.
    Michael Kerrisk
        Add ref to signal(7) for further info on use of real-time signals
            signal(7) provides some further details on the use of real-time
            signals by the two Linux threading implementations.
    Michael Kerrisk
        SEE ALSO: add pthread_attr_init() and pthread_cancel()

tcp.7
    Michael Kerrisk
        Update description of tcp_rmem defaults for Linux 2.6
    Michael Kerrisk
        Add kernel version numbers for TCP_* socket options
            Note kernel version were each socket option first appeared.
    Michael Kerrisk
        The tcp_bic* proc files disappeared in Linux 2.6.13
    Michael Kerrisk
        tcp_vegas_cong_avoid disappeared in Linux 2.6.13
    Michael Kerrisk
        Add mention of RFC 4138 for 'tcp_frto' /proc file
    Michael Kerrisk
        Remove mention of /proc in VERSIONS
            This information is not indicated for each /proc interface
    Michael Kerrisk
        Clarify that tcp_mem measures in units of the system page size
    Michael Kerrisk
        Update tcp_frto description for 2.6.22 changes
            Linux 2.6.22 added a mode value 2 ("Enable SACK-enhanced
            F-RTO if flow uses SACK").
    Michael Kerrisk
        Fix alphabetical order in /proc file list
            A few entries were slightly out of order.
    Michael Kerrisk
        Remove obsolete statement about /proc from VERSIONS
            Much of the text has been updated to 2.6.27 or so,
            so this statement no longer applies.
    Michael Kerrisk
        Add kernel version numbers for each /proc interface
            Note kernel version where each /proc interface first appeared
    Michael Kerrisk
        tcp_westwood /proc file disappeared in Linux 2.6.13
    Michael Kerrisk
        Update description of tcp_wmem defaults for Linux 2.6


==================== Changes in man-pages-3.15 ====================

Released: 2008-12-05, Bucaramanga


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andre Majorel <aym-xunil@teaser.fr>
Andries E. Brouwer <Andries.Brouwer@cwi.nl>
Chris Heath <chris@heathens.co.nz>
Drake Wilson <drake@begriffli.ch>
Mats Wichmann <mats.d.wichmann@intel.com>
Mel Gorman <mel@csn.ul.ie>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Fedyk <mfedyk@mikefedyk.com>
Pavel Machek <pavel@suse.cz>
Petr Baudis <pasky@suse.cz>
Phil Endecott <phil_vonar_endecott@chezphil.org>
Rob Landley <rob@landley.net>
Sam Varshavchik <mrsam@courier-mta.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

makedev.3
    Michael Kerrisk
        New page for makedev(), major(), and minor() macros

pthread_cleanup_push_defer_np.3
    Michael Kerrisk
        New page for pthread_cleanup_push_defer_np(3) and
        pthread_cleanup_pop_restore_np(3)


Newly documented interfaces in existing pages
---------------------------------------------

accept.2
    Michael Kerrisk
        Document accept4() system call, new in Linux 2.6.28

fmemopen.3
    Petr Baudis
        Add description of open_wmemstream(3)

tcp.7
    Michael Kerrisk
        Document MSG_TRUNC flag for TCP sockets

New and changed links
---------------------

accept4.2
    Michael Kerrisk
        New link to accept.2
            accept.2 now documents the new accept4() system call.

open_wmemstream.3
    Petr Baudis
        New link to fmemopen.3
            fmemopen.3 now documents open_wmemstream().
pthread_cleanup_pop_restore_np.3
    Michael Kerrisk
        New link to new pthread_cleanup_push_defer_np.3


Global changes
--------------

accept.2
listen.2
recv.2
getpeername.2
getsockname.2
shutdown.2
socketpair.2
    Michael Kerrisk
        Global fix: SEE ALSO: add socket(7)

bind.2
rcmd.3
capabilities.7
ip.7
    Michael Kerrisk
        Global fix: s/reserved port/privileged port/
            Some pages used one term, some pages the other term;
            make some consistency.

connect.2
getpeername.2
getsockname.2
    Michael Kerrisk
        Use consistent argument names
            Most other sockets pages are using the names 'addr'
            and 'addrlen'; make these pages do the same.

getpeername.2
getsockname.2
getsockopt.2
recv.2
send.2
shutdown.2
sockatmark.3
socket.7
udplite.7
    Michael Kerrisk
        SYNOPSIS: Rename socket file descriptor argument to 'sockfd'
            Many sockets man pages use the name 'sockfd' already.
            For consistency, changes the others to do so as well.

gnu_dev_major.3
gnu_dev_makedev.3
gnu_dev_minor.3
major.3
minor.3
    Michael Kerrisk
        New links to new makedev(3) page


Changes to individual pages
---------------------------

_exit.2
    Michael Kerrisk
        Since glibc 2.3, the exit() wrapper function invokes exit_group(2)
            This information is useful to users of strace(1).

accept.2
    Michael Kerrisk
        Clarify details when returned address is truncated
            If the returned address is truncated, the 'addrlen' argument
            indicates the actual size of the address, rather than a count
            of the number of bytes in the truncated buffer.

            Also clarify that if 'addr' argument is NULL, then 'addrlen'
            should is unused, and should also be NULL.
    Michael Kerrisk
        Reorder ERRORS list
            Some errors were listed under a separate "may" heading.
            There's probably no real need to do this; integrate
            those errors into the main list.

exit_group.2
    Michael Kerrisk
        Note that since glibc 2.3, exit(2) invokes exit_group()

futex.2
    Michael Kerrisk
        Mention that glibc provides no wrapper function for futex()

get_thread_area.2
    Michael Kerrisk
        Note that glibc provides no wrapper for this system call

getdomainname.2
    Michael Kerrisk
        Substantial rewrite
            Expand description of setdomainname() and getdomainname().
            Note that getdomainname() is implemented as a library function
            in glibc.
            Note limits on size of domain name.
            Reorganize ERRORS list.

gethostname.2
    Michael Kerrisk
        Various parts rewritten
            Write a paragraph describing sethostname().

            Clarify differences between glibc's gethostbyname() and
            the kernel gethostbyname() system calls.

gethostname.2
    Michael Kerrisk
        Note that HOST_NAME_MAX is 64 on Linux
            Also note that in pre-1.0 days, the limit on hostnames
            was 8 bytes.

getpeername.2
    Michael Kerrisk
        Note that returned address may be truncated if buffer is too small

getsid.2
    Michael Kerrisk
        Simplified version information and moved to a new VERSIONS section

getsockname.2
    Michael Kerrisk
        Note that returned address is truncated if buffer is too small

mknod.2
    Michael Kerrisk
        Refer reader to makedev(3) to build a device ID

mmap.2
    Michael Kerrisk
        Loosen language around how 'addr' hint is interpreted
            Mel Gorman reported that in Linux 2.6.27, 'addr' is rounded
            down to a page boundary.

            Before kernel 2.6.26, if 'addr' was taken as a hint, it was
            rounded up to the next page boundary.  Since Linux 2.6.24,
            it is rounded down.  Therefore, loosen the description of
            this point to say that the address is rounded to "a nearby
            page boundary".

open.2
    Michael Kerrisk
        EFBIG error is now EOVERFLOW (since Linux 2.6.24)
            When a 32-bit app opens a file whose size is too big to be
            represented in 31-bits, POSIX.1 specifies the error EOVERFLOW.
            Linux used to give EFBIG for this case, but 2.6.24 fixed this.

            Also, add some text to describe the error scenario in
            more detail.

pread.2
    Michael Kerrisk
        Note that glibc emulation for these calls uses lseek(2)
            (This makes it clearer that the emulated calls are not atomic.)

recv.2
send.2
    Michael Kerrisk
        Make names of "address" and "address length" args more consistent
            Make the names of these arguments more consistent with other
            sockets man pages.

recv.2
    Michael Kerrisk
        Clarify details when returned address is truncated
            If the recvfrom() returned address is truncated, the 'fromlen'
            argument indicates the actual size of the address, rather than
            a count of the number of bytes in the truncated buffer.

            Also clarify that the 'from' argument can be NULL, in which
            case 'fromlen' should is unused, and should also be NULL.
    Michael Kerrisk
        Internet datagram and netlink sockets support MSG_TRUNC for recv(2)
            Internet datagram (since Linux 2.4.27/2.6.8),
            and netlink (since Linux 2.6.22) sockets support
            the MSG_TRUNC flag for recv(2).

select.2
    Michael Kerrisk
        Rewrote text describing feature test macros requirement for pselect()

select_tut.2
    Michael Kerrisk
        Fix SHUT_FD* macros in example program
            Add "do {} while (0)"

set_thread_area.2
    Michael Kerrisk
        Note that glibc provides no wrapper for this system call

setfsgid.2
setfsuid.2
    Michael Kerrisk
        Simplify version information and move to a VERSIONS section

setsid.2
    Michael Kerrisk
        Rework RETURN VALUE section; add an ERRORS section

setup.2
    Michael Kerrisk
        Relocate some CONFORMING TO text to VERSIONS and NOTES

stat.2
    Michael Kerrisk
        Document EOVERFLOW error
    Michael Kerrisk
        Refer reader to major() and minor() to decompose a device ID

syscalls.2
    Michael Kerrisk
        Fix version numbers for a few system calls
            Some 2.6 system calls were wrongly mentioned as also being
            backported into a 2.4.x kernel.

uname.2
    Michael Kerrisk
        DESCRIPTION: Point reader at NOTES for further info on field lengths

atan.3
    Andries E. Brouwer
        Fix return value description
            The correct range for the return value is [-pi/2,pi/2].
            (mtk's fix in the last change to the return value text was
            a botch-up of a (correct) suggestion by Nicolas François.)

atexit.3
    Michael Kerrisk
        atexit() and on_exit(3) register functions on the same list
    Michael Kerrisk
        Terminating registered function using longjmp() is undefined
            According to POSIX.1, using longjmp() to terminate execution of
            a function registered using atexit() produces undefined results.
    Michael Kerrisk
        Calling exit(3) more than once produces undefined results
            If an exit handler itself calls exit(3), the results are
            undefined (see the POSIX.1-2001 specification of exit(3)).
    Michael Kerrisk
        The same exit handler may be registered multiple times
    Michael Kerrisk
        Calling _exit(2) terminates processing of exit handlers
    Michael Kerrisk
        Terminating registered function using longjmp() is undefined
            According to POSIX.1, using longjmp() to terminate execution of
            a function registered using atexit() produces undefined results.

bindresvport.3
    Mats Wichmann
        SYNOPSIS: s/\*\*/*/ in prototype
    Michael Kerrisk
        Fix errors regarding port used, plus other rewrites
            Glibc's bindresvport() takes no notice of sin->sin_port:
            it always returns an arbitrary reserved port in the
            anonymous range (512-1023).  (Reported by Mats Wichmann.)

            Also:
            * Add EADDRINUSE and EACCES errors.
            * Mention use of getsockname(2).
            * Other minor rewrites and reorderings of the text.
            * Explicitly note that glib's bindresvport() ignores
              sin->sin_port.
            * Change license There's now virtually no text remaining from
              the 1.70 version of this page.

            Reviewed-by: Mats Wichmann
            Reviewed-by: Petr Baudis

dlopen.3
    Petr Baudis
        Describe confusing dladdr() behavior
            dladdr() will act unexpectedly if called from non-pic code on a
            compile-time-generated function pointer.

fmemopen.3
    Michael Kerrisk
        Add VERSIONS section
    Petr Baudis
        SEE OPEN: Add fopencookie(3)
            fopencookie(3) is used to implement fmemopen().

fopen.3
    Petr Baudis
        SEE ALSO: Add fmemopen(3) and fopencookie(3)

fopencookie.3
    Petr Baudis
        fopencookie() needs _GNU_SOURCE feature test macro

getaddrinfo.3
    Petr Baudis
        Document results ordering and /etc/gai.conf
            This patch documents the order of the getaddrinfo(3) results
            (RFC 3484), how should the application deal with that,
            mentions the extremely common cause of having multiple
            results per query (both IPv4 and IPv6 addresses available)
            and mentions /etc/gai.conf.

            (mtk: Minor tweaks, and note glibc version for /etc/gai.conf)

isatty.3
    Michael Kerrisk
        Complete rewrite of this page, with rather more detail

memmem.3
    Michael Kerrisk
        Remove sentence saying that libc 5.0.9 is still widely used
            That was a *long* time ago.

on_exit.3
    Michael Kerrisk
        Document handling of registrations on fork(2) and execve(2)
            Treatment in these cases is the same as for atexit(3).
    Michael Kerrisk
        Arg given to registered function is status from *last* call to exit()
            It's a subtle point, but if a registered function itself
            calls exit(3), then subsequent functions that were registered
            with on_exit(3) will see the exit status given to the more
            recent exit(3) call.
    Michael Kerrisk
        Note that same function may be registered multiple times

setlocale.3
locale.7
    Michael Kerrisk
        Clean up the description of LANGUAGE environment variable
            Clean up the $LANGUAGE description, by removing bogus comments
            from setlocale(3) and expanding the mention in locale(7).

            Maybe you will decide that a more detailed description
            should be left to the gettext(3) documentation, but I
            actually care about the invisible part of the patch more
            since the comments have put me off the track initially
            ($LANGUAGE has nothing to do with setlocale(3) and is
             completely isolated to gettext, as obvious from the
             glibc sources).

proc.5
    Michael Kerrisk
        /proc/stat: s/minor/disk_idx/ in description of /proc/stat
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=225619

capabilities.7
    Drake Wilson
        Various minor fixes as per Debian bug 471029
            The relevant pieces of
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=471029 are:

              - Delete duplicate subentry for KEYCTL_CHOWN/KEYCTL_SETPERM
                operations in the CAP_SYS_ADMIN entry.  (It feels like that
                capability entry should be converted to a list, but I've
                left it in semicolon-delimited form for now.)

              - Remove text about ENFILE from the text about the
                /proc/sys/fs/file-max limit in the CAP_SYS_ADMIN entry, since
                this is already described in the man pages for the relevant
                ofile-creating system calls.

              - Correct or clarify a few other bits of grammar and such;
                see the diff file itself for details.

socket.7
    Michael Kerrisk
        SEE ALSO: add tcp(7) and udp(7)

tcp.7
    Michael Kerrisk
        Relocate out-of-band data discussion
            Move to a new subsection entitled "Sockets API".
    Michael Kerrisk
        Note that MSG_PEEK can be used on out-of-band data

time.7
    Michael Kerrisk
        SEE ALSO: add clock_gettime(3)

unix.7
    Michael Kerrisk
        Unix domain sockets don't support the recv() MSG_TRUNC flag
    Michael Kerrisk
        Retitled subsection "(Un)supported features" to "Sockets API"
            This is consistent with the recent change in tcp(7).



==================== Changes in man-pages-3.16 ====================

Released: 2009-01-13, Christchurch


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Colin Watson <cjwatson@ubuntu.com>
Florentin Duneau <fduneau@gmail.com>
Petr Baudis <pasky@suse.cz>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

pthread_getcpuclockid.3
    Michael Kerrisk
        New page documenting pthread_getcpuclockid(3)

libc.7
    Michael Kerrisk
        New page giving brief overview of C libraries on Linux

rtld-audit.7
    Michael Kerrisk
        New page documenting dynamic linker auditing API


Newly documented interfaces in existing pages
---------------------------------------------

ld.so.8
    Petr Baudis
        Document LD_AUDIT
    Petr Baudis
        Document LD_POINTER_GUARD


New and changed links
---------------------

gethostid.2
    Michael Kerrisk
        New link to new page location in Section 3

sethostid.2
    Michael Kerrisk
        Change link to point to new page location in Section 3

sethostid.3
    Michael Kerrisk
        New link to relocated page in Section 3

glibc.7
    Michael Kerrisk
        New link to new libc.7


Global changes
--------------

syscalls.2
feature_test_macros.7
standards.7
    Michael Kerrisk
        SEE ALSO: add libc(7)

dlopen.3
ld.so.8
    Michael Kerrisk
        SEE ALSO: add rtld-audit(7)


Changes to individual pages
---------------------------

gethostid.2
    Michael Kerrisk
        Move to Section 3
            The interfaces documented in this page are purely glibc.

syscalls.2
    Michael Kerrisk
        Kernel 2.6.28 adds accept4()

clock_getres.3
    Michael Kerrisk
        SEE ALSO: Add pthread_getcpuclockid(3)

fmemopen.3
    Michael Kerrisk
        Fix VERSIONS information

gethostid.3
    Michael Kerrisk
        Before version 2.2, glibc stored the host ID in /var/adm/hostid
            Also: rewrite some text describing the /etc/hostid file, so that
            this location is referred to just once on the page.
    Michael Kerrisk
        RETURN VALUE: describe return value of sethostid()
    Michael Kerrisk
        Added BUGS section noting that ID can't be guaranteed to be unique
    Michael Kerrisk
        Added ERRORS section describing errors for sethostid()
    Michael Kerrisk
        Update section number to reflect relocation into Section 3

printf.3
    Michael Kerrisk
        Source and destination buffers may not overlap for *s*printf()
            http://sourceware.org/bugzilla/show_bug.cgi?id=7075

            Some existing code relies on techniques like the following to
            append text to a buffer:

                $ cat s.c
                #include <stdio.h>
                char buf[80] = "not ";
                main()
                {
                    sprintf(buf, "%sfail", buf);
                puts(buf);
                return 0;
                }

                $ cc s.c
                $ ./a.out
                not fail

            However, the standards say the results are undefined if source
            and destination buffers overlap, and with suitable compiler
            options, recent changes can cause unexpected results:

                $ cc -v 2>&1 | grep gcc
                gcc version 4.3.1 20080507 (prerelease) [gcc-4_3-branch revision 135036] (SUSE Linux)
                $ cc -D_FORTIFY_SOURCE -O2 s.c
                $ ./a.out
                fail

readdir.3
    Michael Kerrisk
        Rewrite text describing 'dirent' fields standardized in POSIX.1
    Michael Kerrisk
        Clarify text for return value/errno setting for end-of-stream case

nscd.8
    Petr Baudis
        Correct NOTES section on reloading configuration files
            It behaved this way at least since
            "Sun Oct 18 15:02:11 1998 +0000",
            some four months after including the nscd implementation
            in glibc. But there does seem to be a short window between
            glibc-2.1 and glibc-2.1.3 when nscd -i was not available,
            I don't think it's worth muddling the point of the page
            with that, though.


==================== Changes in man-pages-3.17 ====================

Released: 2009-01-19, Hobart


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Adeodato Simó <dato@net.com.org.es>
Bastien ROUCARIES <roucaries.bastien@gmail.com>
Davide Libenzi <davidel@xmailserver.org>
Lefteris Dimitroulakis <edimitro@tee.gr>
Mads Martin Joergensen <mmj@mmj.dk>
Marc Lehmann <schmorp@schmorp.de>
Martin (Joey) Schulze <joey@infodrom.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Petr Baudis <pasky@suse.cz>
Sam Varshavchik <mrsam@courier-mta.com>
Vegard Nossum <vegard.nossum@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

endian.3
    Michael Kerrisk
        New page documenting byte order conversion functions
            Document functions (new in glibc 2.9) for conversion between
            host byte order and big-/little- endian byte order:
            htobe16(), htole16(), be16toh(), le16toh(),
            htobe32(), htole32(), be32toh(), le32toh(),
            htobe64(), htole64(), be64toh(), le64toh()

getifaddrs.3
    Petr Baudis
        New page documenting getifaddrs(3) and freeifaddrs(3)
            Many edits and changes of Petr's initial draft by mtk

cp1251.7
    Lefteris Dimitroulakis
        New page documenting CP 1251 (Windows Cyrillic) character set

iso-8859-10.7
    Lefteris Dimitroulakis
        New page documenting ISO 8859-10 character set

iso_8859-13.7
    Lefteris Dimitroulakis
        New page documenting ISO 8859-13 character set

iso_8859-14.7
    Lefteris Dimitroulakis
        New page documenting ISO 8859-14 character set

iso_8859-3.7
    Lefteris Dimitroulakis
        New page documenting ISO 8859-3 character set

iso_8859-5.7
    Lefteris Dimitroulakis
        New page documenting ISO 8859-5 character set

iso_8859-8.7
    Lefteris Dimitroulakis
        New page documenting ISO 8859-8 character set

koi8-u.7
    Lefteris Dimitroulakis
        New page documenting KOI8-U character set


Newly documented interfaces in existing pages
---------------------------------------------

epoll.7
    Michael Kerrisk
        Document /proc interfaces for limiting kernel memory usage
            Document the following /proc files that were added in
            Linux 2.6.28:
            /proc/sys/fs/epoll/max_user_instances
            /proc/sys/fs/epoll/max_user_watches

netdevice.7
    Michael Kerrisk
        Document recently added interface flags
            IFF_LOWER_UP (since Linux 2.6.17)
            IFF_DORMANT (since Linux 2.6.17)
            IFF_ECHO (since Linux 2.6.25)

            Documentation taken from comments in <linux/if.h>


New and changed links
---------------------

freeifaddrs.3
    Michael Kerrisk
        New link to new getifaddrs.3

htobe16.3
htole16.3
be16toh.3
le16toh.3
htobe32.3
htole32.3
be32toh.3
le32toh.3
htobe64.3
htole64.3
be64toh.3
le64toh.3
    Michael Kerrisk
        New links to new endian.3

iso-8859-10.7
iso_8859_10.7
latin6.7
    Michael Kerrisk
        New links to new iso_8859-10.7

iso-8859-13.7
iso_8859_13.7
latin7.7
    Michael Kerrisk
        New links to new iso_8859-13.7

iso-8859-14.7
iso_8859_14.7
latin8.7
    Michael Kerrisk
        New links to new iso_8859-14.7

iso-8859-3.7
iso_8859_3.7
latin3.7
    Michael Kerrisk
        New links to new iso_8859-3.7

iso-8859-5.7
iso_8859_5.7
    Michael Kerrisk
        New links to new iso_8859-5.7

iso-8859-8.7
iso_8859_8.7
    Michael Kerrisk
        New links to new iso_8859-8.7


Changes to individual pages
---------------------------

bind.2
    Michael Kerrisk
        SEE ALSO: Add getifaddrs(3)

epoll_create.2
    Michael Kerrisk
        Document EMFILE error
            This error is encountered when the limit imposed by
            /proc/sys/fs/epoll/max_user_instances is encountered.
    Michael Kerrisk
        Clarify distinction between epoll instance and epoll file descriptor
            Reword so that the notion of an epoll instance is made clear,
            and made distinct from the notion of an epoll file descriptor.
            Some other minor rewordings also.

epoll_ctl.2
    Michael Kerrisk
        Reordered parts of the text
    Michael Kerrisk
        Introduce notion of epoll instance
            Introduce notion of epoll instance as distinct from
            epoll file descriptor.  Plus other wording clean-ups.
    Michael Kerrisk
        Document ENOSPC error (new in Linux 2.6.28)
            This error results when the limit imposed by
            /proc/sys/fs/epoll/max_user_watches is encountered.

epoll_wait.2
    Michael Kerrisk
        Introduce the notion of an epoll instance into text

getdents.2
    Michael Kerrisk
        Before kernel < 2.6.4, 'd_type' was effectively always DT_UNKNOWN

gethostid.2
    Michael Kerrisk
        Rename file (was misnamed gethostd.2 in previous release)

getsockname.2
    Michael Kerrisk
        SEE ALSO: Add getifaddrs(3)

signalfd.2
    Michael Kerrisk
        Fix description of fork() semantics
            The page text described the semantics of the initial
            implementation of signalfd().  These were changed early on,
            but the man page wasn't updated.

byteorder.3
    Michael Kerrisk
        SEE ALSO: add endian(3)

longjmp.3
    Michael Kerrisk
        Clarify wording re saving/restoring signal mask
    Michael Kerrisk
        siglongjmp() restores signal mask iff 'savesigs' was non-zero
            Note that siglongjmp() restores signal mask if, and only
            if, 'savesigs' argument of sigsetjmp() was non-zero.  (Previous
            text omitted the "and only if".)

memccpy.3
    Michael Kerrisk
        Fix CONFORMING TO: s/C99/POSIX.1-2001/
    Michael Kerrisk
        If the memory areas overlap, the results are undefined

sethostid.3
    Michael Kerrisk
        Rename file (was misnamed sethostd.3 in previous release)

setjmp.3
    Michael Kerrisk
        Clarify wording re saving/restoring signal mask
    Michael Kerrisk
        Clarify when setjmp() provides BSD vs System V signal mask semantics

strsep.3
    Michael Kerrisk
        BUGS: explicitly list problems afflicting strsep()
            Previously, the page said this function suffered the same
            problems as strtok(), but in fact strsep() doesn't suffer
            from all of the same problems as strtok(), so explicitly
            list just the problems of strsep() in the strsep.3 page.

proc.5
    Michael Kerrisk
        Add pointer to epoll(7) for description of epoll /proc files

epoll.7
    Michael Kerrisk
        Various wording changes to improve clarity and consistency


==================== Changes in man-pages-3.18 ====================

Released: 2009-02-10, Christchurch


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
Bastien ROUCARIES <roucaries.bastien@gmail.com>
Christian Siebert <christian.siebert@s2000.tu-chemnitz.de>
Christopher Head <chead@telus.net>
Florentin Duneau <fduneau@gmail.com>
Guillem Jover <guillem@debian.org>
Lefteris Dimitroulakis <edimitro@tee.gr>
Lucio Maciel <luciofm@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Peter Zijlstra <peterz@infradead.org>
Petr Baudis <pasky@suse.cz>
Sam Varshavchik <mrsam@courier-mta.com>
Satyam Sharma <ssatyam@cse.iitk.ac.in>
Sebastian Kienzl <seb@riot.org>
Timo Sirainen <tss@iki.fi>
Vegard Nossum <vegard.nossum@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

armscii-8.7
    Lefteris Dimitroulakis
        New page documenting ArmSCII-8 character set

iso_8859-11.7
    Lefteris Dimitroulakis
        New page documenting ISO 8859-11 character set

iso_8859-4.7
    Lefteris Dimitroulakis
        New page documenting ISO 8859-4 character set

iso_8859-6.7
    Lefteris Dimitroulakis
        New page describing ISO 8859-6 character set

pthread_kill.3
    Michael Kerrisk
        New page documenting pthread_kill(3)

pthread_kill_other_threads_np.3
    Michael Kerrisk
        New page documenting pthread_kill_other_threads_np(3)

pthread_sigmask.3
    Michael Kerrisk
        New page documenting pthread_sigmask(3)


Newly documented interfaces in existing pages
---------------------------------------------

clock_getres.3
    Michael Kerrisk
        Document CLOCK_MONOTONIC_RAW, new in 2.6.28


New and changed links
---------------------

clock_gettime.2
clock_settime.2
clock_getres.3
clock_gettime.3
clock_settime.3
    Michael Kerrisk
        Update links to reflect the fact that clock_* pages are now in
        Section 2

iso-8859-11.7
iso_8859_11.7
    Michael Kerrisk
        New links to new iso_8859-11.7

iso-8859-4.7
iso_8859_4.7
latin4.7
    Michael Kerrisk
        New links to new iso_8859-4.7

iso-8859-6.7
iso_8859_6.7
    Michael Kerrisk
        New links to new iso_8859-6.7

tis-620.7
    Michael Kerrisk
        New link to new iso_8859-11.7


Global changes
--------------

clock_nanosleep.2
getrusage.2
timerfd_create.2
clock.3
clock_getcpuclockid.3
ftime.3
pthread_create.3
pthread_getcpuclockid.3
pthread_tryjoin_np.3
sem_wait.3
time.7
    Michael Kerrisk
        Global fix: Fix xrefs to clock_*.? pages to reflect move to section 2

clock_nanosleep.2
execve.2
fork.2
nanosleep.2
sigaction.2
timerfd_create.2
pthread_getcpuclockid.3
ualarm.3
usleep.3
pthreads.7
time.7
    Michael Kerrisk
        Global fix: s/(3)/(2)/ in section number xrefs for timer_*() API
            The POSIX timers API is implemented (mostly) within the kernel,
            so these interfaces are system calls.  Although there are as yet
            no man pages, when they are added they should be in Section 2,
            not 3.  Therefore fix those pages that currently refer to these
            interfaces as being in Section 3.


Changes to individual pages
---------------------------

capget.2
    Andi Kleen
        Add some details and relocate a paragraph
            While writing a little program using capset
            I found the capset manpage quite light on crucial
            details and I had to resort to RTFS.

            This patch improves the points I found unclear
            and also moves one misplaced paragraph around.

clock_getres.2
    Michael Kerrisk
        Move page from Section 3 to Section 2

eventfd.2
    Michael Kerrisk
        glibc eventfd() supports the use of eventfd2() since version 2.9

fork.2
    Michael Kerrisk
        SEE ALSO: add daemon(3)

getdents.2
    Michael Kerrisk
        Remove unneeded HAVE_D_TYPE from example program
            Since d_type will always just return DT_UNKNOWN before
            kernel 2.6.4, we don't need to use a conditional for
            determining whether we use this flag.

nanosleep.2
    Michael Kerrisk
        Relocated misplaced BUGS heading

select_tut.2
    Michael Kerrisk
        Clean up error checking in example program (no semantic changes)
    Michael Kerrisk
        Many parts tidied and rewritten
            Remove some redundant text, clarify various pieces,
            tidy example code, etc.
    Michael Kerrisk
        Bug fixes + rewrites in example program
            Sebastien pointed out that the first example program
            wrongly thinks it can count signals.
            Also, some further rewrites by mtk.

socket.2
    Michael Kerrisk
        BUGS: Remove discussion SOCK_UUCP
            As time goes on, this sentence becomes less a piece of humor,
            and more a puzzle.

stat.2
    Michael Kerrisk
        Note that open(O_NOATIME) also causes st_atime not to be updated

timerfd_create.2
    Michael Kerrisk
        Add BUGS noting that timerfd supports fewer clock types than
        timer_create()

btowc.3
    Michael Kerrisk
        SEE ALSO: add wctob(3)

clock_getcpuclockid.3
    Michael Kerrisk
        SEE ALSO: add pthread_getcpuclockid(3)

cos.3
    Michael Kerrisk
        SEE ALSO: add sincos(3)

fexecve.3
    Timo Sirainen
        Note that fexecve() depends on a mounted /proc
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=514043
    Michael Kerrisk
        CONFORMING TO: note addition of fexecve() in POSIX.1-2008
    Michael Kerrisk
        'fd' must be opened read-only and refer to a file that is executable

fmemopen.3
    Michael Kerrisk
        CONFORMING TO: note that these functions are in POSIX.1-2008

getifaddrs.3
    Lucio Maciel
        Fix memory leak in example program
    Petr Baudis
        Various small fixes

getpwnam.3
    Michael Kerrisk
        SEE ALSO: add getspnam(3)

getumask.3
    Michael Kerrisk
        Updated glibc version number in NOTES

ilogb.3
    Michael Kerrisk
        SEE ALSO: add significand(3)

intro.3
    Michael Kerrisk
        SEE ALSO: add libc(7)

isalpha.3
    Michael Kerrisk
        Fix statement that isalpa() is obsolete; should be isascii()
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=512709
    Michael Kerrisk
        SEE ALSO: add toascii(3)

mq_notify.3
    Michael Kerrisk
        Add cross reference to pthread_attr_init(3)

pthread_attr_setaffinity_np.3
    Michael Kerrisk
        SYNOPSIS: Fix declaration of 'attr'

pthread_getcpuclockid.3
    Michael Kerrisk
        SYNOPSIS: fix type of 'thread'

qsort.3
    Michael Kerrisk
        EXAMPLE: remove unnecessary "#include <unistd.h>"

random.3
    Michael Kerrisk
        SEE ALSO: add random_r(3)

remainder.3
    Michael Kerrisk
        SEE ALSO: add div(3)

scandir.3
    Michael Kerrisk
        CONFORMING TO: alphasort() and scandir() are added to POSIX.1-2008
    Michael Kerrisk
        CONFORMING TO: note that versionsort() was added to glibc in
        version 2.1

sem_wait.3
    Michael Kerrisk
        SEE ALSO: add clock_gettime(2)

significand.3
    Michael Kerrisk
        Add CONFORMING TO noting that this function is unstandardized

sigwait.3
    Michael Kerrisk
        Add EXAMPLES section referring to pthread_sigmask(3)

sin.3
    Michael Kerrisk
        SEE ALSO: add sincos(3)

stpcpy.3
    Michael Kerrisk
        Add BUGS section noting the possibility of buffer overruns
    Michael Kerrisk
        Add missing pieces/fix various problems in example program
    Michael Kerrisk
        CONFORMING TO: stpcpy() is nowadays on the BSDs
    Michael Kerrisk
        SEE ALSO: add stpcpy.3

wcscasecmp.3
    Michael Kerrisk
        CONFORMING TO: note that this function is added in POSIX.1-2008

wcsdup.3
    Michael Kerrisk
        CONFORMING TO: note that this function was added in POSIX.1-2008

wcsncasecmp.3
    Michael Kerrisk
        CONFORMING TO: note that this function is added in POSIX.1-2008

wctob.3
    Michael Kerrisk
        SEE ALSO: add btowc(3)

proc.5
    Michael Kerrisk
        Remove mention of epoll/max_user_instances
            (Since this interface appeared in 2.6.28, and then
            disappeared in 2.6.29.)

ascii.7
    Michael Kerrisk
        Update SEE ALSO list to include pages added in 3.17
    Michael Kerrisk
        SEE ALSO: add recently added iso_8859-*(7) pages

epoll.7
    Michael Kerrisk
        remove documentation of /proc/sys/fs/epoll/max_user_instances
            This /proc interface appeared in 2.6.28. but will be
            removed in 2.6.29.

            Also, document change in default value of
            /proc/sys/fs/epoll/max_user_watches (was 1/32 of lowmem,
            now 1/25 of lowmem).

koi8-r.7
    Michael Kerrisk
        SEE ALSO: add koi8-u(7); remove crufty text

standards.7
    Michael Kerrisk
        Update to note that latest POSIX/SUS was ratified in 2008

time.7
    Michael Kerrisk
        SEE ALSO: add pthread_getcpuclockid(3)


==================== Changes in man-pages-3.19 ====================

Released: 2009-02-20, Putaruru


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Christian Siebert <christian.siebert@gmail.com>
Jan Engelhardt <jengelh@medozas.de>
Jens Thoms Toerring <jt@toerring.de>
Kir Kolyshkin <kir@openvz.org>
Mark Hills <mark@pogo.org.uk>
Michael Kerrisk <mtk.manpages@gmail.com>
Parag Warudkar <parag.lkml@gmail.com>
Peter Zijlstra <a.p.zijlstra@chello.nl>
Sami Liedes <sliedes@cc.hut.fi>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

timer_create.2
    Michael Kerrisk
        New page documenting timer_create(2)

timer_delete.2
    Michael Kerrisk
        New page documenting timer_delete(2)

timer_getoverrun.2
    Michael Kerrisk
        New page documenting timer_getoverrun(2)

timer_settime.2
    Michael Kerrisk
        New page documenting timer_settime(2) and timer_gettime(2)


New and changed links
---------------------

timer_gettime.2
    Michael Kerrisk
        New link to new timer_settime.2


Global changes
--------------

Various pages
    Kir Kolyshkin
        Trivial punctuation fixes in SEE ALSO
            In SEE ALSO, when a few man pages are referenced, those
            are divided by commas.  Every reference is on a separate
            line, and all lines but the last one should end with
            comma. I spotted one place where there is no comma in
            between references, and mocked up an awk script to find
            similar places:

            for f in man*/*; do
                awk '
                    /^.SH ["]SEE ALSO["]/ {
                        sa=1; print "== " FILENAME " =="; print; next
                    }
                    /^\.(PP|SH)/ {
                        sa=0; no=0; next
                    }
                    /^\.BR/ {
                        if (sa==1) {
                            print;
                            if (no == 1)
                                print "Missing comma in " FILENAME " +" FNR-1; no=0
                        }
                    }
                    /^\.BR .*)$/ {
                        if (sa==1)
                            no=1;
                        next
                    }
                    /\.\\"/ {next}
                    /.*/ {
                        if (sa==1) {
                            print; next
                        }
                    }
                ' $f;
            done | fgrep 'Missing comma'

            This patch fixes all the places found by the above script.

            Also, there is an extra dot at the end of uri.7 "SEE ALSO"
            section.  Removed as per man-pages(7) recommendation.


Changes to individual pages
---------------------------

getitimer.2
clock_getcpuclockid.3
time.7
    Michael Kerrisk
        SEE ALSO: add timer_create(2)

getitimer.2
    Michael Kerrisk
        Rename arguments for consistency with other timer pages
            Also some other minor wording improvements

splice.2
    Mark Hills
        ERRORS: Add EINVAL case for file opened O_APPEND
            Target file cannot be opened in append (O_APPEND) mode

            In kernels prior to v2.6.27 splice() to a file in
            append mode is broken, and since that version it is
            disallowed. It is possible this behaviour may change
            in the future; see the kernel commit message
            (efc968d450e013049a662d22727cf132618dcb2f) for more
            information.

syscalls.2
    Michael Kerrisk
        Note that getpmsg(2) and putmsg(2) are unimplemented
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=514771

timerfd_create.2
    Michael Kerrisk
        ERRORS: add EFAULT

timerfd_create.2
    Michael Kerrisk
        Rename timerfd_settime() 'curr_value' arg to 'old_value'
            For consistency with related pages.

vm86.2
    Parag Warudkar
        CONFORMING TO: Add 32-bit specific
            Note that this call is only on *32-bit* Intel

mq_open.3
    Michael Kerrisk
        ERRORS: add ENOENT error for name == "/"

mq_open.3
    Michael Kerrisk
        ERRORS: Add EACCES error for name containing > 1 slash

sem_open.3
    Michael Kerrisk
        ERRORS: add EINVAL error where name == "/"

sem_open.3
    Jens Thoms Toerring
        Add case of non-well-formed name to ENOENT

shm_open.3
    Michael Kerrisk
        Clarify rules for construction of shared memory object names

proc.5
    Michael Kerrisk
        Add description of /proc/sys/kernel/sysrq
            Reported by: Goerghe Cosorea <gheorghe.coserea@gmail.com>

proc.5
    Michael Kerrisk
        Put /proc/modules entry in correct alphabetical order

ascii.7
    Kir Kolyshkin
        Fix formatting of tables on second page to use monospaced font

mq_overview.7
    Michael Kerrisk
        Clarify construction rules for message queue object names

sem_overview.7
    Michael Kerrisk
        Clarify construction rules for semaphore object names
            See also http://groups.google.com/group/comp.os.linux.development.apps/browse_thread/thread/b4a67caa765cb65f



==================== Changes in man-pages-3.20 ====================

Released: 2009-03-31, Christchurch


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alan Curry <pacman@kosh.dhis.org>
Américo Wang <xiyou.wangcong@gmail.com>
Andi Kleen <andi@firstfloor.org>
Carlos O'Donell <carlos@systemhalted.org>
Chunming Chang <cchang@aerohive.com>
Colin Watson <cjwatson@debian.org>
Eelco Dolstra <e.dolstra@tudelft.nl>
Jan Engelhardt <jengelh@medozas.de>
Jens Thoms Toerring <jt@toerring.de>
Johannes Stezenbach <js@sig21.net>
Leandro A. F. Pereira <leandro@tia.mat.br>
Martin Gebert <martin.gebert@alpha-bit.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike O'Connor <stew@vireo.org>
Mike Frysinger <vapier@gentoo.org>
Nikanth Karthikesan <knikanth@suse.de>
Reuben Thomas <rrt@femur.dyndns.org>
Reuben Thomas <rrt@sc3d.org>
Roland McGrath <roland@redhat.com>
Sam Varshavchik <mrsam@courier-mta.com>
Simon Gomizelj <simongmzlg@gmail.com>
Tanaka Akira <akr@fsij.org>
Teddy Hogeborn <teddy@fukt.bsnet.se>
Walter Jontofsohn <wjontofs@atriumberlin.de>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

cpuid.4
    Andi Kleen
        New page for cpuid access device

msr.4
    Andi Kleen
        New page documenting x86 CPU MSR access device


Newly documented interfaces in existing pages
---------------------------------------------

proc.5
    Américo Wang
        Document /proc/sys/vm/swappiness
    Michael Kerrisk
        Document /proc/sysrq-trigger


Global changes
--------------

timer_create.2
timer_delete.2
timer_getoverrun.2
timer_settime.2
numa.7
    Michael Kerrisk
        Make source layout of 'Link with' text consistent with other pages
            No actual change to formatted output, but this makes the
            page sources more consistent for the purpose of grepping, etc.

mempcpy.3
signbit.3
significand.3
    Michael Kerrisk
        Global fix: acknowledge FSF in copyright
            These pages are heavily based on original material in
            glibc info pages, but the comments in the source of the pages
            did not acknowledge the FSF copyright on the original material.
            Fix that.

accept.2
read.2
recv.2
send.2
write.2
    Michael Kerrisk
        Fix discussion of EAGAIN/EWOULDBLOCK errors
            For a non-blocking socket, POSIX.1-2001/2008 allow either
            EAGAIN or EWOULDBLOCK to be returned in cases where a call
            would have blocked.  Although these constants are defined
            with the same value on most Linux architectures (PA-RISC
            is the exception), POSIX.1 does not require them to have
            the same value.  Therefore, a portable application using
            the sockets API should test for both errors when checking
            this case.

            (NB POSIX.1 only mentions EWOULDBLOCK in the context of
            the sockets interfaces.)

            Change made after a note cross-posted on linux-arch@vger,
            http://thread.gmane.org/gmane.linux.debian.ports.hppa/5615
            and a suggestion for write(2) from Carlos O'Donell

basename.3
getgrent.3
getgrnam.3
getpwent.3
getpwnam.3
readdir.3
    Michael Kerrisk
        Note that returned pointer should not be given to free()

armscii-8.7
cp1251.7
iso_8859-10.7
iso_8859-11.7
iso_8859-13.7
iso_8859-14.7
iso_8859-15.7
iso_8859-16.7
iso_8859-2.7
iso_8859-3.7
iso_8859-4.7
iso_8859-5.7
iso_8859-6.7
iso_8859-7.7
iso_8859-8.7
iso_8859-9.7
koi8-r.7
koi8-u.7
    Michael Kerrisk
        Add explicit character set encoding to first line of source
            Nowadays mandb has provision to understand a character set
            encoding that is explicitly indicated in the first line
            of the source.  As pointed out by Colin Watson, including
            such an explicit indication on pages encoded in anything
            other than ISO 8859-1 or UTF-8 is useful for man-pages
            that aren't shipped in UTF-8.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=519209
            and for some other background (responded to by Colin Watson
            in the above report):
            http://thread.gmane.org/gmane.comp.internationalization.linux/6040
            ("man page encoding", 5 Jul 2005)


Changes to individual pages
---------------------------

fallocate.2
    Michael Kerrisk
        VERSIONS: glibc support is provided since version 2.10

fcntl.2
    Michael Kerrisk
        Remove mention of EWOULDBLOCK from discussion of mandatory locking
            In the kernel, the error on encountering a mandatory lock is
            EAGAIN.  Although EAGAIN and EWOULDBLOCK are the same on
            most Linux architectures, on some they are not, so don't
            mention EWOULDBLOCK as it is misleading.  (Mea culpa.)

getcontext.2
    Michael Kerrisk
        Note that POSIX.1-2008 removes the specification of getcontext()

getitimer.2
    Michael Kerrisk
        Note that POSIX.1-2008 recommends POSIX timers API instead of this API

gettimeofday.2
    Michael Kerrisk
        Note that POSIX.1-2008 recommends clock_gettime() instead of this API

ptrace.2
    Michael Kerrisk
        Note use of 'data' for PTRACE_SYS{CALL,EMU} and PTRACE_*_SINGLESTEP
            These operations use the 'data' argument as a signal number,
            like PTRACE_CONT.

ptrace.2
    Mike Frysinger
        only reference <sys/user.h>
            The kernel no longer installs linux/user.h, so update
            references to sys/user.h.

recv.2
    Michael Kerrisk
        Add 'iovec' defn to defn of 'msghdr' structure
            The 'msghdr' structure includes a field of type 'iovec',
            so show the definition of that structure in this page.

rename.2
    Michael Kerrisk
        Make ENOENT description consistent with POSIX.1-2008

timerfd_create.2
    Michael Kerrisk
        ERRORS: add EINVAL for invalid 'flags' for timer_settime()

truncate.2
    Michael Kerrisk
        SYNOPSIS: Fix description of feature test macro requirements
            After a report by Arvid Norlander.

bcopy.3
    Michael Kerrisk
        Note that POSIX.1-2008 removes specification of bcopy()

bsd_signal.3
    Michael Kerrisk
        Note that POSIX.1-2008 recommends sigaction(2) instead of this API

ctime.3
    Michael Kerrisk
        Note that POSIX.1-2008 recommends strftime(3) instead of these functions

ecvt.3
    Michael Kerrisk
        Note that POSIX.1-2008 recommends sprintf(3) instead of these functions

gcvt.3
    Michael Kerrisk
        Note that POSIX.1-2008 recommends sprintf(3) instead of this function

getcwd.3
    Michael Kerrisk
        Note that getcwd() should be used instead of the obsolete getwd()

getgrent.3
    Michael Kerrisk
        Returned buffer may be statically allocated and overwritten by
        later calls

gethostbyname.3
    Michael Kerrisk
        POSIX.1-2008 recommends getaddrinfo(3) and getnameinfo(3) instead

getnetent_r.3
    Michael Kerrisk
        Fix function name in text: s/getnetbynumber_r/getnetbyaddr_r/
            The SYNOPSIS showed the right function name (getnetbyaddr_r),
            but the text repeatedly used the wrong name (getnetbynumber_r).
            Probably, this was a cut-and-paste error.

getpwent.3
    Michael Kerrisk
        Returned buffer may be statically allocated and overwritten by
        later calls

index.3
    Michael Kerrisk
        Note that POSIX.1-2008 recommends strchr(3) and strrchr(3) instead

isalpha.3
    Michael Kerrisk
        Explain why POSIX.1-2008 marks isascii(3) obsolete

lockf.3
    Nikanth Karthikesan
        Update pointer to documentation in kernel source

makecontext.3
    Michael Kerrisk
        Note that POSIX.1-2008 recommends the use of POSIX threads instead

mq_notify.3
    Michael Kerrisk
        Document the POSIX.1-2008 optional EINVAL error
            POSIX.1-2008 allows an optional EINVAL error if
            notification==NULL and the caller is not currently
            registered to receive notifications.

posix_fallocate.3
    Michael Kerrisk
        Clarify that EINVAL also occurs of 'len' *equals* zero
            See http://bugzilla.kernel.org/show_bug.cgi?id=12919

posix_fallocate.3
    Michael Kerrisk
        Document POSIX.1-2001 and POSIX.1-2008 specifications for EINVAL error
            See http://bugzilla.kernel.org/show_bug.cgi?id=12919

posix_memalign.3
    Michael Kerrisk
        Document handling of size==0 case for posix_memalign()

pthread_exit.3
    Michael Kerrisk
        Fix error in DESCRIPTION: s/pthread_create/pthread_exit/

realpath.3
    Michael Kerrisk
        Rework resolved_path==NULL discussion w.r.t. POSIX.1-200[18]
            Although the page already mentioned the resolved_path==NULL
            feature, and that this feature was added in POSIX.1-2008, there
            was still some crufty text in BUGS that hadn't been updated to
            reflect the POSIX.1-2008 changes.

            Also, some other minor wording and grammar fixes.

scalb.3
    Michael Kerrisk
        Note that POSIX.1-2008 recommends scalbln*(3) instead

seekdir.3
    Michael Kerrisk
        SYNOPSIS: Fix type of 'offset' argument: s/off_t/long/
            And add a NOTES section pointing out that 'off_t'
            was indeed used in glibc 2.1.1 and earlier.
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=519230

sem_post.3
    Michael Kerrisk
        Document EOVERFLOW error

shm_open.3
    Michael Kerrisk
        Recast discussion on name length to exclude terminating NULL byte
            Probably it's clearer to describe the length of the IPC object
            name as a count that excludes the null terminator.

siginterrupt.3
    Michael Kerrisk
        Note that POSIX.1-2008 recommends sigaction() instead

sigset.3
    Michael Kerrisk
        Note APIs that POSIX.1-2008 recommends instead of these obsolete APIs

strftime.3
    Michael Kerrisk
        Small fix to description of %G
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=516677

strftime.3
    Michael Kerrisk
        Add details on ISO 8601 week-based dates
            ISO 8602 week-based dates are relevant for %G, %g, and %V,
            and the existing details on these dates are a little thin.

strftime.3
    Michael Kerrisk
        Remove mention of year from ISO 8601 standard
            The text mentioned the 1988 8601 standard, but there have
            already been two revisions of the standard since then, so
            simply remove mention of the year.

telldir.3
    Michael Kerrisk
        SYNOPSIS: Fix return type: s/off_t/long/
            And add a NOTES section pointing out that 'off_t'
            was indeed used in glibc 2.1.1 and earlier.
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=519230

timeradd.3
    Michael Kerrisk
        Note that on some systems, <=, >=, == don't work for timercmp()

timeradd.3
    Michael Kerrisk
        SYNOPSIS: Fix return types of timerisset() and timercmp()

toascii.3
    Michael Kerrisk
        Note why POSIX.1-2008 marks this function obsolete

console_ioctl.4
    Alan Curry
        Fix 'argp' type for KDGETLED description
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=517485

group.5
    Michael Kerrisk
        Various minor rewordings and improvements

resolv.conf.5
    Michael Kerrisk
        Document 'ip6-bytestring' option

resolv.conf.5
    Michael Kerrisk
        Document 'edns0' option

resolv.conf.5
    Michael Kerrisk
        Document 'ip6-dotint' / 'no-ip6-dotint' option

resolv.conf.5
    Michael Kerrisk
        Note that maximum value of 'ndots' option is capped to 15

resolv.conf.5
    Michael Kerrisk
        Note that maximum value of 'timeout' option is capped to 30

hier.7
    Michael Kerrisk
        Add description of /srv
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=520904

ip.7
    Michael Kerrisk
        Fix type used to declare sin6_port
            The page should use the type specified by POSIX,
            rather than the (equivalent) type used in the kernel

ipv6.7
    Teddy Hogeborn
        Fix types used to declare sin6_family and sin6_port
            The page should use the types specified by POSIX,
            rather than the (equivalent) types used in the kernel.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=517074

mq_overview.7
    Michael Kerrisk
        Recast discussion on name length to exclude terminating NULL byte
            Probably it's clearer to describe the length of the IPC object
            name as a count that excludes the null terminator.

rtld-audit.7
    Michael Kerrisk
        Note that multiple libraries in LD_AUDIT doesn't work
            This is reportedly fixed in glibc 2.10.
            See http://sourceware.org/bugzilla/show_bug.cgi?id=9733

sem_overview.7
    Michael Kerrisk
        Fix discussion of length of semaphore names
            Because of the "sem." prefix added by glibc to a semaphore
            name, the limit on the length of the name (excluding the
            terminating null byte) is 251 characters.


==================== Changes in man-pages-3.21 ====================

Released: 2009-04-15, Los Gatos


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Frank Dana <ferdnyc@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Roman Byshko <rbyshko@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

pthread_setconcurrency.3
    Michael Kerrisk
        New page documenting pthread_setconcurrency(3) and
        pthread_getconcurrency(3)

pthread_yield.3
    Michael Kerrisk
        New page documenting pthread_yield(3)


New and changed links
---------------------

pthread_getconcurrency.3
    Michael Kerrisk
        New link to new pthread_setconcurrency(3)

Changes to individual pages
---------------------------

initrd.4
    Michael Kerrisk
        Various minor wording improvements

initrd.4
    Frank Dana
        Add missing word in description

feature_test_macros.7
    Michael Kerrisk
        Update for glibc 2.10 changes to <features.h>
            From glibc 2.10, <features.h> understands the values 200809
            for _POSIX_C_SOURCE and 700 for _XOPEN_SOURCE, and makes
            corresponding changes to defaults for other feature test macros.
    Michael Kerrisk
        Add an example program
            This example program makes it possible to explore what
            feature test macros are set depending on the glibc version
            and the macros that are explicitly set.

ldconfig.8
    Michael Kerrisk
        /etc/ld.so.conf also include libraries found in /lib and /usr/lib


==================== Changes in man-pages-3.22 ====================

Released: 2009-07-25, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Adrian Dewhurst <sailor@sailorfrag.net>
Alexander Lamaison <awl03@doc.ic.ac.uk>
Bryan Østergaard <kloeri@exherbo.org>
Christopher Head <chead@telus.net>
Doug Goldstein <cardoe@gentoo.org>
Florentin Duneau <fduneau@gmail.com>
Gokdeniz Karadag <gokdenizk@gmail.com>
Jeff Moyer <jmoyer@redhat.com>
KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Lucian Adrian Grijincu <lucian.grijincu@gmail.com>
Mark Hills <mark@pogo.org.uk>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Petr Baudis <pasky@suse.cz>
Reimar Döffinger <Reimar.Doeffinger@gmx.de>
Ricardo Garcia <rg3.zeluan@gmail.com>
Rui Rlex <rui.rlex@gmail.com>
Shachar Shemesh <shachar@debian.org>
Tolga Dalman <tdalman@project-psi.org>
ku roi <kuroibox@yahoo.de>
sobtwmxt <sobtwmxt@sdf.lonestar.org>

Apologies if I missed anyone!


Changes to individual pages
---------------------------

clone.2
    Michael Kerrisk
        Rewrite crufty text about number of args in older version of clone()
                Some bit rot had crept in regarding the discussion of the
                number of arguments in older versions of this syscall.
                Simplify the text to just say that Linux 2.4 and earlier
                didn't have ptid, tls, and ctid arguments.

                See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=533868
    Michael Kerrisk
        Fix version number for CLONE_NEWIPC
            It's 2.6.19, not 2.4.19.
    Michael Kerrisk
        Fix errors in argument names in text (ptid, ctd)

execve.2
    Mike Frysinger
        Remove erroneous statement that pending signal set is cleared
        on execve(2).

fcntl.2
    Michael Kerrisk
        The kernel source file mandatory.txt is now mandatory-locking.txt
    Michael Kerrisk
        The Documentation/* files are now in Documentation/filesystems

flock.2
    Michael Kerrisk
        Remove unneeded reference to Documentation/mandatory.txt
            Mandatory locks are only implemented by fcntl() locking
    Michael Kerrisk
        The Documentation/* files are now in Documentation/filesystems

fork.2
    Jeff Moyer
        Document fork() behaviour for the Linux native AIO io_context
            It was noted on lkml that the fork behaviour is documented
            for the POSIX AIO calls, but not for the Linux native calls.
            Here is a patch which adds a small blurb that folks will
            hopefully find useful.

            Upon fork(), the child process does not inherit the
            io_context_t data structures returned by io_setup,
            and thus cannot submit further asynchronous I/O or
            reap event completions for said contexts.

getdents.2
    Michael Kerrisk
        The d_type field is fully supported on Btrfs

mount.2
    Michael Kerrisk
        Document MS_STRICTATIME, update description of MS_RELATIME
            Starting with Linux 2.6.30, the MS_RELATIME behavior became
            the default, and MS_STRICTATIME is required to obtain the
            traditional semantics.

poll.2
    Michael Kerrisk
        Remove EBADF error from ERRORS
            As reported by Motohiro:

            "man poll" describe this error code.

            >ERRORS
            > EBADF  An invalid file descriptor was given in one of the sets.

            but current kernel implementation ignore invalid file descriptor,
            not return EBADF.
            ...

            In the other hand, SUSv3 talk about

            > POLLNVAL
            >  The specified fd value is invalid. This flag is only valid in the
            >  revents member; it shall ignored in the events member.

            and

            > If the value of fd is less than 0, events shall be ignored, and
            > ireevents shall be set to 0 in that entry on return from poll().

            but, no desribe EBADF.
            (see http://www.opengroup.org/onlinepubs/009695399/functions/poll.html)

            So, I think the implementation is correct.

            Why don't we remove EBADF description?

sigaction.2
    Michael Kerrisk
        Expand description of si_utime and si_stime fields of siginfo_t

stat.2
    Michael Kerrisk
        Improve wording of ENOTDIR error

syscalls.2
    Michael Kerrisk
        Add preadv() and pwritev(), new in kernel 2.6.30

wait.2
    Gokdeniz Karadag
        Document CLD_DUMPED and CLD_TRAPPED si_code values

daemon.3
    Michael Kerrisk
        Clarify discussion of 'noclose' and 'nochdir' arguments

ffs.3
    Petr Baudis
        SEE ALSO: add memchr(3)

fmemopen.3
    Petr Baudis
        Relocate BUGS section to correct position
    Petr Baudis
        NOTES: there is no file descriptor associated with the returned stream
            Alexander Lamaison pointed out that this is not obvious
            from the documentation, citing an example with passing the
            FILE * handle to a function that tries to fstat() its
            fileno() in order to determine the buffer size.
    Michael Kerrisk
        CONFORMING TO: remove note that these functions are GNU extensions
            That sentence is now redundant, since these functions
            are added in POSIX.1-2008.

lockf.3
    Michael Kerrisk
        Clarify relationship between fcntl() and lockf() locking

memchr.3
    Petr Baudis
        SEE ALSO: add ffs(3)

readdir.3
    Michael Kerrisk
        The d_type field is fully supported on Btrfs

setjmp.3
    Mike Frysinger
        Fix typo and clarify RETURN description
            The word "signal" was duplicated in NOTES, and the RETURN
            section refers to setjmp() and sigsetjmp(), and mentions
            longjmp(), but not siglongjmp().

strcmp.3
    Petr Baudis
        SEE ALSO: add strverscmp(3)

strcpy.3
    Mark Hills
        SEE ALSO: Add strdup(3)

complex.7
    Michael Kerrisk
        Add missing header file for example program
    Reimar Döffinger
        Fix type used in example code
        man complex (from release 3.18) contains the following code:
            complex z = cexp(I * pi);
        Reading the C99 standard, "complex" is not a valid type,
        and several compilers (Intel ICC, ARM RVCT) will refuse to compile.
        It should be
            double complex z = cexp(I * pi); instead.

environ.7
    Michael Kerrisk
        Note that last element in environ array is NULL
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=528628
    Michael Kerrisk
        Wording fixes

mq_overview.7
    Michael Kerrisk
        Note that mkdir and mount commands here need superuser privilege
    Michael Kerrisk
        Fix example showing contents of /dev/mqueue file

standards.7
    Michael Kerrisk
        Remove references to dated books
            Gallmeister and Lewine are rather old books. Probably,
            there are better books to consult nowadays, and anyway,
            this man page isn't intended to be a bibliography.


==================== Changes in man-pages-3.23 ====================

Released: 2009-09-30, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Aaron Gardner <aaron.j.gardner@gmail.com>
Andrey Vihrov <vihrov@gmail.com>
Christoph Hellwig <hch@lst.de>
Georg Sauthoff <gsauthof@techfak.uni-bielefeld.de>
Leslie P. Polzer <sky@viridian-project.de>
Marc Lehmann <debian-reportbug@plan9.de>
Mark Hills <mark@pogo.org.uk>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Nicolas François <nicolas.francois@centraliens.net>
Serge Hallyn <serue@us.ibm.com>
Siward de Groot <siward@ziggo.nl>
rui rlex <rui.rlex@gmail.com>

Apologies if I missed anyone!


Changes to individual pages
---------------------------

execve.2
pipe.2
tee.2
fmemopen.3
mq_notify.3
qsort.3
    Michael Kerrisk
        Replace use of assert() by code that checks argc
            See http://bugzilla.kernel.org/show_bug.cgi?id=13569

            As noted by Andrey:
            The purpose of the assert macro, defined in <assert.h>,
            is to provide a tool to check for programming mistakes
            or program logic errors. However, the assert macro must
            never be used to perform checks for run time errors,
            since, with the NDEBUG macro defined, expressions within
            the assert macro invocations are not evaluated/checked
            for, resulting in behavior that was not originally intended.
            ...
            The pages affected in the core package are

            execve(2)
            pipe(2)
            tee(2)
            fmemopen(3)
            mq_notify(3)
            qsort(3)

getrusage.2
    Michael Kerrisk
        ru_inblock and ru_oublock are now implemented
            These fields of the rusage structure are filled in since
            Linux 2.6.22.

mmap.2
    Michael Kerrisk
        Add brief documentation of MAP_HUGETLB
            This flag is new in 2.6.32, and serves a similar
            purpose to the shmget() SHM_HUGETLB flag.

open.2
    Christoph Hellwig
        add some comments on O_SYNC and friends

poll.2
    Michael Kerrisk
        Clarify wording describing of 'nfds' argument.
            reported by: rui rlex <rui.rlex@gmail.com>

semctl.2
    Nicolas François
        Remove some redundant words

setpgid.2
    Michael Kerrisk
        Add an explanation of orphaned process groups

splice.2
tee.2
vmsplice.2
    Mark Hills
        Fix return type
            Since glibc 2.7, the return type for these functions
            is ssize_t (formerly it was long).

stat.2
    Nicolas François
        Fix small bug in example program
            Since it is a failure, EXIT_FAILURE looks more appropriate
            than EXIT_SUCCESS.

umount.2
    Michael Kerrisk
        glibc only exposes MNT_DETACH and MNT_EXPIRE since version 2.11
            See http://sourceware.org/bugzilla/show_bug.cgi?id=10092

exit.3
    Michael Kerrisk
        Add a pointer to explanation of orphaned process groups in setpgid(2)

fflush.3
    Michael Kerrisk
        fflush() discards buffered input

ffs.3
    Michael Kerrisk
        Clarify that ffsl() and ffsll() are GNU extensions

getaddrinfo.3
    Michael Kerrisk
        Note nonstandard assumed hints.ai_flags value when hints is NULL
            When hints is NULL, glibc assumes hints.ai_flags is
            AI_V4MAPPED|AI_ADDRCONFIG whereas POSIX says 0.
            According to Ulrich Drepper, glibc's behavior is better.

getmntent.3
    Mike Frysinger
        setmntent() argument is 'filename' not 'fp'
            The description of setmntent() formerly used the wrong
            argument name.

posix_fallocate.3
    Nicolas François
        Fix reference to POSIX.1-2008
            The sentence mentions twice POSIX.1-2001.
            I guess the second one should be POSIX.1-2008.
            This should be checked in the standard.

setenv.3
    Michael Kerrisk
        Improve ERRORS section
            Add ENOMEM error; improve EINVAL description. Also, make
            RETURN VALUE section a little more accurate in its mention
            of errno.

strftime.3
    Nicolas François
        Fix error in description: s/Monday/Thursday/

proc.5
    Nicolas François
        Fix page cross reference
            max_user_watches is better explained in epoll(7) than inotify(7).

proc.5
    Michael Kerrisk
        dmesg is in section 1, not section 8

capabilities.7
    Michael Kerrisk
        FS UID manipulations affect CAP_LINUX_IMMUTABLE and CAP_MKNOD
            Nowadays, file system UID manipulations also affect
            CAP_LINUX_IMMUTABLE (since 2.6.3) and CAP_MKNOD (since 2.6.29).

capabilities.7
    Michael Kerrisk
        Fix version number for CAP_MKNOD in FS UID manipulations
            A recent patch said "since 2.6.29". It should have
            been "since 2.6.30".

capabilities.7
    Nicolas François
        Reword a bad sentence in description of capability bounding set.

mq_overview.7
    Michael Kerrisk
        Change documented ranges for msg_max and msgsize_max
            Linux 2.6.28 changed the permissible ranges for
            these /proc files.

tcp.7
udp.7
    Nicolas François
        Replace references to syctl interfaces with /proc


==================== Changes in man-pages-3.24 ====================

Released: 2010-02-25, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
Andries E. Brouwer <Andries.Brouwer@cwi.nl>
Ansgar Burchardt <ansgar@2008.43-1.org>
Bela Lubkin <filbo@armory.com>
Bill O. Gallmeister <bog.kernel@gmail.com>
Christoph Hellwig <hch@lst.de>
Colin Watson <cjwatson@debian.org>
Dan Jacobson <jidanni@jidanni.org>
David Howells <dhowells@redhat.com>
Denis Barbier <bouzim@gmail.com>
Doug Manley <doug.manley@gmail.com>
Edward Welbourne <eddy@opera.com>
Fang Wenqi <anton.fang@gmail.com>
Frédéric Brière <fbriere@fbriere.net>
Garrett Cooper <yaneurabeya@yahoo.com>
Ihar Hrachyshka <ihar.hrachyshka@gmail.com>
Jann Poppinga <jann.poppinga@gmx.de>
Jason Goldfine-Middleton <jasonwoodfine@gmail.com>
Jason Noakes <jjnoakes@gmail.com>
Jonathan Nieder <jrnieder@gmail.com>
Kevin <tsubasa.xw@gmail.com>
Mark Hills <mark@pogo.org.uk>
Markus Peuhkuri <puhuri@iki.fi>
Michael Kerrisk <mtk.manpages@gmail.com>
Michael Witten <mfwitten@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Sam Liao <phyomh@gmail.com>
Samy Al Bahra <sbahra@repnop.org>
Stuart Kemp <skemp@alertlogic.com>
sunjiangangok <sunjiangangok@gmail.com>
Tobias Stoeckmann <tobias@bugol.de>
Vlastimil Babka <caster@gentoo.org>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

add_key.2
    David Howells
        New page documenting add_key(2)
            Taken from keyutils-1.1 package.

keyctl.2
    David Howells
        New page documenting keyctl(2)
            Taken from keyutils-1.1 package.

request_key.2
    David Howells
        New page documenting request_key(2)
            Taken from keyutils-1.1 package.


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix: s/non-root/unprivileged/

Various pages
    Michael Kerrisk
        Global fix: s/non-privileged/unprivileged/

Various pages
    Michael Kerrisk
        Global fix:  /non-superuser/unprivileged user/

Various pages
    Michael Kerrisk
        s/non-/non/
            The tendency in English, as prescribed in style guides like
            Chicago MoS, is toward removing hyphens after prefixes
            like "non-" etc.

Various pages
    Michael Kerrisk
        Global fix: s/re-/re/
            The tendency in English, as prescribed in style guides like
            Chicago MoS, is toward removing hyphens after prefixes
            like "re-" etc.

Various pages
    Michael Kerrisk
        Global fix: s/multi-/multi/
            The tendency in English, as prescribed in style guides like
            Chicago MoS, is toward removing hyphens after prefixes
            like "multi-" etc.

Various pages
    Michael Kerrisk
        Global fix: s/pre-/pre/
            The tendency in English, as prescribed in style guides like
            Chicago MoS, is toward removing hyphens after prefixes
            like "pre-" etc.

Various pages
    Michael Kerrisk
        Global fix: s/sub-/sub/
            The tendency in English, as prescribed in style guides like
            Chicago MoS, is toward removing hyphens after prefixes
            like "sub-" etc.

stime.2
time.2
utimensat.2
ctime.3
difftime.3
ftime.3
getspnam.3
mq_receive.3
mq_send.3
rtime.3
sem_wait.3
strftime.3
strptime.3
timeradd.3
rtc.4
core.5
proc.5
icmp.7
time.7
    Michael Witten
        Global fix: Consistently define the Epoch
            All definitions of the Epoch have been refactored to the following:

              1970-01-01 00:00:00 +0000 (UTC)

            That form is more consistent, logical, precise, and internationally
            recognizable than the other variants.

            Also, some wording has been altered as well.

spu_create.2
getopt.3
passwd.5
    Michael Kerrisk
        Global fix: s/non-existing/nonexistent/

faccessat.2
fchmodat.2
fchownat.2
fstatat.2
futimesat.2
linkat.2
mkdirat.2
mknodat.2
openat.2
readlinkat.2
renameat.2
symlinkat.2
unlinkat.2
utimensat.2
mkfifoat.3
    Michael Kerrisk
        Update feature test macro requirements
            Starting in glibc 2.10, defining _XOPEN_SOURCE >= 700,
            or _POSIX_C_SOURCE >= 200809 exposes the declarations of
            these functions.


Changes to individual pages
---------------------------

clock_getres.2
    Michael Kerrisk
        Update text on nonsetabble CLOCK_*_CPUTIME_ID clocks
            SUSv3 permits, but does not require CLOCK_THREAD_CPUTIME_ID and
            CLOCK_PROCESS_CPUTIME_ID to be settable.
            See http://bugzilla.kernel.org/show_bug.cgi?id=11972.

execve.2
    Colin Watson
        Fix description of treatment of caught signals
            Caught signals reset to their default on an execve() (not
            to being ignored).

fcntl.2
    Michael Kerrisk
        s/F_OWNER_GID/F_OWNER_PGRP/
            Peter Zijlstra took the name change I suggested.
    Michael Kerrisk
        Document F_[SG]ETOWN_EX; update details on F_SETOWN
            Linux 2.6.32 adds F_SETOWN_EX and F_GETOWN_EX.
            Linux 2.6.12 changed (broke) the former behavior of
            F_SETOWN with respect to threads.

intro.2
intro.3
    Michael Kerrisk
        Make subsection heading consistent with other intro.? pages
            These pages used "Copyright Terms"; the other intro.? pages
            used "Copyright Conditions". Make these pages like the others.

sendfile.2
    Michael Kerrisk
        Clarify behavior when 'offset' is NULL

seteuid.2
    Michael Kerrisk
        Note unstandardized behavior for effective ID
            POSIX.1 doesn't require that the effective ID can be changed
            to the same value it currently has (a no-op). The man page
            should note this, since some other implementations
            don't permit it.

setgid.2
    Michael Kerrisk
        Fix EPERM error description
            s/effective group ID/real group ID/
            This bug lived in man pages for 15 years before Jason
            spotted it! I checked back in Linux 1.0, and the behavior
            was as the fixed man page describes.

setreuid.2
    Michael Kerrisk
        Add more detail on POSIX.1 specification for these syscalls

setuid.2
    Michael Kerrisk
        Remove crufty statement that seteuid() is not in POSIX
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=569812

stime.2
strftime.3
tzset.3
zic.8
    Michael Witten
        GMT -> UTC (where appropriate)

sync_file_range.2
    Christoph Hellwig
        Add some big warnings re data integrity
            This system call is by design completely unsuitable for any data
            integrity operations.  Make that very clear in the manpage.

CPU_SET.3
    Vlastimil Babka
        SYNOPSIS: Fix return types for CPU_COUNT_*()
            These functions return 'int' not void'.

confstr.3
    Michael Kerrisk
        Fix feature test macro requirements

daemon.3
    Michael Kerrisk
        Fix description of 'nochdir' argument.
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=554819

gethostbyname.3
    Michael Kerrisk
        Document feature test macro requirements for herror() and hstrerror()
            Since glibc 2.8, one of _BSD_SOURCE, _SVID_SOURCE,
            or _GNU_SOURCE is required.

getline.3
    Michael Kerrisk
        Update to reflect that these functions were standardized in POSIX.1-2008

getnameinfo.3
    Michael Kerrisk
        Document feature test macros requirements for NI_MAXHOST and NI_MAXSERV
            Since glibc 2.8, one of _BSD_SOURCE, _SVID_SOURCE, or _GNU_SOURCE
            must be defined to obtain these definitions.

getopt.3
    Jonathan Nieder
        Fix feature test macro requirements

memchr.3
    Michael Kerrisk
        Add feature text macro requirements for memrchr()

nextafter.3
    Michael Kerrisk
        Fix notable error in DESCRIPTION.
        "less than y" should be "less than x".

popen.3
    Michael Kerrisk
        Fix feature test macro requirements

pthread_attr_setdetachstate.3
pthread_attr_setschedparam.3
pthread_attr_setschedpolicy.3
    Denis Barbier
        Argument name is 'attr' not 'thread'
            The function argument was misnamed in the DESCRIPTION on these
            three pages.

rtnetlink.3
    Michael Kerrisk
        Various fixes in example code
            Edward reported a problem in the example code, where a variable
            seems to be misnamed. Upon inspection, there seem to be a few
            such instances, and this patch is my best guess at how things
            should look.

sched_getcpu.3
    Michael Kerrisk
        Place correct header file in SYNOPSIS

sleep.3
    Bill O. Gallmeister
        sleep() puts calling *thread* to sleep (not calling *process*)

sleep.3
    Bill O. Gallmeister
        Add nanosleep(2) to SEE ALSO

strftime.3
    Michael Kerrisk
        %z is defined in SUSv3
            So, substitute "GNU" tag in man page by "SU".

strftime.3
    Michael Witten
        Move 822-compliant date format example to EXAMPLES section
            The RFC 822-compliant date format given in the description
            of `%z' is now moved to the `EXAMPLES' section (note: `EXAMPLE'
            has been renamed `EXAMPLES').

            Furthermore, that format example is now actually
            RFC 822-compliant (using `%y' instead of `%Y') and has been
            qualified as being correct only when in the context of at least
            an English locale. Also, `%T' is used in place of `%H:%M:%S'.

            For completeness, an RFC 2822-compliant format example has been
            similarly added.

strftime.3
    Michael Witten
        Expand introductory text

strftime.3
    Michael Witten
        Clarification of %z specifier

string.3
    Mark Hills
        Add stpcpy() to this list of string functions

strptime.3
    Michael Kerrisk
        Initialize tm structure in example program

undocumented.3
    Michael Kerrisk
        Remove pages now documented
            By now, the following are documented:

                fopencookie(3)
                freeifaddrs(3)
                rawmemchr(3)
                readdir_r(3)
                getutmp(3)
                getutmpx(3)
                utmpxname(3)

            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=554819

group.5
    Michael Kerrisk
        s/passwd/password/
            The page inconsistently used "passwd" and "password"
            to refer to the same field.

capabilities.7
    Michael Kerrisk
        Update securebits discussion to use SECBIT_* flags

feature_test_macros.7
    Michael Kerrisk
        _POSIX_C_SOURCE >= 200808 defines _ATFILE_SOURCE
            Since glibc 2.10, _POSIX_C_SOURCE >= 200808 defines _ATFILE_SOURCE

path_resolution.7
    Michael Kerrisk
        Add readlink(2) to SEE ALSO
    Michael Kerrisk
        Fix NAME line
            The poorly constructed part preceding "\-" causes apropos
            not to be able to find the subject.

            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=558300

signal.7
    Michael Kerrisk
        Fix discussion of SIGUNUSED
            Clarify that this signal really is synonymous with SIGSYS.
            See http://bugzilla.kernel.org/show_bug.cgi?id=14449


==================== Changes in man-pages-3.25 ====================

Released: 2010-06-20, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alexander E. Patrakov <patrakov@gmail.com>
Andi Kleen <andi@firstfloor.org>
Andrew Klossner <andrew@cesa.opbu.xerox.com>
André Goddard Rosa <andre.goddard@gmail.com>
Bo Borgerson <gigabo@gmail.com>
Christian Franke <nobody@nowhere.ws>
Daisuke HATAYAMA <d.hatayama@jp.fujitsu.com>
David Sommerseth <davids@redhat.com>
Denis Barbier <bouzim@gmail.com>
Eric Blake <ebb9@byu.net>
Fang Wenqi <anton.fang@gmail.com>
Francesco Cosoleto <cosoleto@gmail.com>
Gernot Tenchio <gernot@tenchio.de>
Hugh Dickins <hughd@google.com>
Ivana Hutarova Varekova <varekova@redhat.com>
Jan Blunck <jblunck@novell.com>
Jan Engelhardt <jengelh@medozas.de>
Jan Kara <jack@suse.cz>
Jeff Barry <JeffBatHome@myletters.us>
Manfred Schwarb <manfred99@gmx.ch>
Mark Hills <mark@pogo.org.uk>
Martin (Joey) Schulze <joey@infodrom.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Mihai Paraschivescu <paraschivescu_mihail@yahoo.com>
Mike Frysinger <vapier@gentoo.org>
Miklos Szeredi <miklos@szeredi.hu>
Petr Baudis <pasky@suse.cz>
Petr Gajdos <pgajdos@suse.cz>
Petr Uzel <petr.uzel@suse.cz>
Pierre Habouzit <madcoder@madism.org>
Reuben Thomas <rrt@sc3d.org>
Rob Landley <rob@landley.net>
Robert Wohlrab <robert.wohlrab@gmx.de>
Serge E. Hallyn <serge@hallyn.com>
Tolga Dalman <tdalman@project-psi.org>
Tom Swigg <swiggtc@lsbu.ac.uk>
Walter Harms <wharms@bfs.de>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

migrate_pages.2
    Andi Kleen
        New page documenting migrate_pages(2).
            Andi's text based on the move_pages.2 page;
            additional edits by mtk.
            migrate_pages(2) was new in Linux 2.6.16.

quotactl.2
    Jan Kara
        Major updates
            Update the page to consolidate information from the
            outdated man-pages quotactl.2 page and the quotactl.2
            page in the "quota-tools" package. The page in "quota-tools"
            has now been dropped by Jan Kara, so that there is just one
            canonical quotactl.2 page (in pan-pages).
    Michael Kerrisk
            Various other pieces added to the page by mtk.


Newly documented interfaces in existing pages
---------------------------------------------

fcntl.2
    Michael Kerrisk
        Document F_SETPIPE_SZ and F_GETPIPE_SZ
            These commands, new in kernel 2.6.35, set and get the capacity
            of pipes.

madvise.2
    Andi Kleen
        Document MADV_HWPOISON
    Michael Kerrisk
        Added documentation of MADV_MERGEABLE and MADV_UNMERGEABLE
            These flags (used for Kernel Samepage Merging, KSM)
            are new in 2.6.32.
    Andi Kleen
        Document MADV_SOFT_OFFLINE
            This operation was added in Linux 2.6.33.

mmap.2
    Michael Kerrisk
        Document MAP_UNINITIALIZED flag
            New in Linux 2.6.33.

prctl.2
    Andi Kleen
        Document the hwpoison prctls in 2.6.32

sched_setscheduler.2
    Michael Kerrisk
        Document SCHED_RESET_ON_FORK
            New in Linux 2.6.32

umount.2
    Michael Kerrisk
        Document UMOUNT_NOFOLLOW
            New in Linux 2.6.34.

mkstemp.3
    Michael Kerrisk
        Document mkstemps() and mkostemps()
            These functions are new in glibc 2.11. They allow the template
            string to include a suffix after the "XXXXXX" string.

proc.5
    Michael Kerrisk
        Document /proc/sys/vm/memory_failure_early_kill
            New in 2.6.32. Description based on the text in
            Documentation/sysctl/vm.txt.
    Michael Kerrisk
        Document /proc/sys/vm/memory_failure_recovery
            New in Linux 2.6.32.  Description based on the text in
            Documentation/sysctl/vm.txt.
    Michael Kerrisk
        Document /proc/sys/fs/pipe-max-size

socket.7
    Jan Engelhardt
        Document SO_DOMAIN and SO_PROTOCOL
            These read-only socket options were new in Linux 2.6.32.


New and changed links
---------------------

fstatvfs.2
    Michael Kerrisk
        Adjust link to point to Section 3

fstatvfs.3
statvfs.2
    Michael Kerrisk
        New link to page relocated to Section 3

mkstemps.3
mkostemps.3
    Michael Kerrisk
        New links to mkstemp.3
            mkstemp.3 now describes mkstemps(3) and mkostemps(3).

timer_create.2
timer_delete.2
timer_getoverrun.2
timer_settime.2
getline.3
    Michael Kerrisk
        Add 'L' to constants in feature test macro specifications
            Be consistent with POSIX, which uses constants such as 200809L.


Global changes
--------------

open.2
sync_file_range.2
umount.2
    Michael Kerrisk
        Global fix: s/filesystem/file system/


Changes to individual pages
---------------------------

fcntl.2
    Michael Kerrisk
        Note that glibc 2.11 papers over the kernel F_GETOWN bug
            Since version 2.11, glibc works around the kernel limitation for
            process groups IDs < 4096 by implementing F_GETOWN via F_GETOWN_EX.

futex.2
    Michael Kerrisk
        Various fixes in SEE ALSO

getpriority.2
nice.2
    Francesco Cosoleto
        Move renice from section 8 to section 1

getrusage.2
    Mark Hills
        Add ru_maxrss
            See kernel commit 1f10206.
    Mark Hills
        Description of maintained fields
            These descriptions are taken from NetBSD 5.0's getrusage(2).
    Michael Kerrisk
        Enhanced description of various fields

mlock.2
    Michael Kerrisk
        /proc/PID/status VmLck shows how much memory a process has locked
            After a note from Tom Swigg, it seems sensible mention VmLck here.

mount.2
    Petr Uzel
        Fix incorrect path

move_pages.2
    Andi Kleen
        Clarify includes/libraries

mremap.2
    Michael Kerrisk
        Clarify existence of fifth argument.

msgctl.2
semctl.2
shmctl.2
    Francesco Cosoleto
        Move ipcs from section 8 to section 1

open.2
    Michael Kerrisk
        Remove ambiguity in text on NFS and O_EXCL.

poll.2
    Michael Kerrisk
        Fix discussion of ppoll() timeout argument
            1. Rename ppoll)(_ argument to "timeout_ts" to distinguish it
               from the poll() argument in the text.
            2. More accurately describe the poll() call that is equivalent
               to ppoll().

posix_fadvise.2
    Michael Kerrisk
        Add sync_file_range(2) under SEE ALSO

prctl.2
    Michael Kerrisk
        Correct PR_SET_KEEPCAPS description
            The "keep capabilities" flag only affects the treatment of
            permitted capabilities, not effective capabilities.
            Also: other improvements to make the PR_SET_KEEPCAPS text clearer.

select_tut.2
    Michael Kerrisk
        Fix bug in example program

sigaction.2
    Michael Kerrisk
        Add TRAP_BRANCH and TRAP_HWBKPT to si_code values for SIGTRAP
    Michael Kerrisk
        Rearrange text describing fields set by sigqueue(2)
    Michael Kerrisk
        Add details for signals sent by POSIX message queue notifications
    Michael Kerrisk
        Improve description of various siginfo_t fields
    Michael Kerrisk
        Add some details for SIGTRAP and si_trapno
    Andi Kleen
        Document hwpoison signal extensions

statfs.2
    Michael Kerrisk
        Bring statfs struct type declarations closer to glibc reality
    Fang Wenqi
        Add definition EXT4_SUPER_MAGIC = 0xEF53
    Michael Kerrisk
        Document f_frsize field.

statvfs.2
    Michael Kerrisk
        Move this page to section 3 (since it's a library call)

swapon.2
    Ivana Hutarova Varekova
        Note effect of CONFIG_MEMORY_FAILURE on MAX_SWAPFILES
            From 2.6.32, MAX_SWAPFILES is decreased by 1 if the kernel is
            built with CONFIG_MEMORY_FAILURE.

syscalls.2
    Michael Kerrisk
        Bring system call list up to date with Linux 2.6.33
    Michael Kerrisk
        Fix kernel version number for utimes()

cproj.3
    Michael Kerrisk
        Note fix for C99 conformance in glibc 2.12.

crypt.3
    Petr Baudis
        Correct note on key portion significance
            As Marcel Moreaux notes:

                The Linux manpage for crypt()[1] contains the following
                statement as the last sentence of the NOTES section:

                    In the SHA implementation the entire key is significant
                    (instead of only the first 8 bytes in MD5).

                It should probably say "DES" where it says "MD5" (and maybe
                "MD5/SHA" where it says "SHA"), because in MD5 password hashing,
                the entire key is significant, not just the first 8 bytes.

            This patch fixes the wording.

fmemopen.3
    Michael Kerrisk
        Bug fix in example program

ftw.3
    Michael Kerrisk
        Note that if 'fn' changes CWD, the results are undefined
    Michael Kerrisk
        Clarify description of fpath argument
            As reported by Pierre Habouzit, 'fpath' is not relative
            to 'dirpath'. It is either relative to the calling process's
            current working directory (if 'dirpath' was relative), or it
            is absolute (if 'dirpath' was absolute).

getaddrinfo.3
    Christian Franke
        Fix a field name mixup: s/ai_family/ai_flags/

getline.3
    Robert Wohlrab
        Remove unneeded check before free()
            The manpage of getline shows an example with an extra NULL pointer
            check before it calls free. This is unneeded according to free(3):

                 If ptr is NULL, no operation is performed.

            This patch removes the "if" check.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=572508

log.3
log10.3
log2.3
    Jan Engelhardt
        Add cross-references to other-base logarithmic functions

opendir.3
    Petr Baudis
        Specify feature test macro requirements for fdopendir(3)
            Currently, there is no note on the fact that fdopendir() is
            POSIX.2008-only.

openpty.3
    Eric Blake
        Use const as appropriate
    Michael Kerrisk
        Note glibc version that added "const" to function arguments
    Michael Kerrisk
        Explicitly note that these functions are not in POSIX

resolver.3
    Michael Kerrisk
        Fix declaration of dn_comp() in SYNOPSIS
            Remove the second 'exp_dn' from the calling signature.

termios.3
    Michael Kerrisk
        Change NOFLSH text to speak of characters, not signals

core.5
    Michael Kerrisk
        Update description of coredump_filter
            Kernel 2.6.24 added MMF_DUMP_ELF_HEADERS.
            Kernel 2.6.28 added MMF_DUMP_HUGETLB_PRIVATE and
            MMF_DUMP_HUGETLB_SHARED.

elf.5
    Daisuke HATAYAMA
        Document PN_XNUM extension
            In linux-2.6.34-rc1, an ELF core extension was added; user-land
            tools manipulating ELF core dump such as gdb and binutils has
            already been modified before; so elf.5 needs to be modified
            accordingly.

            You can follow information on the ELF extension via the LKML post:
            http://lkml.org/lkml/2010/1/3/103
            Date        Mon, 04 Jan 2010 10:06:07 +0900 (JST)
            Subject     ... elf coredump: Add extended numbering support

            This Linux-specific extension was added in kernel 2.6.34.

            Reviewed-by: Petr Baudis <pasky@suse.cz>

    Michael Kerrisk
        Remove EI_BRAND
            As reported by Yuri Kozlov  and confirmed by Mike Frysinger,
            EI_BRAND is not in GABI
            (http://www.sco.com/developers/gabi/latest/ch4.eheader.html)
            It looks to be a BSDism
    Michael Kerrisk
        Remove words under '.note': "described below"
            The existing text is broken, because there is
            no '"Note Section" format' describe below. Simplest
            solution is to remove the words "described below".

filesystems.5
    Jeff Barry
        Add discussion of ntfs and ext4

proc.5
    Michael Kerrisk
        Simplify description of /proc/sys and /proc/sys/fs
            In the description of these directories, there's no need
            to list all the files and subdirectories that they contain;
            that information is provided by the entries that follow.

services.5
    Yuri Kozlov
        Remove crufty reference to nonexistent BUGS section

capabilities.7
    Michael Kerrisk
        Document CAP_SYS_RESOURCE and F_SETPIPE_SZ
            With CAP_SYS_RESOURCE, a process can increase pipe capacity above
            /proc/sys/ps/pipe-max-size.
    Michael Kerrisk
        Add get_robust_list() info under CAP_SYS_PTRACE
    Michael Kerrisk
        Add MADV_HWPOISON under CAP_SYS_ADMIN

signal.7
    Michael Kerrisk
        Make a clearer statement about nonportable aspect of signal(2)
            Make a clearer statement that signal(2) is less portable for
            establishing a signal handler.

socket.7
    Michael Kerrisk
        Use consistent language to describe read-only socket options

udp.7
    Michael Kerrisk
        Add FIONREAD warning.
            Warn that FIONREAD can't distinguish case of a zero-length
            datagram from the case where no datagrams are available.


==================== Changes in man-pages-3.26 ====================

Released: 2010-09-04, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Alexander Shishkin <virtuoso@slind.org>
Brian Sutin <Brian.Sutin@hs.utc.com>
Denis Barbier <bouzim@gmail.com>
Guillem Jover <guillem@hadrons.org>
Jianhua Li <jhlicc@gmail.com>
Linus Nilsson <lajnold@gmail.com>
Lenaic Huard <lenaic.huard@laposte.net>
Mac <mac@mcrowe.com>
Martin Schulze <joey@infodrom.org>
Maxin John <maxin.john@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Nicholas Hunt <nhunt@cs.washington.edu>
Peng Haitao <penght@cn.fujitsu.com>
Peter Stuge <peter@stuge.se>
Przemyslaw Szczepaniak <Przemyslaw.Szczepaniak@imgtec.com>
Scott Walls <sawalls@umich.edu>
TAN Yee Fan <tanyeefa@comp.nus.edu.sg>
Wu Fengguang <fengguang.wu@intel.com>
Yitzchak Gale <gale@sefer.org>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!

Newly documented interfaces in existing pages
---------------------------------------------

eventfd.2
    Michael Kerrisk
        Document EFD_SEMAPHORE
            Document the EFD_SEMAPHORE flag, added in kernel 2.6.30.
            Also restructured some parts of the text to fit with the
            addition of the EFD_SEMAPHORE text.


Global changes
--------------

getaddrinfo.3
getipnodebyname.3
st.4
    Michael Kerrisk
        s/logical OR/bitwise OR/


Changes to individual pages
---------------------------

clock_nanosleep.2
    Michael Kerrisk
        Fix discussion of return value when interrupted by a signal

epoll_ctl.2
    Yuri Kozlov
        Small fix to types in data structures

eventfd.2
    Alexander Shishkin
        Clarified close-on-exec behavior

madvise.2
    Michael Kerrisk
        Improve discussion of MADV_SOFT_OFFLINE

mkdir.2
    Michael Kerrisk
        Add EMLINK error to ERRORS

mq_getsetattr.2
mq_close.3
mq_getattr.3
mq_notify.3
mq_send.3
mq_unlink.3
    Lnac Huard
        Fix return type in SYNOPSIS (s/mqd_t/int/)

recv.2
send.2
    Michael Kerrisk
        Remove obsolete reference to glibc version in NOTES

recv.2
send.2
    Nicholas Hunt
        Adjust type shown for msg_controllen to glibc reality
            This patch fixes the type of msg_controllen in the struct msghdr
            definition given in send.2 and recv.2 to match the definition in
            glibc and the kernel.

select.2
    Michael Kerrisk
        Update NOTES on old glibc pselect()
            Make it clear that modern glibc uses the kernel pselect()
            on systems where it is available.
            See https://bugzilla.kernel.org/show_bug.cgi?id=14411

statfs.2
    Guillem Jover
        Fix copy & paste error for __SWORD_TYPE definition

sysfs.2
    Michael Kerrisk
        Clarify that this syscall is obsolete.
            And strengthen recommendation to use /proc/filesystems instead.

write.2
    Michael Kerrisk
        Add EDESTADDRREQ error

a64l.3
    Peng Haitao
        Fix error in NOTES, s/a64l/l64a/

error.3
    Linus Nilsson
        Change "perror" to "strerror" in DESCRIPTION of error()

mq_send.3
    Michael Kerrisk
        Fix EAGAIN description (s/empty/full)

initrd.4
    Yuri Kozlov
        Fix IP address in explanation of NFS example

tzfile.5
    Michael Kerrisk
        Add information on version 2 format timezone files
            Updated using information from the tzcode 2010l release at
            ftp://elsie.nci.nih.gov/pub.
            (It's an open question whether or not a version of tzfile.5
            should live independently in man-pages. It was added to the
            man-pages set many years ago. For now, I'll follow a
            conservative course that causes least pain to downstream,
            by continuing to maintain a separate copy in man-pages.)

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=594219


==================== Changes in man-pages-3.27 ====================

Released: 2010-09-22, Nuernberg


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

caishuxian <caishuxian@gmail.com>
Denis Barbier <bouzim@gmail.com>
Denis Silakov <silakov@ispras.ru>
der Mouse <mouse@rodents-montreal.org>
Jan Kratochvil  <jan.kratochvil@redhat.com>
Jim Belton <jim.belton@gmail.com>
Jiri Olsa <jolsa@redhat.com>
KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Mark Hills <mark@pogo.org.uk>
Matthew Flaschen <matthew.flaschen@gatech.edu>
Michael Kerrisk <mtk.manpages@gmail.com>
Ozgur Gurcan <ozgur.gurcan@lpp.polytechnique.fr>
Petr Baudis <pasky@suse.cz>
Remi Denis-Courmont <remi@remlab.net>
Tanaka Akira <akr@fsij.org>
Tim Stoakes <tim@stoakes.net>
W. Trevor King <wking@drexel.edu>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

sigevent.7
    Petr Baudis, Michael Kerrisk
        New page to centralize description of sigevent structure
            Several interfaces use this structure. Best to centralize the
            common details in one place. Content taken from the existing
            timerfd_create.2 and mq_open.3 pages, with additions by
            Petr Baudis and Michael Kerrisk.


Newly documented interfaces in existing pages
---------------------------------------------

ip.7
    Jiri Olsa
        Document IP_NODEFRAG
            This option is new in Linux 2.6.36

unix.7
    Michael Kerrisk
        Document SIOCINQ ioctl() operation


Global changes
--------------

_exit.2
brk.2
chdir.2
chmod.2
chown.2
chroot.2
clock_nanosleep.2
getdtablesize.2
gethostname.2
getpagesize.2
getsid.2
killpg.2
mknod.2
mknodat.2
posix_fadvise.2
pread.2
readlink.2
setpgid.2
setreuid.2
sigaltstack.2
stat.2
symlink.2
sync.2
truncate.2
vfork.2
wait.2
wait4.2
a64l.3
abs.3
acos.3
acosh.3
asin.3
asinh.3
atan.3
atan2.3
atanh.3
atoi.3
cbrt.3
ceil.3
clock_getcpuclockid.3
copysign.3
cos.3
cosh.3
dirfd.3
div.3
dprintf.3
ecvt.3
erf.3
erfc.3
exp.3
exp2.3
expm1.3
fabs.3
fdim.3
fexecve.3
ffs.3
floor.3
fma.3
fmax.3
fmemopen.3
fmin.3
fmod.3
fpclassify.3
frexp.3
fwide.3
gamma.3
gcvt.3
getcwd.3
getdate.3
getgrent.3
gethostid.3
getpass.3
getpwent.3
getsubopt.3
getw.3
hypot.3
ilogb.3
insque.3
isalpha.3
isgreater.3
iswblank.3
j0.3
j0.3
ldexp.3
lockf.3
log.3
log10.3
log1p.3
log2.3
logb.3
lrint.3
lround.3
mbsnrtowcs.3
mkdtemp.3
mkstemp.3
mktemp.3
modf.3
mq_receive.3
mq_send.3
nan.3
nextafter.3
posix_fallocate.3
posix_memalign.3
pow.3
printf.3
qecvt.3
random.3
realpath.3
remainder.3
remquo.3
rint.3
rint.3
round.3
scalb.3
scalbln.3
scanf.3
siginterrupt.3
signbit.3
sigset.3
sin.3
sinh.3
sqrt.3
stpcpy.3
stpncpy.3
strdup.3
strdup.3
strnlen.3
strsignal.3
strtod.3
strtol.3
strtoul.3
tan.3
tanh.3
tgamma.3
trunc.3
ttyslot.3
ualarm.3
usleep.3
wcpcpy.3
wcpncpy.3
wcscasecmp.3
wcsdup.3
wcsncasecmp.3
wcsnlen.3
wcsnrtombs.3
wprintf.3
    Michael Kerrisk
        Add/fix/update feature test macro requirements in SYNOPSIS
            Various changes to:
            * Update feature test requirements to note changes in
              recent glibc releases
            * Correct errors in feature test macro requirements
            * Add feature test macro requirements to pages where
              the requirements were not previously stated.

accept.2
clone.2
dup.2
fallocate.2
pipe.2
readahead.2
sched_setaffinity.2
unshare.2
CPU_SET.3
endian.3
euidaccess.3
fexecve.3
getpt.3
getpw.3
getumask.3
getutmp.3
gnu_get_libc_version.3
makedev.3
matherr.3
mbsnrtowcs.3
memfrob.3
pthread_attr_setaffinity_np.3
pthread_getattr_np.3
pthread_setaffinity_np.3
pthread_tryjoin_np.3
tcgetsid.3
wcscasecmp.3
wcsncasecmp.3
wcsnlen.3
wcsnrtombs.3
wcswidth.3
rtld-audit.7
    Michael Kerrisk
        SYNOPSIS: Add reference to feature_test_macros(7)
            These pages specify feature test macros in the function
            prototypes. Add a reference to feature_test_macros(7),
            so that readers are pointed to the information that
            feature test macros must be defined before including
            *any* header file.

clock_nanosleep.2
clock_getcpuclockid.3
getnetent_r.3
getprotoent_r.3
getrpcent_r.3
getservent_r.3
sigwait.3
    Michael Kerrisk
        RETURN VALUE: Note that "positive error numbers" are listed in ERRORS

fcntl.2
intro.2
open.2
poll.2
ftw.3
intro.3
matherr.3
system.3
tmpnam.3
unix.7
    Michael Kerrisk
        Note that feature test macros must be defined before *any* includes
            Programmers often make the mistake of including a feature test
            macro only after having already included some header files.
            This patch adds some text at opportune places to remind
            programmers to do things the right way.

index.3
stpcpy.3
strcasecmp.3
strcat.3
strchr.3
strcmp.3
strcoll.3
strcpy.3
strdup.3
strfry.3
strpbrk.3
strsep.3
strspn.3
strstr.3
strtok.3
strxfrm.3
    Michael Kerrisk
        SEE ALSO: Add reference to string(3)
            The idea here is to provide a route to discover other
            string functions.

armscii-8.7
cp1251.7
iso_8859-3.7
iso_8859-5.7
iso_8859-6.7
iso_8859-8.7
iso_8859-10.7
iso_8859-11.7
iso_8859-13.7
iso_8859-14.7
koi8-u.7
    Denis Barbier
        Fix decimal values in encoding tables
            Octal and hexadecimal values are right, but there are some
            off-by one errors in decimal values.  Correct values are
            printed by this command:

              perl -pi -e 'if (s/^([0-7]+)\t([0-9]+)\t([0-9a-fA-F]+)//)
                {printf "%03o\t%d\t%s", hex($3), hex($3), $3;};' man7/*.7


Changes to individual pages
---------------------------

capget.2
    Michael Kerrisk
        SYNOPSIS: Remove unneeded "undef _POSIX_SOURCE"

fcntl.2
    Michael Kerrisk
        Add feature test macro requirements for F_GETOWN and F_SETOWN

fcntl.2
    Michael Kerrisk
        Note feature test macro requirements for F_DUPFD_CLOEXEC

getrlimit.2
    Michael Kerrisk
        Document units for RLIMIT_RTTIME limit
            This limit is in microseconds

            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=596492

lseek.2
    Michael Kerrisk
        Removed note about return type on ancient systems

mount.2
    Michael Kerrisk
        Definitions of various MS_* constants only appeared in glibc 2.12
            See http://sourceware.org/bugzilla/show_bug.cgi?id=11235

stat.2
    Michael Kerrisk
        Update information on nanosecond timestamp fields
            Update feature test macro requirements for exposing these fields.
            Note that these fields are specified in POSIX.1-2008.

timer_create.2
    Michael Kerrisk
        Factor out generic material that was moved to new sigevent(7) page

aio_fsync.3
    Michael Kerrisk
        Add reference to new sigevent(7) page

atanh.3
    Michael Kerrisk
        glibc 2.10 fixed pole error bug
            http://sourceware.org/bugzilla/show_bug.cgi?id=6759
            was resolved.

cerf.3
    Michael Kerrisk
        Make it clearer that this function is unimplemented

cos.3
    Michael Kerrisk
        errno is now correctly set to EDOM on a domain error
            http://sources.redhat.com/bugzilla/show_bug.cgi?id=6780
            was (silently) resolved.

expm1.3
    Michael Kerrisk
        errno is now correctly set to ERANGE on a range error
            http://sources.redhat.com/bugzilla/show_bug.cgi?id=6788
            was (silently) resolved.

fmod.3
    Michael Kerrisk
        errno is now correctly set to EDOM for the x==inf domain error
            http://sources.redhat.com/bugzilla/show_bug.cgi?id=6784
            was (silently) resolved.

insque.3
    Michael Kerrisk
        Noted prev == NULL bug in glibc 2.4 and earlier
            As noted by Remi Denis-Courmont, glibc nowadays allows
            'prev' to be NULL, as required by POSIX for initializing
            a linear list. But in glibc 2.4 and earlier, 'prev' could
            not be NULL. Add a BUGS section noting this.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=551201
    Michael Kerrisk
        Added info on circular lists, and initializing circular lists
    Michael Kerrisk
        Added example program

lgamma.3
    Michael Kerrisk
        glibc 2.10 fixed pole error bug
            http://sourceware.org/bugzilla/show_bug.cgi?id=6777
            was (silently) resolved.

log2.3
    Matthew Flaschen
        log2() function does not conform to C89
            log2(), log2f(), and log2l() do not conform to C89.
            They are defined in C99.  See http://flash-gordon.me.uk/ansi.c.txt
            and http://www.schweikhardt.net/identifiers.html

mq_notify.3
    Michael Kerrisk
        Factor out generic material that was moved to new sigevent(7) page

pow.3
    Michael Kerrisk
        errno is now correctly set to ERANGE on a pole error
            http://sources.redhat.com/bugzilla/show_bug.cgi?id=6776
            was (silently) resolved.

pthread_kill_other_threads_np.3
    Michael Kerrisk
        CONFORMING TO: Note meaning of "_np" suffix

rand.3
    Michael Kerrisk
        Clarify description of range of returned value
    Michael Kerrisk
        Add an example program
    Michael Kerrisk
        Expand description of rand_r()

random.3
    W. Trevor King
        Update initstate() return value description to match glibc

readdir.3
    Michael Kerrisk
        Clarify that "positive error numbers" are listed in ERRORS

rexec.3
    Michael Kerrisk
        SYNOPSIS: Add header file and feature test macro requirements

sigpause.3
    Michael Kerrisk
        Correct discussion of when BSD vs SysV version is used in glibc

sin.3
    Michael Kerrisk
        errno is now correctly set to EDOM on a domain error
            http://sources.redhat.com/bugzilla/show_bug.cgi?id=6781
            was (silently) resolved.

tan.3
    Michael Kerrisk
        errno is now correctly set to EDOM on a domain error
            http://sources.redhat.com/bugzilla/show_bug.cgi?id=6782
            was (silently) resolved.

wcscasecmp.3
wcsncasecmp.3
wcsnlen.3
    Michael Kerrisk
        Added VERSIONS section

boot.7
    Yuri Kozlov
        Update list of major Linux distributions

feature_test_macros.7
    Michael Kerrisk
        Make text on required placement of macros more prominent
            Move the text that notes the requirement that feature test macros
            must be defined before including any header files to the top of
            the page, and highlight the text further, so that the reader will
            not miss this point.

pthreads.7
signal.7
    Michael Kerrisk
        Add SEE ALSO reference to new sigevent(7) page

tcp.7
    Michael Kerrisk
        Clarify header file details for SIOCINQ and SIOCOUTQ
            Also note synonymous FIONREAD and TIOCOUTQ.


==================== Changes in man-pages-3.28 ====================

Released: 2010-10-04, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andries E. Brouwer <Andries.Brouwer@cwi.nl>
Denis Barbier <bouzim@gmail.com>
Jan Kara <jack@suse.cz>
Landijk <landijk-user@yahoo.com>
Lennart Poettering <mzjro@0pointer.net>
Michael Haardt <michael@moria.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Petr Baudis <pasky@suse.cz>
Sam Varshavchik <mrsam@courier-mta.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

getaddrinfo_a.3
    Petr Baudis
        New page documenting getaddrinfo_a()
            The page also documents gai_suspend(), gai_cancel(),
            and gai_error().

aio.7
    Michael Kerrisk
        New page providing an overview of POSIX asynchronous I/O


Newly documented interfaces in existing pages
---------------------------------------------

exec.3
    Michael Kerrisk
        Document execvpe()
            This function was added to glibc in version 2.11.
            Also various other small rewrites in the page.


New and changed links
---------------------

gai_cancel.3
gai_error.3
gai_suspend.3
    Petr Baudis
        New links to new getaddrinfo_a.3 page

error_one_per_line.3
    Michael Kerrisk
         Fix misnamed link file (was error_on_per_line.3)

execvpe.3
    Michael Kerrisk
        New link to exec.3

sigstack.3
    Michael Kerrisk
        New link to sigaltstack.2
            No new programs should use sigstack(3). Point the user to the
            better sigaltstack(2), whose man page briefly mentions sigstack(3).

vlimit.3
    Michael Kerrisk
        New link to getrlimit.2
            No new programs should use vlimit(3). Point the user to the
            better setrlimit(2), whose man page briefly mentions vlimit(3).

vtimes.3
    Michael Kerrisk
        New link to getrusage.2
            No new programs should use vtimes(3). Point the user to the
            better getrusage(2), whose man page briefly mentions vtimes(3).


Global changes
--------------

Various pages
    Michael Kerrisk
        Switch to American usage: "-wards" ==> "-ward"
            American English uses "afterward" in preference to "afterwards",
            and so on

chdir.2
chmod.2
chown.2
gethostname.2
getsid.2
pread.2
setpgid.2
sigaltstack.2
stat.2
truncate.2
wait.2
dirfd.3
getsubopt.3
mkdtemp.3
mkstemp.3
siginterrupt.3
strdup.3
    Michael Kerrisk
        Simplify feature test macro requirements


Changes to individual pages
---------------------------

getrlimit.2
    Michael Kerrisk
        Add mention of the ancient vlimit() function

getrusage.2
    Michael Kerrisk
        Add mention of the ancient vtimes() function

io_cancel.2
io_destroy.2
io_getevents.2
io_setup.2
io_submit.2
    Michael Kerrisk
        SEE ALSO: add aio(7)

sched_setscheduler.2
    Michael Kerrisk
        ERRORS: note that NULL 'param' yields EINVAL

stat.2
    Michael Kerrisk
        Note feature test macro requirements for blkcnt_t and blksize_t

timer_create.2
    Michael Kerrisk
        Standardize on name 'sevp' for sigevent argument

truncate.2
    Michael Kerrisk
        Correct and simplify ftruncate() feature test macro requirements
            The glibc 2.12 feature test macro requirements for ftruncate() are
            buggy; see http://sourceware.org/bugzilla/show_bug.cgi?id=12037.
            Corrected the requirements in the SYNOPSIS, and added a BUGS
            section describing the problem in glibc 2.12.

aio_cancel.3
    Michael Kerrisk
        Add pointer to aio(7) for example program
        Refer the reader to aio(7) for a description of the aiocb structure
        CONFORMING TO: Add POSIX.1-2008; add VERSIONS section

aio_error.3
    Michael Kerrisk
        Wording improvements in RETURN VALUE
        Add pointer to aio(7) for example program
        Refer the reader to aio(7) for a description of the aiocb structure
        CONFORMING TO: Add POSIX.1-2008; add VERSIONS section

aio_fsync.3
    Michael Kerrisk
        Refer the reader to aio(7) for a description of the aiocb structure
        CONFORMING TO: Add POSIX.1-2008; add VERSIONS section

aio_read.3
    Michael Kerrisk
        Various minor rewordings and additions
        Add pointer to sigevent(7) for details of notification of I/O completion
        Add pointer to aio(7) for example program
        Refer the reader to aio(7) for a description of the aiocb structure
        CONFORMING TO: Add POSIX.1-2008; add VERSIONS section

aio_return.3
    Michael Kerrisk
        Improve description in RETURN VALUE
        Add pointer to aio(7) for example program
        Refer the reader to aio(7) for a description of the aiocb structure
        CONFORMING TO: Add POSIX.1-2008; add VERSIONS section

aio_suspend.3
    Michael Kerrisk
        Various additions and rewordings.
            Give some arguments more meaningful names.
            More explicitly describe the 'nitems' argument.
            Explicitly note that return is immediate if an I/O operation
            has already completed.
            Note that aio_error(3) should be used to scan the aiocb list
            after a successful return.
            Add references to other relevant pages.
            Various other pieces rewritten.
        Refer the reader to aio(7) for a description of the aiocb structure
        CONFORMING TO: Add POSIX.1-2008; add VERSIONS section

aio_write.3
    Michael Kerrisk
        Add pointer to sigevent(7) for details of notification of I/O completion
        Various minor rewordings and additions
        Refer the reader to aio(7) for a description of the aiocb structure
        CONFORMING TO: Add POSIX.1-2008; add VERSIONS section

clearenv.3
    Michael Kerrisk
        Fix error in feature test macro requirements

dysize.3
    Michael Kerrisk
        Remove crufty statement about old SCO bug

exec.3
    Michael Kerrisk
        Add feature test macro requirements for execvpe()
        Rewrite description of PATH and mention _CS_PATH
        Note execvp() and execlp() behavior for filename containing a slash

getaddrinfo.3
    Michael Kerrisk
        Add SEE ALSO reference to new getaddrinfo_a.3 page

gethostbyname.3
    Michael Kerrisk
        Fix formatting of feature test macros

getw.3
    Michael Kerrisk
        Fix feature test macros

malloc.3
    Landijk
        Remove editorializing comments on memory overcommitting
            See https://bugzilla.kernel.org/show_bug.cgi?id=19332
    Michael Kerrisk
        Various minor reorganizations and wording fix-ups

mq_notify.3
    Michael Kerrisk
        Standardize on name 'sevp' for sigevent argument

nl_langinfo.3
    Michael Haardt
        Make it clear that nl_langinfo() interacts with setlocale()
        Add an example program

posix_openpt.3
    Michael Kerrisk
        Fix feature test macro requirements

rand.3
    Michael Kerrisk
        Remove duplicate #include in example program

strtok.3
    Petr Baudis
        Add reference to strtok() example in getaddrinfo(3)

inotify.7
    Michael Kerrisk
        Added section noting limitations and caveats of inotify

sigevent.7
    Michael Kerrisk
        Add SEE ALSO reference to new getaddrinfo_a.3 page
        Add SEE ALSO referring to new aio(7) page

suffixes.7
    Michael Kerrisk
        Change explanation of ".rpm" to "RPM software package"


==================== Changes in man-pages-3.29 ====================

Released: 2010-10-19, Detroit


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Balazs Scheidler <bazsi@balabit.hu>
David Prevot <davidp@altern.org>
Denis Barbier <bouzim@gmail.com>
Guillem Jover <guillem@hadrons.org>
Ivana Varekova <varekova@redhat.com>
Lennart Poettering <mzxreary@0pointer.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Sam Varshavchik <mrsam@courier-mta.com>
Simon Paillard <simon.paillard@resel.enst-bretagne.fr>
Stephan Mueller <stephan.mueller@atsec.com>
Thomas Jarosch <thomas.jarosch@intra2net.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

subpage_prot.2
    Michael Kerrisk
        New page documenting the PowerPC-specific subpage_prot(2)

aio_init.3
    Michael Kerrisk
        New page documenting aio_init(3)


Newly documented interfaces in existing pages
---------------------------------------------

posix_fadvise.2
    Michael Kerrisk
        Document the architecture-specific arm_fadvise64_64() system call
            This ARM-specific system call fixes the argument ordering
            for that architecture. Since Linux 2.6.14.

sync_file_range.2
    Michael Kerrisk
        Document the architecture-specific sync_file_range2() system call
            As described in commit edd5cd4a9424f22b0fa08bef5e299d41befd5622,
            the sync_file_range() argument order is broken for some
            architectures (PowerPC, ARM, tile). The remedy was a different
            system call using the right argument order on those architectures.

psignal.3
    Guillem Jover
        Document psiginfo()
            psiginfo() was added to glibc in version 2.10.
    Michael Kerrisk
        Add details, VERSIONS, and BUGS for psiginfo()

ip.7
    Balazs Scheidler
        Document IP_RECVORIGDSTADDR
        Document IP_TRANSPARENT
    Michael Kerrisk
        Document IP_FREEBIND
            Text based on input from Lennart Poettering and Balazs Scheidler.
            See https://bugzilla.kernel.org/show_bug.cgi?id=20082


New and changed links
---------------------

arm_fadvise64_64.2
    Michael Kerrisk
        New link to posix_fadvise.2

arm_sync_file_range.2, sync_file_range2.2
    Michael Kerrisk
        New links to sync_file_range.2

arrm_fadvise.2
    Michael Kerrisk
        New link to posix_fadvise.2

psiginfo.3
    Guillem Jover
        New link to psignal.3


Global changes
--------------

Many pages
    Michael Kerrisk
        global fix: s/Unix/UNIX/
            The man pages were rather inconsistent in the use of "Unix"
            versus "UNIX". Let's go with the trademark usage.

Various pages
    Michael Kerrisk
        Global fix: s/pseudo-terminal/pseudoterminal/

grantpt.3, ptsname.3, unlockpt.3, pts.4
    Michael Kerrisk
        Global fix: s/pty/pseudoterminal/

recv.2, cmsg.3, unix.7
    Michael Kerrisk
        global fix: s/UNIX socket/UNIX domain socket/

fmtmsg.3, gethostbyname.3, termios.3
    Michael Kerrisk
        Global fix: s/Unixware/UnixWare/


Changes to individual pages
---------------------------

inotify_rm_watch.2
    Michael Kerrisk
        SYNOPSIS: fix type of 'wd' argument

posix_fadvise.2
    Michael Kerrisk
        Rewrite VERSIONS, noting that the system call is fadvise64()

syscalls.2
    Michael Kerrisk
        Add the PowerPC-specific subpage_prot() system call
        Add sync_file_range2()

truncate.2
    Michael Kerrisk
        Fix feature test macros

aio_cancel.3
aio_error.3
aio_fsync.3
aio_read.3
aio_return.3
aio_suspend.3
aio_write.3
    Michael Kerrisk
        SEE ALSO: Add lio_listio(3)

gai_cancel.3
gai_error.3
gai_suspend.3
    Michael Kerrisk
        Make these into links
            In the previous release, these files were accidentally made copies
            of getaddrinfo_a.3, instead of being made as link files.

getifaddrs.3
    Thomas Jarosch
        Prevent possible NULL pointer access in example program

malloc.3
    Michael Kerrisk
        Emphasize that malloc() and realloc() do not initialize allocated memory

malloc_hook.3
    Ivana Varekova
        Warn that these functions are deprecated

strcpy.3
    Michael Kerrisk
        Formatting fixes in strncpy() example implementation code

ip.7
    Michael Kerrisk
        Reword NOTES on Linux-specific options

sigevent.7
    Michael Kerrisk
        SEE ALSO: Add aio_read(3), aio_write(3), and lio_listio(3)

unix.7
    Michael Kerrisk
        Document the autobind feature
    Michael Kerrisk
        Fix description of abstract socket names
            As reported by Lennart Poettering:
                The part about "abstract" sockets is misleading as it suggests
                that the sockaddr returned by getsockname() would necessarily
                have the size of sizeof(struct sockaddr), which however is not
                the case: getsockname() returns exactly the sockaddr size that
                was passed in on bind(). In particular, two sockets that are
                bound to the same sockaddr but different sizes are completely
                independent.
            See https://bugzilla.kernel.org/show_bug.cgi?id=19812
    Michael Kerrisk
        Fix description of "pathname" sockets
            As reported by Lennart Poettering:
               The part about "pathname" sockets suggests usage of
               sizeof(sa_family_t) + strlen(sun_path) + 1
               for calculating the sockaddr size. Due to alignment/padding
               this is probably not a good idea. Instead, one should use
               offsetof(struct sockaddr_un, sun_path) + strlen() + 1
               or something like that.
            See https://bugzilla.kernel.org/show_bug.cgi?id=19812


==================== Changes in man-pages-3.30 ====================

Released: 2010-11-01, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
Bernhard Walle <bernhard@bwalle.de>
David Prevot <davidp@altern.org>
Eric W. Biederman <ebiederm@xmission.com>
Florian Lehmann <flo.lehmann@googlemail.com>
Jan Engelhardt <jengelh@medozas.de>
Lucian Adrian Grijincu <lucian.grijincu@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Paul Mackerras <paulus@samba.org>
Pádraig Brady <P@draigbrady.com>
Reuben Thomas <rrt@sc3d.org>
scarlettsp <scarlettsp@gmail.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

kexec_load.2
    Andi Kleen
        New page documenting kexec_load(2)
    Michael Kerrisk
        Add license
    Michael Kerrisk
        Incorporate fixes from Eric W. Biederman
            Eric noted that a few instances of "virtual" should
            be "physical" and noted:

                There is an expectation that at hand off from sys_kexec that
                virtual and physical addresses will be identity mapped. But
                this isn't the old Alpha booting convention where you have
                a virtual address and then you have to parse the page table
                to figure out where your kernel was actually loaded.
    Michael Kerrisk
        Additions and edits by mtk
            Various wording and layout improvements.
            Fixed the name of a constant: s/KEXEC_ARCH_I386/KEXEC_ARCH_386/.
            Added RETURN VALUE and ERRORS sections.
            Added VERSIONS section
            Note that CONFIG_KEXEC is needed
            Removed details of using syscall; the reader can find them in
            syscall(2).
            Added some details for KEXEC_PRESERVE_CONTEXT.
            Revised the text mentioning the kernel header, since it is
            not yet exported, and it's not certain that it will be.

lio_listio.3
    Michael Kerrisk
        New page documenting lio_listio(3)


Newly documented interfaces in existing pages
---------------------------------------------

reboot.2
    Andi Kleen
        Document LINUX_REBOOT_KEXEC
            Some fix-ups by Michael Kerrisk
    Michael Kerrisk
        Place 'cmd' values in alphabetical order.

unshare.2
    Michael Kerrisk
        Document CLONE_NEWIPC
    Michael Kerrisk
        Document CLONE_NEWNET
    Lucian Adrian Grijincu
        Improve description of CLONE_NEWNET
            CLONE_NEWNET creates a new network namespace from scratch.
            You don't have anything from the old network namespace in
            the new one. Even the loopback device is new.
    Michael Kerrisk
        Document CLONE_SYSVSEM
    Michael Kerrisk
        Document CLONE_NEWUTS
    Michael Kerrisk
        Relocate discussion of CAP_SYS_ADMIN to CLONE_NEWNS section
            And rewrite the EPERM description to be more general in
            preparation for the new flags to be documented.


Global changes
--------------

Various pages
    Michael Kerrisk
        Add reference to feature_test_macros(7)
            Some pages simply list feature test macro requirements in
            the form:

                #define #GNU_SOURCE
                #include <someheader.h>

            For these pages, add a "See feature_test_macros(7)" comment
            on the "#define" line.

Various pages
    Michael Kerrisk
        SEE ALSO: Remove redundant reference to feature_test_macros(7)

Various pages
    David Prevot
        Use greater consistency in NAME line
        (Remove definite article at start of descriptive clause.)

Various pages
    Michael Kerrisk
        SEE ALSO: Place entries in correct order

Various pages
    Michael Kerrisk
        ERRORS: Place entries in correct order

Various pages
    Michael Kerrisk
        Add section number to references to functions documented in other pages

Various pages
    Michael Kerrisk
        Remove redundant section number in page references
            Remove section number in function references that are for
            functions documented on this page.

armscii-8.7
iso_8859-3.7
iso_8859-4.7
iso_8859-5.7
iso_8859-6.7
iso_8859-10.7
iso_8859-11.7
iso_8859-13.7
iso_8859-14.7
koi8-u.7
    David Prevot
        Capitalize hexadecimal numbers


Changes to individual pages
---------------------------

access.2
    Michael Kerrisk
        Note use of faccessat(2) for checking symbolic link permissions
    Michael Kerrisk
        Give an example of a safer alternative to using access()

clone.2
    Michael Kerrisk
        Clarify when CLONE_NEWNET implementation was completed

faccessat.2
    Michael Kerrisk
        Note that faccessat() is racy

fcntl.2
    Michael Kerrisk
        RETURN VALUE: Improve description of F_GETFD and F_GETFL

inotify_add_watch.2
    Michael Kerrisk
        Document ENOENT error

mlock.2
    Michael Kerrisk
        Improve wording describing /proc/PID/status /VmLck field
    Michael Kerrisk
        shmctl() SHM_LOCKed memory is not included in VmLck

reboot.2
    Michael Kerrisk
        Place 'cmd' values in alphabetical order

subpage_prot.2
    Michael Kerrisk
        Change 1-line page description
    Michael Kerrisk
        Improvements after review by Paul Mackerras

timer_settime.3
    Michael Kerrisk
        Remove redundant SEE ALSO reference

euidaccess.3
    Michael Kerrisk
        Note the use of faccessat(2) to operate on symbolic links
    Michael Kerrisk
        Note that the use of euidaccess() is racy

fenv.3
    Michael Kerrisk
        Clarify wording relating to glibc version

getgrent.3
getgrent_r.3
getgrnam.3
    Michael Kerrisk
        Refer reader for group(5) for more info on group structure

getopt.3
    Bernhard Walle
        Use constants in getopt_long() example
            The description of getopt_long() mentions the constants
            required_argument, no_argument and optional_argument.
            Use them in the example to make the code easier to understand.

getpw.3
    Michael Kerrisk
        Change comment describing pw_gecos

getpw.3
getpwent.3
getpwent_r.3
    Michael Kerrisk
        Refer reader to passwd(5) for more info on the passwd structure

getpwent.3
getpwnam.3
    Michael Kerrisk
        Note that pw_gecos is not in POSIX
            And change the comment describing this field

getpwent_r.3
    Michael Kerrisk
        Change comment describing pw_gecos

getpwnam.3
    Michael Kerrisk
        Some rewording and restructuring

sched_getcpu.3
    Michael Kerrisk
        Fix feature test macro requirements

strnlen.3
    Michael Kerrisk
        Fix feature test macro requirements

group.5
    Michael Kerrisk
        Various minor rewordings

hosts.5
protocols.5
spufs.7
termio.7
    David Prevot
        Remove definite article from NAME section
            Please find inline another tiny patch in order to shrink
            the definite article from some other pages (found with
            "rgrep -i ' \\\- the' man*").

passwd.5
    Michael Kerrisk
        Various minor rewordings

proc.5
    Michael Kerrisk
        Add reference to mlock(2) for further info on /proc/PID/status VmLck

armscii-8.7
    David Prevot
        Write the character set name as ArmSCII

cp1251.7
    David Prevot
        Capitalize hexadecimal numbers

ip.7
    David Prevot
        Fix name of socket option: s/IP_TTL/IP_TRANSPARENT/
    David Prevot
        Place socket options in alphabetical order

koi8-r.7
    David Prevot
        Fix special character names
            Comparing to koi8-u.7, I noticed some inconsistencies in special
            character names. After checking with the following Unicode related
            pages, please find inline (and gzipped attached, hopefully not
            messing with encoding), a patch in order to make it right, on an
            Unicode point of view.

            http://www.unicode.org/charts/PDF/U2500.pdf
            http://www.unicode.org/charts/PDF/U25A0.pdf
            http://www.unicode.org/charts/PDF/U0080.pdf
            http://www.unicode.org/charts/PDF/U1D400.pdf
    David Prevot
        Fix SEE ALSO reference and letter names
            The koi8-r(7) (Russian Net Character Set) manual page refers
            to iso-8859-7(7) manual page, which is the Latin/Greek one.
            I guess it should refer instead to the iso-8859-5(7)
            (Latin/Cyrillic) one. This is addressed at the end of the patch.

            It has also been spotted that letter names are different in
            this manual page and in the Unicode related page [0], the
            first part of the page address this.

                    0: http://www.unicode.org/charts/PDF/U0400.pdf

man-pages.7
    Michael Kerrisk
        Update example
            The old example used the chmod(2) man page, but the
            feature test macro requirements on that page had changed.
            Update to use an example from a different page (acct(2),
            whose feature test macro requirements are probably unlikely
            to change in the future).


==================== Changes in man-pages-3.31 ====================

Released: 2010-11-12, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
David Prevot <davidp@altern.org>
Denis Barbier <bouzim@gmail.com>
Krzysztof Żelechowski <giecrilj@stegny.2a.pl>
Michael Kerrisk <mtk.manpages@gmail.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


Newly documented interfaces in existing pages
---------------------------------------------

getrlimit.2
    Michael Kerrisk
        Added documentation of prlimit()
            prlimit() is new in kernel 2.6.36.

inotify.7
    Michael Kerrisk
        Document IN_EXCL_UNLINK
            This flag was added in Linux 2.6.36.
            See kernel commit 8c1934c8d70b22ca8333b216aec6c7d09fdbd6a6.


New and changed links
---------------------

prlimit.2
    Michael Kerrisk
        New link to getrlimit.2


Changes to individual pages
---------------------------

getrlimit.2
    Michael Kerrisk
        Remove unneeded text in DESCRIPTION

intro.2
    Michael Kerrisk
        Added various pages to SEE ALSO

kexec_load.2
    Michael Kerrisk
        Add kernel version where KEXEC_PRESERVE_CONTEXT first appeared
        Added kernel version number where KEXEC_ON_CRASH first appeared
        Fix copyright
            Make copyright in the name of Intel corporation
        VERSIONS: Fix version number
            kexec_load() was first implemented in 2.6.13, though the entry
            in the system call table was reserved starting in 2.6.7.

migrate_pages.2
    Michael Kerrisk
        SEE ALSO: Add reference to Documentation/vm/page_migration

sched_setaffinity.2
    Michael Kerrisk
        Add missing word "real" to "user ID"

syscalls.2
    Michael Kerrisk
        Fix kernel version number for kexec_load
            kexec_load() was first implemented in 2.6.13, though the entry
            in the system call table was reserved starting in 2.6.7.
    Michael Kerrisk
        Add prlimit() to list

intro.3
    Michael Kerrisk
        Added various pages to SEE ALSO

printf.3
    Michael Kerrisk
        Formatting fixes in example code

hostname.7
    Michael Kerrisk
        Small improvement to description of domains
            See: https://bugzilla.novell.com/show_bug.cgi?id=651900


==================== Changes in man-pages-3.32 ====================

Released: 2010-12-03, Munich


Contributors
------------

The following people contributed notes, ideas, or patches that have
been incorporated in changes in this release:

A. Costa <agcosta@gis.net>
Denis Barbier <bouzim@gmail.com>
Emil Mikulic <emikulic@gmail.com>
Eugene Kapun <abacabadabacaba@gmail.com>
Hugh Dickins <hughd@google.com>
Ivana Hutarova Varekova <varekova@redhat.com>
Joern Heissler <kernelbugs@joern.heissler.de>
Lars Wirzenius <liw@liw.fi>
Martin Eberhard Schauer <Martin.E.Schauer@gmx.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Petr Uzel <petr.uzel@suse.cz>
Roger Pate <roger@qxxy.com>
Török Edwin <edwintorok@gmail.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

pthread_sigqueue.3
    Michael Kerrisk
        New page documenting pthread_sigqueue()
            pthread_sigqueue() is new in glibc 2.11 (requires a kernel with
            rt_tgsigqueinfo(), added in Linux 2.6.31).


Newly documented interfaces in existing pages
---------------------------------------------

readv.2
    Michael Kerrisk
        Add documentation of preadv() and pwritev()
            The preadv() and pwritev() system calls were added in
            Linux 2.6.30.


New and changed links
---------------------

preadv.2
    Michael Kerrisk
        New link to readv.2

pwritev.2
    Michael Kerrisk
        New link to readv.2


Changes to individual pages
---------------------------

chdir.2
    Michael Kerrisk
        Remove redundant and incorrect info on FTMs from NOTES

chown.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

clock_nanosleep.2
    Michael Kerrisk
        Clarify that clock_nanosleep() suspends the calling *thread*

epoll_create.2
    Michael Kerrisk
        Note that 'size' argument must be greater than 0
            See https://bugzilla.kernel.org/show_bug.cgi?id=23872
    Michael Kerrisk
        Added VERSIONS section

epoll_ctl.2
    Michael Kerrisk
        Added VERSIONS section

epoll_wait.2
    Michael Kerrisk
        Updated VERSIONS section

fcntl.2
    Michael Kerrisk
        Add notes on fcntl64()

fstatat.2
    Michael Kerrisk
        Add NOTES on fstatat64(), the name of the underlying system call

getdents.2
    Michael Kerrisk
        Added notes on getdents64()

getgid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

getgroups.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

getpagesize.2
    Michael Kerrisk
        Improve description of getpagesize()
            Improve description of getpagesize() and relocate discussion
            of sysconf(_SC_PAGESIZE).

            In part inspired by
            http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=537272

getresuid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

getrlimit.2
    Michael Kerrisk
        Add example program for prlimit()

getuid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

open.2
    Ivana Hutarova Varekova
        O_EXCL can be used without O_CREAT for block devices
            Since Linux 2.6 there is a possibility to use O_EXCL without
            O_CREAT. See patch: http://lkml.org/lkml/2003/8/10/221.

pread.2
    Michael Kerrisk
        Add notes on pread64() and pwrite64()
            See https://bugzilla.kernel.org/show_bug.cgi?id=23072
    Michael Kerrisk
        SEE ALSO: add readv(3)

readv.2
    Michael Kerrisk
        Wording fix: readv() and writev() are system calls, not functions

sendfile.2
    Michael Kerrisk
        Add notes on sendfile64()

setfsgid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

setfsuid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

setgid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

setresuid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

setreuid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

setuid.2
    Michael Kerrisk
        Add NOTES explaining 32-bit system calls added in Linux 2.4

sigqueue.2
pthreads.7
signal.7
    Michael Kerrisk
        SEE ALSO: Add pthread_sigqueue(3)

stat.2
    Michael Kerrisk
        Fix EOVERFLOW error description
            2<<31 should read 1<<31 (which equals 2^31).

statfs.2
    Michael Kerrisk
        Add notes on statfs64() and fstatfs64()

swapon.2
    Hugh Dickins
        Document SWAP_FLAG_DISCARD and discarding of swap pages

truncate.2
    Michael Kerrisk
        Add notes on truncate64() and ftruncate64()

memcpy.3
    Michael Kerrisk
        Change "should not overlap" to "must not overlap"
            glibc 2.12 changed things so that applications that use memcpy() on
            overlapping regions will encounter problems. (The standards have
            long said that the behaviors is undefined if the memory areas
            overlap.)

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=603144
            In reference of http://lwn.net/Articles/414467/
            and http://article.gmane.org/gmane.comp.lib.glibc.alpha/15278

usleep.3
    Petr Uzel
        usleep() suspends calling thread, not process

core.5
    Michael Kerrisk
        Change single quote to double quote in shell session example
            The example section has a sample shell session containing:

            echo '|$PWD/core_pattern_pipe_test %p UID=%u GID=%g sig=%s'

            But $PWD won't be expanded in single quotes. It should be double
            quotes around the entire argument or some other form.

pthreads.7
    Michael Kerrisk
        Added description of async-cancel-safe functions

unix.7
    Michael Kerrisk
        Reworded the text of various errors
    Michael Kerrisk
        Added ENOENT error


==================== Changes in man-pages-3.33 ====================

Released: 2011-09-16, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes and ideas that have been
incorporated in changes in this release:

Akira Fujita <a-fujita@rs.jp.nec.com>
Alexander Schuch <Alex.Schuch@gmx.de>
Andries Brouwer <Andries.Brouwer@cwi.nl>
Brian M. Carlson <sandals@crustytoothpaste.net>
Dan Jacobson <jidanni@jidanni.org>
Folkert van Heusden <folkert.mobiel@gmail.com>
Graham Gower <graham.gower@gmail.com>
Hendrik Jan Thomassen <hjt@atcomputing.nl>
Jan Engelhardt <jengelh@medozas.de>
Joey Adams <joeyadams3.14159@gmail.com>
Johannes Laire <johannes@laire.fi>
Jon Grant <jg@jguk.org>
Josh Triplett <josh@joshtriplett.org>
Konstantin Ritt <ritt.ks@gmail.com>
Luis Javier Merino <ninjalj@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Mikel Ward <mikel@mikelward.com>
Nick Black <dankamongmen@gmail.com>
Paul Evans <leonerd@leonerd.org.uk>
Petr Pisar <ppisar@redhat.com>
Przemyslaw Pawelczyk <przemyslaw@pawelczyk.it>
Regid Ichira <regid23@yahoo.com>
Reuben Thomas <rrt@sc3d.org>
Richard B. Kreckel <kreckel@ginac.de>
Ryan Mullen <rmmullen@gmail.com>
Sebastian Geiger <sbastig@gmx.net>
Sebastian Unger <sebunger@gmx.net>
Seonghun Lim <wariua@gmail.com>
Serge E. Hallyn <serge.hallyn@canonical.com>
Simon Cross <hodgestar@gmail.com>
Simon Paillard <spaillard@debian.org>
Stan Sieler <sieler@me.com>
Timmy Lee <scuttimmy@gmail.com>
Tolga Dalman <tolga.dalman@googlemail.com>
Tomislav Jonjic <jonjic@cs.unibo.it>
Yuri Kozlov <yuray@komyakino.ru>
Wei Luosheng <weiluosheng001@gmail.com>

Apologies if I missed anyone!


Newly documented interfaces in existing pages
---------------------------------------------

sync.2
    Michael Kerrisk
        Added new syncfs() system call
            syncfs() was added in Linux 2.6.39.


New and changed links
---------------------

syncfs.2
    Michael Kerrisk
        New link for sync(2).


Global changes
--------------

Various pages
    Simon Paillard
        Global fix:  properly escape minus sign


Changes to individual pages
---------------------------

clone.2
    Michael Kerrisk
        Note that CLONE_STOPPED was removed in 2.6.38

execve.2
    Michael Kerrisk  [Sebastian Geiger]
        Note that the first argv[] value should contain name of executable

fcntl.2
    Michael Kerrisk  [Reuben Thomas]
        Note that F_GETFL also retrieves file access mode

getrlimit.2
    Michael Kerrisk  [Ryan Mullen]
        Remove mention of kernel versions in discussion of RLIMIT_CPU
    Michael Kerrisk  [Seonghun Lim]
        Fix example program and add _FILE_OFFSET_BITS requirement

mlock.2
    Michael Kerrisk  [Brian M. Carlson]
        Clarify EINVAL error
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?625747
    Michael Kerrisk  [Seonghun Lim]
        Simplify and correct text for EPERM error

mprotect.2
    Seonghun Lim
        Fix off-by-one error in a memory range
    Seonghun Lim
        Fix small bug in example program
            The description of the example program says that it makes the
            third page "read-only". Thus use PROT_READ instead of PROT_NONE.

open.2
    Folkert van Heusden
        Remove text describing O_CLOEXEC as Linux-specific
            O_CLOEXEC is specified in POSIX.1-2008, as noted
            elsewhere in the page.

readlink.2
    Michael Kerrisk  [Dan Jacobson]
        SEE ALSO: Add readlink(1)

sendfile.2
    Akira Fujita
        Since 2.6.33, 'out_fd' can refer to any file type
            Linux kernel commit cc56f7de7f00d188c7c4da1e9861581853b9e92f
            meant sendfile(2) can work with any output file.
    Michael Kerrisk
        Shift text on falling back to read()/write() to NOTES
    Michael Kerrisk  [Tolga Dalman]
        Remove mention of kernel version for 'in_fd' argument
    Tolga Dalman
        Add an explicit reference to splice(2)
            Unlike sendfile(), splice() can transfer data
            between a pair of sockets.

sigaction.2
    Michael Kerrisk  [Tolga Dalman]
        Add a little info about ucontext_t

stat.2
    Michael Kerrisk  [Jon Grant]
        Small rewording of ENAMETOOLONG error

sync.2
    Michael Kerrisk
        Some rewrites to description of sync()

syscalls.2
    Michael Kerrisk
        Added fanotify_init() and fanotify_mark() to syscall list
    Michael Kerrisk
        Added new 2.6.39 system calls
    Michael Kerrisk
        Updated for Linux 3.0 system calls
    Michael Kerrisk
        Update kernel version at head of syscall list
    Michael Kerrisk
        Update to mention 3.x kernel series

syslog.2
    Michael Kerrisk  [Serge E. Hallyn]
        Update for kernel 2.6.37 changes
            Document /proc/sys/kernel/dmesg_restrict.
            Document CAP_SYSLOG.

time.2
    Michael Kerrisk  [Alexander Schuch]
        NOTES: Fix description of "Seconds since the Epoch"

timerfd_create.2
    Michael Kerrisk  [Josh Triplett]
        Note behavior when timerfd_settime() old_value is NULL
        See http://bugs.debian.org/cgi-bin/bugreport.cgi?641513
    Tomislav Jonjic
        Fix small error in description of timerfd_settime()

truncate.2
    Seonghun Lim
        Remove redundant EINTR description

unlink.2
    Hendrik Jan Thomassen
        Improve EBUSY description

cacos.3
cacosh.3
catan.3
catanh.3
    Michael Kerrisk  [Richard B. Kreckel, Andries Brouwer]
        Fix formula describing function
            The man pages for cacos(), cacosh(), catan(), catanh()
            contain incorrect formulae describing the functions.

cacos.3
    Michael Kerrisk
        Add example program

cacosh.3
    Michael Kerrisk
        Add example program

cacosh.3
casinh.3
catan.3
catanh.3
    Michael Kerrisk
        SEE ALSO: Add reference to inverse function

catan.3
    Michael Kerrisk
        Add example program

catanh.3
    Michael Kerrisk
        Add example program

ccos.3
ccosh.3
csin.3
csinh.3
ctan.3
ctanh.3
    Michael Kerrisk
        SEE ALSO Add reference to "arc" inverse function

cexp.3
    Michael Kerrisk
        SEE ALSO: add cexp(3)

clog.3
    Michael Kerrisk
        SEE ALSO: Add reference to clog(2)

crypt.3
    Michael Kerrisk  [Jan Engelhardt]
        Fix header file and feature test macro requirements for crypt_r()

err.3
    Seonghun Lim
        Clean up description of error message source
            In the second paragraph of DESCRIPTION section, one of the
            sources of error messages is incorrect: the four functions obtain
            error message only from errno, and "a code" is just relevant
            with errc() and warnc(), which are not present on Linux.
            see http://www.unix.com/man-page/freebsd/3/ERR/ .

            Then, the third paragraph becomes a duplicate.

fflush.3
    Regid Ichira
        Fix wording error
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?614021

hsearch.3
    Seonghun Lim
        Update ERRORS section
            EINVAL can occur for hdestroy_r().
            EINVAL can't occur for hcreate().
            Other minor fixes.

lockf.3
    Michael Kerrisk  [Mikel Ward]
        ERRORS: EBADF can also occur for nonwritable file descriptor
            As noted in the DESCRIPTION, the file descriptor must be writable
            in order to place a lock.

malloc.3
    Seonghun Lim
        Reorder prototypes in SYNOPSIS
            calloc() comes before realloc() in the other sections,
            so should do in SYNOPSIS, too.

mbstowcs.3
    Michael Kerrisk
        SEE ALSO: add reference to wcstombs(3)

memcmp.3
    Michael Kerrisk  [Sebastian Unger]
        Clarify that comparison interprets bytes as "unsigned char"

realpath.3
    Michael Kerrisk  [Seonghun Lim]
        Fix EINVAL error
            Since glibc 2.3, resolved_path can be non-NULL (with the
            semantics already documented in the page).

scandir(3)
    Mike Frysinger
        Add ENOENT/ENOTDIR errors

siginterrupt.3
    Michael Kerrisk  [Luis Javier Merino]
        Remove misleading sentence about signal(2) and system call interruption

strlen.3
    Michael Kerrisk  [Jon Grant]
        SEE ALSO: Add strnlen(3)

strnlen.3
    Michael Kerrisk  [Jon Grant]
        CONFORMING TO: Note that strnlen() is in POSIX.1-2008

strtoul.3
    Michael Kerrisk  [Tolga Dalman]
        Fix NOTES section constants

termios.3
    Michael Kerrisk
        Use "terminal special characters" consistently throughout page
    Michael Kerrisk  [Paul Evans]
        Add documentation of _POSIX_VDISABLE
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=627841
    Michael Kerrisk
        Add a description of STATUS character
    Michael Kerrisk
        Added description of SWTCH character
    Michael Kerrisk
        Add names of terminal special characters
    Michael Kerrisk
        List terminal special characters in alphabetical order

wcstombs.3
    Michael Kerrisk
        SEE ALSO: add mbstowcs(3)

console_codes.4
    Petr Pisar
        Add ESC [ 3 J
            Linux 3.0 (commit f8df13e0a901fe55631fed66562369b4dba40f8b)
            implements \E[3J to allow scrambling content of console
            including scroll-back buffer
            (http://thread.gmane.org/gmane.linux.kernel/1125792).

proc.5
    Michael Kerrisk  [Stan Sieler]
        Add description of 'PPid' field of /proc/PID/status
    Michael Kerrisk  [Stan Sieler]
        Add description of 'SigQ' field of /proc/PID/status

capabilities.7
    Michael Kerrisk  [Serge E. Hallyn]
        Document CAP_SYSLOG and related changes in Linux 2.6.37
    Michael Kerrisk
        File capabilities are no longer optional
            Starting with Linux 2.6.33, the CONFIG_SECURITY_FILE_CAPABILITIES
            has been removed, and file capabilities are always part of the
            kernel.

complex.7
    Michael Kerrisk
        Updated SEE ALSO list to include all complex math functions

ipv6.7
    Michael Kerrisk  [Simon Cross]
        Fix description of address notation: "8 4-digit hexadecimal numbers"

signal.7
    Seonghun Lim
        Remove crufty repeated info about LinuxThreads

unix.7
    Michael Kerrisk
        Add pointer to cmsg(3) for an example of the use of SCM_RIGHTS


==================== Changes in man-pages-3.34 ====================

Released: 2011-09-23, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes and ideas that have been
incorporated in changes in this release:

Alan Curry <pacman@kosh.dhis.org>
Benjamin Poirier <benjamin.poirier@gmail.com>
Brian M. Carlson <sandals@crustytoothpaste.net>
David Howells <dhowells@redhat.com>
David Prévot <taffit@debian.org>
Denis Barbier <bouzim@gmail.com>
Doug Goldstein <cardoe@cardoe.com>
Eric Blake <eblake@redhat.com>
Guillem Jover <guillem@hadrons.org>
Jon Grant <jg@jguk.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Neil Horman <nhorman@tuxdriver.com>
Paul Pluzhnikov <ppluzhnikov@google.com>
Reuben Thomas <rrt@sc3d.org>
Stefan Puiu <stefan.puiu@gmail.com>
Stephan Mueller <stephan.mueller@atsec.com>
Stephen Cameron <scameron@beardog.cce.hp.com>
Sunil Mushran <sunil.mushran@oracle.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

rt_sigqueueinfo.2
    Michael Kerrisk  [Stephan Mueller]
        New page for rt_sigqueueinfo(2) and rt_tgsigqueueinfo(2)
            This replaces the previous '.so' man page link file for
            rt_sigqueueinfo.2, which linked to this sigqueue() man page.

cciss.4
    Stephen M. Cameron
        New man page for cciss driver
            I obtained the information in this man page as a consequence
            of having worked on the cciss driver for the past several years,
            and having written considerable portions of it.
    Michael Kerrisk
        Copyedit by mtk

hpsa.4
    Stephen M. Cameron
        New man page for the hpsa driver
            I obtained the information in this man page as a consequence
            of being the main author of the hpsa driver.
    Michael Kerrisk
        Copyedits my mtk


Newly documented interfaces in existing pages
---------------------------------------------

fstatat.2
    Michael Kerrisk  [David Howells]
        Document AT_NO_AUTOMOUNT
	    This flag was added in Linux 2.6.38.

lseek.2
    Michael Kerrisk  [Eric Blake, Sunil Mushran]
        Document SEEK_HOLE and SEEK_DATA
            These flags, designed for discovering holes in a file,
            were added in Linux 3.1. Included comments from Eric
            Blake and Sunil Mushran.

madvise.2
    Doug Goldstein
        Add MADV_HUGEPAGE and MADV_NOHUGEPAGE
            Document the MADV_HUGEPAGE and MADV_NOHUGEPAGE flags added to
            madvise() in Linux 2.6.38.


New and changed links
---------------------

rt_tgsigqueueinfo.2
    Michael Kerrisk
        New link to new rt_sigqueueinfo.2 page

sigqueue.2
    Michael Kerrisk
        Create link to page that was relocated to section 3


Global changes
--------------

Various pages
    Michael Kerrisk
        Change reference to "sigqueue(2)" to "sigqueue(3)"


Changes to individual pages
---------------------------

fallocate.2
    Michael Kerrisk
        ERRORS: Add EPERM and ESPIPE errors

lseek.2
    Michael Kerrisk  [Alan Curry, Reuben Thomas]
        Remove suspect note about 'whence' being incorrect English

prctl.2
    Paul Pluzhnikov
        PR_SET_DUMPABLE makes process non-ptrace-attachable

readlink.2
    Guillem Jover
        Document using st_size to allocate the buffer
    Michael Kerrisk
        Added copyright text + changelog note for Guillem Jover's patch

sched_setscheduler.2
    Michael Kerrisk
        Document 2.6.39 changes to rules governing changes from SCHED_IDLE policy
            Since Linux 2.6.39, unprivileged processes under the
            SCHED_IDLE policy can switch to another nonrealtime
            policy if their nice value falls within the range
            permitted by their RLIMIT_NICE limit.

tkill.2
    Michael Kerrisk
        SEE ALSO: Add rt_sigqueueinfo (2)

btowc.3, wctob.3
    Michael Kerrisk  [Brian M. Carlson]
        Add pointers to better, thread-safe alternative functions
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=606899

fwide.3
    Michael Kerrisk
        Add _ISOC95_SOURCE to feature test macro requirements
            Since glibc 2.12, _ISOC95_SOURCE can also be used to expose
            prototype of this function.

index.3
    Michael Kerrisk  [Jon Grant]
        Fix text mentioning terminating null

pthread_sigqueue.3
    Michael Kerrisk
        Replace explicit mention of rt_tgsigqueueinfo() with SEE ALSO reference

sigqueue.3
    Michael Kerrisk
        Move this page to section 3
            Now that the underlying system call rt_sigqueueinfo(2) is
            properly documented, move sigqueue() to Section 3, since
            it is really a library function.
    Michael Kerrisk
        Update text in line with existence of new rt_sigqueueinfo.2 page

wcsnlen.3
    Jon Grant
        Improve description of 'maxlen' argument
            It's worth clarifying 'maxlen' is in wide-char units, not bytes.

wprintf.3
    Michael Kerrisk
        Add _ISOC95_SOURCE to feature test macro requirements
            Since glibc 2.12, _ISOC95_SOURCE can also be used to expose
            prototype of these functions.

feature_test_macros.7
    Michael Kerrisk
        Document _ISOC95_SOURCE
            _ISOC95_SOURCE was added in glibc 2.12 as a means
            to expose C90 Amendment 1 definitions.

ip.7
    Benjamin Poirier  [Neil Horman]
        Improve description of IP_MTU_DISCOVER

signal.7
    Michael Kerrisk
        SEE ALSO: Add rt_sigqueueinfo(2)


==================== Changes in man-pages-3.35 ====================

Released: 2011-10-04, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes and ideas that have been
incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
David Prévot <taffit@debian.org>
Denis Barbier <bouzim@gmail.com>
Eric W. Biederman <ebiederm@xmission.com>
Guillem Jover <guillem@hadrons.org>
Jon Grant <jg@jguk.org>
Kevin Lyda <kevin@ie.suberic.net>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Reuben Thomas <rrt@sc3d.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

recvmmsg.2
    Andi Kleen, Michael Kerrisk
        New man page for recvmmsg(2)

setns.2
    Eric W. Biederman
        New manual page for setns(2)
    Michael Kerrisk
        Various improvements


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix: remove spaces around em-dash
            Normal English typographical convention is not to have
            spaces around em dashes.

Various pages
    Michael Kerrisk
        Global fix: s/null pointer/NULL pointer/

Various pages
    Michael Kerrisk
        Global fix: use ORing
            Use "ORing", not "OR'ing", nor an italic ".IR OR ing".

Various pages
    Michael Kerrisk
        Global fix: consistent use of "null wide character"
            Bring more consistency to the discussion of
            "[terminating] null wide character"
            by writing (at least in the initial use in a page)
            "[terminating] null wide character (L'\0')".

Various pages
    Michael Kerrisk
        Global fix: consistent use of "null byte"
            Bring more consistency to the discussion of
            "[terminating] null byte"
            by writing (at least in the initial use in a page)
            "[terminating] null byte ('\0')".

mount.2, prctl.2
    Michael Kerrisk
        s/task/thread/ for consistency with other pages


Changes to individual pages
---------------------------

lseek.2
    Guillem Jover
        CONFORMING TO: Note other systems that have SEEK_HOLE+SEEK_DATA

recv.2
    Michael Kerrisk
        Add mention of recvmmsg(2)

recvmmsg.2
    Michael Kerrisk
        SEE ALSO: add sendmmsg(2)

send.2
    Michael Kerrisk
        CONFORMING TO: POSIX.1-2008 adds MSG_NOSIGNAL

sigwaitinfo.2
    Michael Kerrisk
        Note that attempts to wait for SIGKILL and SIGSTOP are silently ignored

stat.2
    Michael Kerrisk
        Note POSIX.1-2001 and POSIX.1-2008 requirements for lstat()
    Michael Kerrisk
        Regarding automounter action, add a reference to fstatat(2)
    Michael Kerrisk
        Clean up text describing which POSIX describes S_IF* constants

aio_cancel.3
    Michael Kerrisk  [Jon Grant]
        Clarify meaning of "return status" and "error status"

gets.3
    Michael Kerrisk
        POSIX.1-2008 marks gets() obsolescent
            The page formerly erroneously stated that POSIX.1-2008
            removed the specification of this function.

mbsnrtowcs.3
    Michael Kerrisk
        CONFORMING TO: Add POSIX.1-2008
            This function is specified in the POSIX.1-2008 revision.

regex.3
    Michael Kerrisk  [Reuben Thomas]
        Change "terminating null" to "terminating null byte"

stpcpy.3
stpncpy.3
    Mike Frysinger
        Note that these functions are in POSIX.1-2008
            Update the "CONFORMING TO" sections of these functions to
            note that they are now part of the POSIX.1-2008 standard.

stpncpy.3
    Michael Kerrisk
        Change "terminating null" to "terminating null byte"

strcpy.3
    Mike Frysinger
        SEE ALSO: Add stpncpy(3)

strdup.3
    Michael Kerrisk
        CONFORMING TO: strndup() is in POSIX.1-2008

wcpcpy.3
wcpncpy.3
wcsnlen.3
wcsnrtombs.3
    Michael Kerrisk
        CONFORMING TO: Add POSIX.1-2008
            These functions are specified in the POSIX.1-2008 revision.

proc.5
    Eric W. Biederman
        Document /proc/[pid]/ns/
    Michael Kerrisk
        Some edit's to Eric Biederman's /proc/[pid]/ns/ additions

capabilities.7
    Michael Kerrisk
        List setns(2) as an operation allowed by CAP_SYS_ADMIN


==================== Changes in man-pages-3.36 ====================

Released: 2012-02-27, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes and ideas that have been
incorporated in changes in this release:

Alain Benedetti <alainb06@free.fr>
carado <carado@savhon.org>
Christoph Hellwig <hch@lst.de>
Clemens Ladisch <clemens@ladisch.de>
David Prévot <taffit@debian.org>
Elie De Brauwer <eliedebrauwer@gmail.com>
Guillem Jover <guillem@hadrons.org>
Jessica McKellar <jesstess@mit.edu>
Josef Bacik <josef@redhat.com>
Junjiro Okajima <jro@mx3.ttcn.ne.jp>
Lucian Adrian Grijincu <lucian.grijincu@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Pat Pannuto <pat.pannuto@gmail.com>
Salvo Tomaselli <tiposchi@tiscali.it>
Simone Piccardi <piccardi@truelite.it>
Slaven Rezic <srezic@iconmobile.com>
starlight <starlight@binnacle.cx>
Stephan Mueller <stephan.mueller@atsec.com>
Vijay Rao <vijay@portuosus.com>
Walter Haidinger <walter.haidinger@gmx.at>
Walter Harms <wharms@bfs.de>
Yang Yang <wdscxsj@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

sendmmsg.2
    Michael Kerrisk  [Stephan Mueller]
        New page for sendmmsg(2)
            Some pieces inspired by an initial attempt by Stephan Mueller.


Newly documented interfaces in existing pages
---------------------------------------------

fallocate.2
    Lucian Adrian Grijincu
        Document FALLOC_FL_PUNCH_HOLE
            FALLOC_FL_PUNCH_HOLE was added in Linux 2.6.38,
            for punching holes in the allocated space in a file.


Changes to individual pages
---------------------------

dup.2
    Michael Kerrisk
        SYNOPSIS: Add "#include <fcntl.h>" for O_* constants

fallocate.2
    Michael Kerrisk
        Substantial restructuring of DESCRIPTION
            The addition of a second class of operation ("hole punching")
            to the man page made it clear that some significant restructuring
            is required. So I substantially reworked the page, including the
            preexisting material on the default "file allocation" operation.
    Michael Kerrisk  [Josef Bacik]
        Add further details for FALLOC_FL_PUNCH_HOLE
    Michael Kerrisk
        ERRORS: Add EPERM error case for FALLOC_FL_PUNCH_HOLE

fork.2
    Michael Kerrisk
        NOTES: Describe clone() call equivalent to fork()

fsync.2
    Christoph Hellwig
        Various improvements
            - explain the situation with disk caches better
            - remove the duplicate fdatasync() explanation in the NOTES
              section
            - remove an incorrect note about fsync() generally requiring two
              writes
            - remove an obsolete ext2 example note
            - fsync() works on any file descriptor (doesn't need to be
              writable); correct the EBADF error code explanation
    Michael Kerrisk  [Guillem Jover]
        Note that some systems require a writable file descriptor
            An edited version of Guillem Jover's comments:
            [While the file descriptor does not need to be writable on Linux]
            that's not a safe portable assumption to make on POSIX in general
            as that behavior is not specified and as such is
            implementation-specific. Some Unix systems do actually fail on
            read-only file descriptors, for example [HP-UX and AIX].

mount.2
    Michael Kerrisk  [Junjiro Okajima]
        Removed erroneous statement about MS_RDONLY and bind mounts

open.2
    Jessica McKellar
        Fix grammar in O_DIRECT description
            Some small grammar fixes to the O_DIRECT description.

pipe.2
    Michael Kerrisk  [Salvo Tomaselli]
        SYNOPSIS: Add "#include <fcntl.h>" for O_* constants
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=659750

sched_rr_get_interval.2
    Clemens Ladisch
        Update notes on modifying quantum
            Since Linux 2.6.24, it is no longer possible to
            modify the SCHED_RR quantum using setpriority(2).
            (Slight edits to Clemens' patch by mtk.)
    Michael Kerrisk
        Reordered various pieces of text
    Michael Kerrisk
        Reworded text of ESRCH error

send.2
    Michael Kerrisk
        Add mention of sendmmsg(2)

sync.2
    Michael Kerrisk  [Simone Piccardi]
        PROTOTYPE: Fix return type of syncfs()

vfork.2
    Michael Kerrisk  [starlight]
        Clarify what is duplicated in the child
            Add some words to make it clear to the reader that vfork(),
            like fork(), creates duplicates of process attributes
            in the child.
    Michael Kerrisk
        Note clone() flags equivalent to vfork()
    Michael Kerrisk  [starlight, Mike Frysinger]
        Add some notes on reasons why vfork() still exists
    Michael Kerrisk  [starlight]
        Clarify that calling *thread* is suspended during vfork()
    Michael Kerrisk
        CONFORMING TO: Note that POSIX.1-2001 marked vfork() obsolete

gets.3
    Michael Kerrisk
        Document C11 and glibc 2.16 changes affecting gets()

pthread_sigmask.3
    Michael Kerrisk  [Pat Pannuto]
        Fix comment that was inconsistent with code in example program

sem_wait.3
    Walter Harms
        EXAMPLE: Remove extraneous line of output from shell session

wcsnrtombs.3
wcsrtombs.3
wcstombs.3
    Michael Kerrisk
        Fix-ups for e9c23bc636426366d659809bc99cd84661e86464

core.5
    Michael Kerrisk  [Junjiro Okajima]
        Document %E specifier for core_pattern

passwd.5
    Michael Kerrisk  [Walter Haidinger]
        s/asterisk/asterisk (*)/ to improve clarity
    Michael Kerrisk
        Correct note on passwd field value when shadowing is enabled
            When password shadowing is enabled, the password field
            contains an 'x' (not "*').

proc.5
    Elie De Brauwer
        Fix description of fourth field of /proc/loadavg
            SIgned-off-by: Elie De Brauwer <eliedebrauwer@gmail.com>

resolv.conf.5
    Michael Kerrisk  [Slaven Rezic]
        Describe syntax used for comments
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=656994

feature_test_macros.7
    Michael Kerrisk
        Document _ISOC11_SOURCE

inotify.7
    Michael Kerrisk  [Yang Yang]
        Note that 'cookie' field is set to zero when unused

man.7
    Michael Kerrisk
        Various fixes for description of NAME section
            As noted by reporter:
            * The code sample given for the NAME section is incomplete because
              the actual content sample is not given.
            * Additionally, the description assumes that the item described is
              a command, which need not be the case.
            * The command makewhatis is not present on my system; the
              documented tool to create the whatis database is called mandb.
            * The description on .SH NAME in man(7) should either copy the
              relevant paragraph of lexgrog(1) or refer to it.


==================== Changes in man-pages-3.37 ====================

Released: 2012-03-06, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes and ideas that have been
incorporated in changes in this release:

Denys Vlasenko <dvlasenk@redhat.com>
Mark R. Bannister <cambridge@users.sourceforge.net>
Michael Kerrisk <mtk.manpages@gmail.com>
Oleg Nesterov <oleg@redhat.com>
Tejun Heo <tj@kernel.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

getent.1
    Mark R. Bannister
        New page to document 'getent' binary provided by glibc


Changes to individual pages
---------------------------

bdflush.2
    Michael Kerrisk
        Note that bdflush() is deprecated, and does nothing

nfsservctl.2
    Michael Kerrisk
        Note that this system call was removed in Linux 3.1

ptrace.2
    Denys Vlasenko  [Oleg Nesterov, Tejun Heo]
        add extended description of various ptrace quirks
            Changes include:

            s/parent/tracer/g, s/child/tracee/g - ptrace interface now
            is sufficiently cleaned up to not treat tracing process
            as parent.

            Deleted several outright false statements:
            - pid 1 can be traced
            - tracer is not shown as parent in ps output
            - PTRACE_ATTACH is not "the same behavior as if tracee had done
              a PTRACE_TRACEME": PTRACE_ATTACH delivers a SIGSTOP.
            - SIGSTOP _can_ be injected.
            - Removed mentions of SunOS and Solaris as irrelevant.
            - Added a few more known bugs.

            Added a large block of text in DESCRIPTION which doesn't focus
            on mechanical description of each flag and operation, but rather
            tries to describe a bigger picture. The targeted audience is
            a person which is reasonably knowledgeable in Unix but did not
            spend years working with ptrace, and thus may be unaware of its
            quirks. This text went through several iterations of review by
            Oleg Nesterov and Tejun Heo.
            This block of text intentionally uses as little markup as possible,
            otherwise future modifications to it will be very hard to make.
    Michael Kerrisk
        Global clean-up of page
            * Wording and formatting fixes to existing text and
              Denys Vlasenko's new text.
            * Various technical amendments and improvements to
              Denys Vlasenko's new text.
            * Added FIXME for various problems with the current text.
    Michael Kerrisk
        Integrated changes after further review from Denys Vlasenko

syscalls.2
    Michael Kerrisk
        Note that nfsservctl(2) was removed in Linux 3.1
        Note that bdflush(2) is deprecated

capabilities.7
    Michael Kerrisk
        Add CAP_WAKE_ALARM
    Michael Kerrisk
        Add various operations under CAP_SYS_ADMIN
        Add perf_event_open(2) to CAP_SYS_ADMIN
        Add VM86_REQUEST_IRQ vm86(2) command to CAP_SYS_ADMIN
        Update CAP_NET_ADMIN with notes from include/linux/capability.h
        Add nfsservctl(2) to CAP_SYS_ADMIN
    Michael Kerrisk
        Add ioctl(FIBMAP) under CAP_SYS_RAWIO
    Michael Kerrisk
        Add virtual terminal ioctl()s under CAP_SYS_TTY_CONFIG
    Michael Kerrisk
        Update CAP_NET_RAW with notes from include/linux/capability.h
    Michael Kerrisk
        Add F_SETPIPE_SZ case to CAP_SYS_RESOURCE
        Add POSIX messages queues queues_max case to CAP_SYS_RESOURCE
        Update CAP_SYS_RESOURCE with notes from include/linux/capability.h
    Michael Kerrisk
        SEE ALSO: Add libcap(3)

ld.so.8
    Michael Kerrisk
        Add --audit command-line option


==================== Changes in man-pages-3.38 ====================

Released: 2012-03-25, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Akihiro MOTOKI <amotoki@gmail.com>
Artyom Pervukhin <artyom@evasive.ru>
Beňas Petr <xbenas00@stud.fit.vutbr.cz>
Ben Bacarisse <software@bsb.me.uk>
Bjarni Ingi Gislason <bjarniig@rhi.hi.is>
David Prévot <david@tilapin.org>
Denis Barbier <bouzim@gmail.com>
Denys Vlasenko <vda.linux@googlemail.com>
Eric Blake <ebb9@byu.net>
Iain Fraser <iainkfraser@gmail.com>
Justin T Pryzby <justinp@norchemlab.com>
Kirill Brilliantov <brilliantov@inbox.ru>
Mark R Bannister <mark@proseconsulting.co.uk>
Matthew Gregan <kinetik@flim.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Nix <nix@esperi.org.uk>
Peter Schiffer <pschiffe@redhat.com>
Sergei Zhirikov <sfzhi@yahoo.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

get_nprocs_conf.3
    Beňas Petr
        New page documenting get_nprocs_conf(3) and get_nprocs(3)
    Michael Kerrisk
        Some additions and improvements

malloc_get_state.3
    Michael Kerrisk
        New page documenting malloc_get_state(3) and malloc_set_state(3)

mallopt.3
    Michael Kerrisk
        New man page for mallopt(3)

mtrace.3
    Michael Kerrisk
        Complete rewrite of page, adding much more detail

scandirat.3
    Mark R Bannister
        New page for scandirat(3) (new in glibc 2.15)


Newly documented interfaces in existing pages
---------------------------------------------

posix_memalign.3
    Michael Kerrisk
        Document aligned_alloc(3)
            aligned_alloc() is new in C11.
    Michael Kerrisk
        Document pvalloc(3)

qsort.3
    Mark R Bannister
        Add documentation of qsort_r(3)
    Ben Bacarisse
        Improvements to Mark R Bannister's qsort_r() patch
    Michael Kerrisk
        Add VERSIONS section for qsort_r()


New and changed links
---------------------

aligned_alloc.3
    Michael Kerrisk
        New link to posix_memalign.3

get_nprocs.3
    Beňas Petr
        Link to new get_nprocs_conf.3 page

malloc_set_state.3
    Michael Kerrisk
        Link to new malloc_get_state.3 page

pvalloc.3
    Michael Kerrisk
        New link to posix_memalign.3


Global changes
--------------

Various pages
    Michael Kerrisk
        Global formatting fix: balance .nf/.fi pairs

Various pages
    Michael Kerrisk
        Global fix: place sections in correct order

Various pages
    Michael Kerrisk  [Justin T Pryzby]
        Global fix: Remove duplicated words
            Remove instances of duplicate words found using Justin's
            grep-fu:

                for f in man?/*.[1-9]; do
                    grep -HE ' ([[:alpha:]]{2,} +)\1' "$f" |
                        grep -Evw '(proc|hugetlbfs|XXX*|root|long) *\1';
                done | grep -E --colo ' ([[:alpha:]]{2,} +)\1'

Various pages
    Michael Kerrisk
        Correct order of SEE ALSO entries


Changes to individual pages
---------------------------

futimesat.2
    Michael Kerrisk
        PROTOTYPE: Correct header file and feature test macro requirements

keyctl.2
    Bjarni Ingi Gislason
        Strip trailing tabs from source line
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=664688

ptrace.2
    Denys Vlasenko
        Document PTRACE_GETEVENTMSG for PTRACE_EVENT_EXEC
    Denys Vlasenko
        Various fixes to recent updates of this page

symlinkat.2
    Michael Kerrisk  [Eric Blake]
        PROTOTYPE: Correct header file

syscalls.2
    Michael Kerrisk
        Remove unimplemented system calls from main syscall list
            The unimplemented system calls are in any case noted lower down
            in the page. Also: rearrange the text describing the unimplemented
            system calls.
    Michael Kerrisk
        Note a few system calls that were removed in Linux 2.6
    Michael Kerrisk
        Add process_vm_readv(2) and process_vm_writev(2)

unlinkat.2
    Michael Kerrisk  [Eric Blake]
        PROTOTYPE: Correct header file
    Michael Kerrisk
        PROTOTYPE: Add <fcntl.h> for AT_* constants

utimensat.2
    Michael Kerrisk
        PROTOTYPE: Add <fcntl.h> for AT_* constants

copysign.3
    Michael Kerrisk  [Tolga Dalman]
        DESCRIPTION: Add a couple of examples

malloc.3
    Michael Kerrisk
        NOTES: Add a short discussion of arenas
    Michael Kerrisk
        Replace discussion of MALLOC_CHECK_ with pointer to mallopt(3)
    Michael Kerrisk
        SEE ALSO: Add mtrace(3)
        SEE ALSO: add malloc_get_state(3)

posix_memalign.3
    Michael Kerrisk
        Rename memalign() argument
            Rename "boundary" to "alignment" for consistency
            with posix_memalign().
    Michael Kerrisk
        Improve discussion of feature test macros and header files for valloc(3)

rtnetlink.3
    Kirill Brilliantov  [Sergei Zhirikov]
        Fix example code, rta_len assignment should use RTA_LENGTH()
            See also http://bugs.debian.org/655088

scandir.3
    Mark R Bannister
        SEE ALSO: Add scandirat(3)

sigqueue.3
    Nix
        Remove rt_sigqueueinfo from TH line
            rt_sigqueueinfo() now has its own manual page, so should not
            be listed in the .TH line of this page.

tzset.3
    Peter Schiffer
        Correct description for Julian 'n' date format
            The Julian 'n' date format counts starting from 0, not 1.
    Michael Kerrisk
        Add some clarifying remarks to discussion of Julian day formats

packet.7
    Michael Kerrisk  [Iain Fraser]
        Fix comment on 'sll_hatype' field

tcp.7
    Michael Kerrisk  [Artyom Pervukhin]
        Correct RFC for TIME_WAIT assassination hazards


==================== Changes in man-pages-3.39 ====================

Released: 2012-04-17, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Abhijith Das <adas@redhat.com>
Alexander Kruppa <akruppa@gmail.com>
Andreas Jaeger <aj@suse.com>
Armin Rigo <arigo@tunes.org>
Cyrill Gorcunov <gorcunov@openvz.org>
Denys Vlasenko <vda.linux@googlemail.com>
Eric Blake <ebb9@byu.net>
Felix <fkater@googlemail.com>
Jak <jak@gmx.ca>
Jeff Mahoney <jeffm@suse.com>
Jesus Otero <jesus.otero@rysg.es>
Jonathan Nieder <jrnieder@gmail.com>
Kevin O'Gorman <kevinogorman4@gmail.com>
Mark R Bannister <mark@proseconsulting.co.uk>
Michael Kerrisk <mtk.manpages@gmail.com>
Michael Welsh Duggan <mwd@cert.org>
Mike Frysinger <vapier@gentoo.org>
Petr Gajdos <pgajdos@suse.cz>
Regid Ichira <regid23@yahoo.com>
Reuben Thomas <rrt@sc3d.org>
Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
Simone Piccardi <piccardi@truelite.it>
Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
<who@connect.carleton.ca>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

malloc_trim.3
    Michael Kerrisk
        New man page for malloc_trim(3)

malloc_usable_size.3
    Michael Kerrisk
        New man page for malloc_usable_size(3)


Newly documented interfaces in existing pages
---------------------------------------------

prctl.2
    Cyrill Gorcunov
        Document PR_SET_MM (new in Linux 3.3)
    Michael Kerrisk
        Various edits and improvements to Cyrill's patch


Changes to individual pages
---------------------------

epoll_create.2
    Michael Kerrisk
        Rework discussion of 'size' argument
    Michael Kerrisk
        Add .SS for description of epoll_create1()

epoll_wait.2
    Michael Kerrisk  [Armin Rigo]
        Another thread can add to epoll instance while epoll_wait is blocked
            See https://bugzilla.kernel.org/show_bug.cgi?id=43072
    Michael Kerrisk
        Clarify that epoll_pwait() blocks calling *thread*
        A few wording improvements

fchmodat.2
    Michael Kerrisk  [Mike Frysinger]
        Note difference between glibc wrapper and underlying system call
            The wrapper function has a 'flags' argument (which currently
            serves no purpose), while the underlying system call does not.

fcntl.2
    Abhijith Das
        Explain behaviour of F_GETLEASE during lease break
    Michael Kerrisk  [Eric Blake]
        Change type of arg from "long" to "int"
            Various fcntl(2) commands require an integral 'arg'.
            The man page said it must be "long" in all such cases.
            However, for the cases covered by POSIX, there is an
            explicit requirement that these arguments be "int".
            Update the man page to reflect. Probably, all of the
            other "long" cases (not specified in POSIX) should
            be "int", and this patch makes them so. Based on a
            note fromEric Blake, relating to F_DUPFD_CLOEXEC.

gettimeofday.2
    Michael Kerrisk
        Reorganize content
            The main change is to move the historical information about
            the 'tz_dsttime' to NOTES.
    Michael Kerrisk  [Felix]
        Note that compiler issues warnings if 'tv' is NULL

mmap.2
    Michael Kerrisk  [Kevin O'Gorman]
        Clarify that this system call should not be invoked directly
            See https://bugzilla.kernel.org/show_bug.cgi?id=42892
    Michael Kerrisk
        Clarify NOTES discussion of mmap() versus mmap2()

poll.2
    Michael Kerrisk  [Michael Welsh Duggan]
        Document negative value in 'fd' field
    Michael Kerrisk
        Document semantics of passing zero in 'events' field

ptrace.2
    Denys Vlasenko
        Various fixes
            For some reason, the PTRACE_TRACEME paragraph talks about some
            general aspects of ptraced process behavior. It repeats the
            "tracee stops on every signal" information even though that was
            already explained just a few paragraphs before. Then it describes
            legacy SIGTRAP on execve().

            This patch deletes the first part, and moves the second part up,
            into the general ptrace description. It also adds
            "If PTRACE_O_TRACEEXEC option is not in effect" to the description
            of the legacy SIGTRAP on execve().

            The patch also amends the part which says "For requests other
            than PTRACE_KILL, the tracee must be stopped." - PTRACE_ATTACH
            also doesn't require that.

sigaction.2
    Michael Kerrisk  [Andreas Jaeger, ]
        Clarify that the use of SI_SIGIO is for Linux 2.2 only
            See also http://sourceware.org/bugzilla/show_bug.cgi?id=6745

sigprocmask.2
    Mike Frysinger
        ERRORS: add EFAULT

times.2
    Michael Kerrisk  [Simone Piccardi]
        ERRORS: Add EFAULT

div.3
    Michael Kerrisk  [Reuben Thomas]
        CONFORMING TO: Add C99

fread.3
    Regid Ichira
        Clarify further that return value is number of items, not bytes
            See also http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=665780

getaddrinfo.3
    Michael Kerrisk  [Jak]
        Correct type of ai_addrlen field

malloc.3
    Michael Kerrisk
        SEE ALSO: add malloc_usable_size(3)
        SEE ALSO: Add malloc_trim(3)

mallopt.3
    Michael Kerrisk
        Fix text describing M_PERTURB and free()
        SEE ALSO: Add malloc_trim(3)

memchr.3
    Michael Kerrisk  [Reuben Thomas]
        Remove mention of terminating null in description of rawmemchr()

perror.3
    Michael Kerrisk  [Jesus Otero]
        Note that use of 'sys_errlist' is deprecated

rcmd.3
    Michael Kerrisk
        glibc eventually added a declaration of iruserok() in version 2.12

sysconf.3
    Michael Kerrisk  [Ricardo Catalinas Jiménez]
        Add mention of _SC_SYMLOOP_MAX

nologin.5
    Michael Kerrisk  [Tetsuo Handa]
        nologin must not only exist, but *be readable* to be effective

nsswitch.conf.5
    Mark R Bannister
        Significant rewrites and improvements
            This patch applies to nsswitch.conf.5 in man-pages-3.36.

            My changes almost completely rewrite large sections of the
            man page. They are needed to add clarity, correct grammar,
            reduce confusion, and bring up-to-date with the latest glibc.
            I have checked the man page against the nss source code in
            glibc 2.14.90.

            Historical notes are demoted to the footer.

            The rewrite makes the man page much clearer to
            understand, more authoratitive, and easier to read.
    Michael Kerrisk
        Light edits to Mark Bannister's changes

capabilities.7
    Michael Kerrisk
        Add prctl(PR_SET_MM) to CAP_SYS_RESOURCE

epoll.7
    Michael Kerrisk
        Some minor clarifications at start of DESCRIPTION

netlink.7
    Jeff Mahoney  [Petr Gajdos]
        Note cases where nonprivileged users can use netlink multicast groups
            See also https://bugzilla.novell.com/show_bug.cgi?id=754611

unix.7
    Michael Kerrisk  [Tetsuo Handa]
        Add a detail on autobind feature

ld.so.8
    Jonathan Nieder  [Reuben Thomas]
        Document effect of hwcaps on search path
            Wording by Aurelien Jarno from Debian glibc's r4701 (2011-06-04).

            Addresses http://bugs.debian.org/622385


==================== Changes in man-pages-3.40 ====================

Released: 2012-04-27, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alexey Toptygin <alexeyt@freeshell.org>
Bernhard Walle <bernhard@bwalle.de>
Brian F. G. Bidulock <bidulock@openss7.org>
Brian M. Carlson <sandals@crustytoothpaste.net>
Christopher Yeoh <cyeoh@au1.ibm.com>
Daniel J Blueman <daniel@quora.org>
Eric Blake <eblake@redhat.com>
Eugen Dedu <Eugen.Dedu@pu-pm.univ-fcomte.fr>
James Hunt <james.hunt@ubuntu.com>
John Sullivan <jsrhbz@kanargh.force9.co.uk>
Jon Grant <jg@jguk.org>
lepton <ytht.net@gmail.com>
Marcel Holtmann <marcel@holtmann.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Petr Baudis <pasky@ucw.cz>
Simon Paillard <spaillard@debian.org>
Stefan Puiu <stefan.puiu@gmail.com>
Ulrich Drepper <drepper@gmail.com>
Vadim Mikhailov <vadim.mikhailov@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

process_vm_readv.2
    Mike Frysinger, Christopher Yeoh, Michael Kerrisk
        New page for process_vm_readv(2) and process_vm_writev(2)

mcheck.3
    Michael Kerrisk
        New man page for mcheck(3) and related functions
            Also describes mcheck_check_all(3), mcheck_pedantic(3),
            and mprobe(3)


Newly documented interfaces in existing pages
---------------------------------------------

rcmd.3
    Michael Kerrisk
        Document "_af" variants of these functions
            Document rcmd_af(), rresvport_af(), iruserok_af(), ruserok_af().
            Also some restructuring and other clarifications.

rexec.3
    Michael Kerrisk
        Document rexec_af()


New and changed links
---------------------

iruserok_af.3
rcmd_af.3
rresvport_af.3
ruserok_af.3
    Michael Kerrisk
        New links to rcmd.3

rexec_af.3
    Michael Kerrisk
        New link to rexec.3


Changes to individual pages
---------------------------

clock_getres.2
    Michael Kerrisk
        Clarify difference between CLOCK_MONOTONIC and CLOCK_MONOTONIC_RAW
            Note interactions of these two clocks with discontinuous
            adjustments to the system time and NTP/adjtime(2).

fallocate.2
    Michael Kerrisk  [John Sullivan]
        Fix description of ENOSYS and EOPNOTSUP errors
            As reported in https://bugzilla.redhat.com/show_bug.cgi?id=680214

fchmodat.2
    Michael Kerrisk  [Mike Frysinger]
        Improve discussion of difference between wrapper and underlying syscall

gettimeofday.2
    Michael Kerrisk
        gettimeofday() is affected by discontinuous jumps in the system time
            Advise reader to use clock_gettime(2), if they need a
            monotonically increasing time source.
    Michael Kerrisk
        SEE ALSO: Add clock_gettime(2)

prctl.2
    Michael Kerrisk
        Add PR_TASK_PERF_EVENTS_DISABLE and PR_TASK_PERF_EVENTS_ENABLE
            Add some basic documentation of these operations, with a pointer to
            tools/perf/design.txt for more information.
    Michael Kerrisk  [Marcel Holtmann]
        Amend details of PR_SET_PDEATHSIG

ptrace.2
    Michael Kerrisk  [Mike Frysinger]
        Note SPARC deviation with respect to get/set regs
            SPARC reverses the use of 'addr' and 'data' for
            PTRACE_GETREGS, PTRACE_GETFPREGS, PTRACE_SETREGS,
            and PTRACE_SETFPREGS.

send.2
    Stefan Puiu
        Document EACCES error case for UDP

sigaction.2
    Michael Kerrisk
        Remove mention of raise(3) for SI_USER
            For a long time now, glibc's raise(3) didn't yield SI_USER
            for the signal receiver, so remove mention of raise(3)
            here. The user can deduce the details, if needed, by looking
            at the recently updated raise(3) page.

aio_cancel.3
    Michael Kerrisk  [Jon Grant]
        Rewrite RETURN VALUE section to be clearer

aio_init.3
    Michael Kerrisk  [Jon Grant]
        Remove extraneous "POSIX" from NAME section

btree.3
dbopen.3
hash.3
mpool.3
recno.3
    Michael Kerrisk  [Brian M. Carlson]
        Note that glibc no longer provides these interfaces
            glibc stopped providing these interfaces with v2.2.
            Nowadays, the user that finds these pages probably wants
            the libdb API, so note this in the page.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=337581

fopen.3
    Michael Kerrisk
        BUGS: Note limitation on number of flag characters parsed in 'mode'
    Michael Kerrisk
        Note that 'c' and 'e' flags are ignored for fdopen()
            Determined from reading libio/iofdopen.c.
    Michael Kerrisk
        Document ",ccs=string" feature of 'mode' for fopen()/freopen()

getgrnam.3
    Michael Kerrisk  [Ulrich Drepper]
        Fix discussion of _SC_GETGR_R_SIZE_MAX
            The value is not meant to be a maximum (as was specified in
            SUSv3) but an initial guess at the required size
            (as specified in SUSv4).

getpwnam.3
    Michael Kerrisk  [Ulrich Drepper]
        Fix discussion of _SC_GETPW_R_SIZE_MAX
            The value is not meant to be a maximum (as was specified in
            SUSv3) but an initial guess at the required size
            (as specified in SUSv4).

malloc.3
mallopt.3
mtrace.3
    Michael Kerrisk
        SEE ALSO: add mcheck(3)

memchr.3
    Michael Kerrisk
        Clarify description, omitting mention of "strings" and "characters"
            The existing text slipped into talking about characters and
            strings, which could mislead readers into thing that, for
            example, searches for the byte '\0' are treated specially.
            Therefore, rewrite in terms of "bytes" and "memory areas".

            At the same time, make a few source file clean-ups.

mkstemp.3
    Michael Kerrisk
        Add "mkstemps" and "mkostemps" to NAME line

posix_openpt.3
    Michael Kerrisk  [Vadim Mikhailov]
        Add some details on use of the slave pathname
            An explicit pointer to ptsname(3) is useful, as is a note
            of the fact that the slave device pathname exists only as
            long as the master device is held open.

raise.3
    Michael Kerrisk
        Add some notes on underlying system call that is used

rcmd.3
    Michael Kerrisk
        Add some details of the rresvport() 'port' argument

resolver.3
    Petr Baudis
        Note that many options are documented in resolv.conf(5)

scandir.3
    Michael Kerrisk  [Daniel J Blueman]
        Improve EXAMPLE source code: s/0/NULL/ in scandir() call

strchr.3
    James Hunt
        Explain behavior when searching for '\0'

strerror.3
    Eric Blake  [Stefan Puiu]
        Improve strerror_r() description
            POSIX requires that perror() not modify the static storage
            returned by strerror().  POSIX 2008 and C99 both require that
            strerror() never return NULL (a strerror() that always
            returns "" for all inputs is valid for C99, but not for POSIX).

            http://sourceware.org/bugzilla/show_bug.cgi?id=12204
            documents glibc's change to come into compliance with POSIX
            regarding strerror_r() return value.  The GNU strerror_r() use
            of 'buf' was confusing - I ended up writing a test program that
            proves that 'buf' is unused for valid 'errnum', but contains
            truncated "unknown message" for out-of-range 'errnum'.

            See also http://austingroupbugs.net/view.php?id=382
    Bernhard Walle
        Correct description of error return for XSI strerror_r()
    Michael Kerrisk [Eric Blake]
        Note how to use 'errno' to detect errors when calling strerror()
    Michael Kerrisk  [Jon Grant]
        Add an example of the kind of string returned by strerror()

resolv.conf.5
    Petr Baudis
        Document "single-request" option

inotify.7
    Michael Kerrisk
        Note buffer size that guarantees being able to read at least one event
    James Hunt
        Correct description of size of inotify_event structure

iso_8859-1.7
    Eugen Dedu
        Add "-" for SOFT HYPHEN
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=156154

netdevice.7
    Brian F. G. Bidulock
        Document some SIOC configuration ioctls
            This patch adds common but missing SIOC configuration ioctls to
            the netdevice.7 manual pages that are not documented anywhere
            else. SIOCSIFPFLAGS and SIOCGIFPFLAGS are linux-specific. Flag
            values come from Linux 2.6.25 kernel headers for sockios. The
            others are standard BSD ioctls that have always been implemented
            by Linux and were verified from inspecting netdevice.c kernel
            code.

socket.7
    Michael Kerrisk  [Alexey Toptygin]
        Correct description of SO_BROADCAST

tcp.7
    lepton
        Correct description for TCP_MAXSEG on modern kernel


==================== Changes in man-pages-3.41 ====================

Released: 2012-05-11, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Akihiro MOTOKI <amotoki@gmail.com>
Andries E. Brouwer <Andries.Brouwer@cwi.nl>
Angelo Borsotti <angelo.borsotti@gmail.com>
Bjarni Ingi Gislason <bjarniig@rhi.hi.is>
Brian M. Carlson <sandals@crustytoothpaste.ath.cx>
Casper Dik <Casper.Dik@oracle.com>
David Prévot <taffit@debian.org>
D. Barbier <bouzim@gmail.com>
Eric Blake <eblake@redhat.com>
Hugh Dickins <hughd@google.com>
Ivana Varekova <varekova@redhat.com>
Jakub Jelinek <jakub@redhat.com>
Jan Kara <jack@suse.cz>
Jason Baron <jbaron@redhat.com>
Jean-Michel Vourgère <jmv_deb@nirgal.com>
Jeff Moyer <jmoyer@redhat.com>
Josh Triplett <josh@joshtriplett.org>
Kasper Dupont <kasperd@gmail.com>
KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Lauri Kasanen <curaga@operamail.com>
Mel Gorman <mgorman@suse.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Nick Piggin <npiggin@gmail.com>
Paul Pluzhnikov <ppluzhnikov@google.com>
Petr Baudis <pasky@ucw.cz>
Ralph Corderoy <ralph@inputplus.co.uk>
Rich Felker <bugdal@aerifal.cx>
Simone Piccardi <piccardi@truelite.it>
Simon Paillard <spaillard@debian.org>
Stefan Puiu <stefan.puiu@gmail.com>
Stephen Hemminger <shemminger@vyatta.com>
Vincent Lefevre <vincent@vinc17.net>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

get_robust_list.2
    Ivana Varekova  [Michael Kerrisk]
        New page documenting get_robust_list(2) and set_robust_list(2)

mallinfo.3
    Michael Kerrisk [KOSAKI Motohiro, Paul Pluzhnikov]
        New page for mallinfo(3)

malloc_info.3
    Michael Kerrisk  [Jakub Jelinek]
        New page for malloc_info(3)

malloc_stats.3
    Michael Kerrisk  [KOSAKI Motohiro]
        New man page for malloc_stats(3)


Newly documented interfaces in existing pages
---------------------------------------------

madvise.2
    Jason Baron
        Document MADV_DONTDUMP and MADV_DODUMP


New and changed links
---------------------

set_robust_list.2
    Michael Kerrisk
        New link to new get_robust_list.2 page

LIST_ENTRY.3
LIST_HEAD.3
LIST_INIT.3
LIST_INSERT_AFTER.3
LIST_INSERT_HEAD.3
LIST_REMOVE.3
TAILQ_ENTRY.3
TAILQ_HEAD.3
TAILQ_INIT.3
TAILQ_INSERT_AFTER.3
TAILQ_INSERT_HEAD.3
TAILQ_INSERT_TAIL.3
TAILQ_REMOVE.3
CIRCLEQ_ENTRY.3
CIRCLEQ_HEAD.3
CIRCLEQ_INIT.3
CIRCLEQ_INSERT_AFTER.3
CIRCLEQ_INSERT_BEFORE.3
CIRCLEQ_INSERT_HEAD.3
CIRCLEQ_INSERT_TAIL.3
CIRCLEQ_REMOVE.3
    Michael Kerrisk
        New link to queue.3
            The queue(3) page documents these macros, so it makes sense to
            have links for the names.

DES_FAILED.3
    Michael Kerrisk
        New link to des_crypt.3
            The des_crypt(3) page documents this macro, so it makes sense
            to have a link for the name.

qsort_r.3
    Michael Kerrisk
        New link to qsort.3
            Overlooked to add this link in 3.38, when documentation of
            qsort_r() was added to the qsort.3 page.


Global changes
--------------

faccessat.2
fchmodat.2
fchownat.2
fstatat.2
futimesat.2
inotify_init.2
linkat.2
mkdirat.2
mknodat.2
openat.2
readlinkat.2
renameat.2
setns.2
splice.2
symlinkat.2
sync.2
tee.2
unlinkat.2
vmsplice.2
    Michael Kerrisk  [Lauri Kasanen]
        Global fix: note glibc version that added library support

confstr.3
strcasecmp.3
strcat.3
strcmp.3
strcpy.3
strdup.3
strftime.3
strlen.3
strnlen.3
strpbrk.3
strspn.3
strtok.3
strxfrm.3
    Michael Kerrisk  [Andries E. Brouwer]
        Clarify that these functions operate on bytes, not (wide) characters
            Change 'character(s)' to 'byte(s)' to make clear that these
            functions operate on bytes, not wide / UTF8 characters.
            (POSIX uses 'byte(s)' similarly, to make this point.)

icmp.7
ipv6.7
packet.7
raw.7
rtnetlink.7
unix.7
x25.7
    Michael Kerrisk
        Remove names of constants from NAME line
            Some of the sockets/network protocol pages included names of
            the corresponding address family constants in the NAME line,
            but this wasn't done consistently across all pages, and probably
            it adds little value in those pages that did do this. So, remove
            these constants from those pages that have them in the NAME
            section.


Changes to individual pages
---------------------------

clock_getres.2
    Michael Kerrisk  [Josh Triplett]
        Expand description of CLOCK_REALTIME
            Make it clear that this clock may be discontinuous, and is
            affected my incremental NTP and clock-adjtime(2) adjustments.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=540872

epoll_wait.2
    Michael Kerrisk
        Clarify that 'timeout' is a *minimum* interval
            Make it clear that 'timeout' is a minimum interval; the actual
            interval will be rounded up to the system clock granularity,
            and may overrun because of kernel scheduling delays.

execve.2
    Michael Kerrisk
        Rewording to deemphasize libc5 details

fork.2
    Mike Frysinger
        ERRORS: add ENOSYS
            Can occur on, for example, non-MMU hardware.

getcpu.2
    Mike Frysinger
        Add RETURN VALUE and ERRORS sections
    Michael Kerrisk
        Refer reader to NOTES for more info about 'tcache'
    Michael Kerrisk
        DESCRIPTION: reword a sentence to be clearer

io_cancel.2
io_destroy.2
io_getevents.2
io_setup.2
io_submit.2
    Michael Kerrisk
        Rewrite to focus on system call API
            Rewrite to focus on the system call interface, adding
            some notes on the libaio wrapper differences.
            See the following mail:
            2012-05-07 "aio manuals", linux-man@vger
            http://thread.gmane.org/gmane.linux.man/1935/focus=2910

            Other minor rewrites.

mount.2
    Michael Kerrisk
        Comment out an old Linux libc detail

open.2
    Nick Piggin  [KOSAKI Motohiro, Jan Kara, Hugh Dickins]
        Describe race of direct I/O and fork()
            Rework 04cd7f64, which didn't capture the details correctly.
            See the April/May 2012 linux-man@ mail thread "[PATCH]
            Describe race of direct read and fork for unaligned buffers"
            http://thread.gmane.org/gmane.linux.kernel.mm/77571

poll.2
    Michael Kerrisk
        Clarify that 'timeout' is a *minimum* interval
            Make it clear that 'timeout' is a minimum interval; the actual
            interval will be rounded up to the system clock granularity,
            and may overrun because of kernel scheduling delays.
    Michael Kerrisk
        Clarify discussion of wrapper function emulation
            Clarify that glibc (as well as old libc) provides emulation
            using select(2) on older kernels that don't have a poll()
            system call.
    Michael Kerrisk
        Make the meaning of a zero timeout explicit
            Clarify that timeout==0 causes an immediate return, even if
            no file descriptors are ready.

pread.2
    Michael Kerrisk  [Kasper Dupont]
        BUGS: Note O_APPEND + pwrite() does the wrong thing
            See https://bugzilla.kernel.org/show_bug.cgi?id=43178

recvmmsg.2
    Michael Kerrisk
        Clarify that 'timeout' is a *minimum* interval
            Make it clear that 'timeout' interval will be rounded up to the
            system clock granularity, and may overrun because of kernel
            scheduling delays.

select.2
    Michael Kerrisk
        Clarify that 'timeout' is a *minimum* interval
            Make it clear that 'timeout' is a minimum interval; the actual
            interval will be rounded up to the system clock granularity,
            and may overrun because of kernel scheduling delays.
    Michael Kerrisk
        Expand description of the self-pipe trick
    Michael Kerrisk
        Add further details on pselect6() system call that underlies pselect()

semop.2
    Michael Kerrisk
        Clarify that 'timeout' of semtimedop() is a *minimum* interval
            Make it clear that 'timeout' interval will be rounded up to the
            system clock granularity, and may overrun because of kernel
            scheduling delays.

signal.2
    Michael Kerrisk
        Note that 'sig_t' requires _BSD_SOURCE
            Also remove some old Linux libc details

sigwaitinfo.2
    Michael Kerrisk
        Clarify that 'timeout' of sigtimedwait() is a *minimum* interval
            Make it clear that 'timeout' is a minimum interval; the actual
            interval will be rounded up to the system clock granularity,
            and may overrun because of kernel scheduling delays.

stat.2
    Bjarni Ingi Gislason
        Formatting fixes
            From "groff -ww" (or "man --warnings=w ..."):

                warning: around line 442: table wider than line width

            GNU man uses line length of 78.

            Use text blocks.  Two spaces between sentences or better: start
            each sentence in a new line.

syscalls.2
    Bjarni Ingi Gislason
        Formatting fixes
            From "groff -ww ..." (or "man --warnings=w ..."):

                warning: around line 157: table wider than line width

            Have to use text blocks.  Move some text to its correct column.
            Split text to two columns to avoid hyphenation.

sysinfo.2
    Michael Kerrisk
        Remove reference to obsolete libc5

syslog.2
    Michael Kerrisk
        Remove some details about obsolete Linux libc

aio_cancel.3
aio_error.3
aio_fsync.3
aio_read.3
aio_return.3
aio_suspend.3
aio_write.3
    Michael Kerrisk
        ERRORS: Add/update ENOSYS error

aio_cancel.3
    Michael Kerrisk
        Clarify what happens when a request isn't successfully canceled
    Michael Kerrisk
        Add pointers to aio(7) and sigevent(7)

dbopen.3
    Michael Kerrisk
        SYNOPSIS: Add header file <fcntl.h>
            Upstreamed from Debian, and consistent with FreeBSD
            dbopen(3) man page.

fmemopen.3
    Michael Kerrisk
        Note details of POSIX.1-2008 specification of 'b' in 'mode'
    Michael Kerrisk  [Rich Felker]
        BUGS: fmemopen() doesn't correctly set file position in some cases
            If 'mode' is append, but 'size' does not cover a null byte
            in 'buf', then fmemopen() incorrectly sets the initial file
            position to -1, rather than the next byte after the end of
            the buffer.

            See http://sourceware.org/bugzilla/show_bug.cgi?id=13151
    Michael Kerrisk
        BUGS: fmemopen() incorrectly handles size==0 case
            If size is zero, fmemopen() fails, This is surprising behavior,
            and not specified in POSIX.1-2008.

            See http://sourceware.org/bugzilla/show_bug.cgi?id=11216

            Reported-by; Alex Shinn <alexshinn@gmail.com>
    Michael Kerrisk
        BUGS: Note silent ABI change for fmemopen() in glibc 2.9
    Michael Kerrisk  [Rich Felker]
        BUGS: Append mode does not force writes to append
            Append mode correctly sets the initial offset but does
            not force subsequent writes to append at end of stream.

            See http://sourceware.org/bugzilla/show_bug.cgi?id=13152
    Michael Kerrisk  [Eric Blake]
        BUGS: Note inconsistent treatment of 'b' in 'mode'
            fopen() permits, for example, both "w+b" and "wb+",
            but only the latter is meaningful to fmemopen().

            See http://sourceware.org/bugzilla/show_bug.cgi?id=12836

fopencookie.3
    Michael Kerrisk  [Petr Baudis]
        Correct description of return for user-supplied 'write' function
            See http://sourceware.org/bugzilla/show_bug.cgi?id=2074

getaddrinfo.3
    Jean-Michel Vourgère
        Note that AI_ADDRCONFIG is not affected by loopback addresses
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=660479

iconv.3
    Michael Kerrisk
        Upstream useful NOTE from Debian
            Warn the reader that the pointer arguments can't be
            interpreted as C style strings. Also, note possible
            alignment requirements for the referenced bytes sequences,
    Michael Kerrisk
        Write a better paragraph introducing iconv() and its arguments

isgreater.3
    Michael Kerrisk  [Vincent Lefevre]
        Clarify that the arguments to these macros must be real-floating
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=609033

lio_listio.3
    Michael Kerrisk
        Clarify that async notification occurs when *all* I/Os complete

makedev.3
    Michael Kerrisk
        SYNOPSIS: Correct return types of major() and minor()
            See https://bugzilla.redhat.com/show_bug.cgi?id=754188

            Reported-by; Zdenek Kabelac <zkabelac@redhat.com>

malloc.3
    Michael Kerrisk
        SEE ALSO: Add malloc_info(3)

malloc_get_state.3
    Michael Kerrisk
        Fix wordos in function names in NAME line

mallopt.3
    Michael Kerrisk
        Fix example program
            The example code was a version that was not consistent with
            the shell output shown on the page.

            Reported-bY: Simon Paillard <spaillard@debian.org>
    Michael Kerrisk
        Restore accidentally omitted line in shell session
    Michael Kerrisk
        SEE ALSO: Add malloc_stats(3)

mmap64.3
    Michael Kerrisk
        Change target of link to mmap.2 (was mmap2.2)
            Upstreamed from Red Hat / Fedora

realpath.3
    Michael Kerrisk  [Casper Dik]
        Remove note about Solaris possibly returning a relative path

syslog.3
    Michael Kerrisk  [Ralph Corderoy]
        Document behavior when 'ident' argument to openlog() is NULL
            See https://bugs.launchpad.net/ubuntu/+source/manpages/+bug/382096
    Michael Kerrisk
        Update CONFORMING TO for POSIX.1-2008
            POSIX.1-2008 doesn't change any details, but make
            that more explicit.

undocumented.3
    Michael Kerrisk
        Remove some functions that have been documented

sd.4
    Michael Kerrisk
        Remove reference to nonexistent scsi(4) page
            Upstreamed from RedHat / Fedora

sk98lin.4
    Michael Kerrisk  [Stephen Hemminger]
        Note that this driver was removed in 2.6.28
            See https://bugs.launchpad.net/ubuntu/+source/manpages/+bug/528020

passwd.5
    Michael Kerrisk
        Upstream pieces from Red Hat/Fedora
            Note mention of empty password field.
            Add description of "*NP*" in password field.
    Michael Kerrisk
        Various minor fixes and improvements

proc.5
    Michael Kerrisk
        Note that CAP_SYS_ADMIN processes can override file-max
            Upstreamed from red Hat / Fedora
    Michael Kerrisk
        Document  /proc/[pid]/cgroup
            Upstreamed from Red Hat / Fedora

resolv.conf.5
    Michael Kerrisk
        Take a Debian improvement into upstream

tzfile.5
    Michael Kerrisk
        Mention timezone directories in DESCRIPTION
            Note that timezone files are usually in /usr/lib/zoneinfo
            or /usr/share/zoneinfo.
    Michael Kerrisk
        Drop SYNOPSIS
            The SYNOPSIS doesn't correspond to a user-visible file.
    Michael Kerrisk
        SEE ALSO: Add pointer to glibc source file timezone/tzfile.h
    Michael Kerrisk
        SEE ALSO: add tzset(3) and tzselect(8)

ascii.7
    Bjarni Ingi Gislason
        Indent for "troff" makes table too wide
            Fix following from "groff -t -ww ...":

                warning: around line 53: table wider than line width

            Extra indent for "troff" makes the table look misplaced
            (default "ps" output).

cp1251.7
    Bjarni Ingi Gislason
        table too wide
            From "nroff -ww -t ...":

                warning: around line 44: table wider than line width

            Columns are made narrower (column gutter decreased).

ipv6.7
    Stefan Puiu
        Add ENODEV error for bind() to link-local IPv6 address

signal.7
    Michael Kerrisk  [Simone Piccardi]
        Clarify that SIGLOST is unused
    Michael Kerrisk
        Comment out crufty BUGS text on SIGLOST
            It must be a very long time since the statement there
            about SIGLOST was true. (The text seems to date back to
            1996.)
    Michael Kerrisk
        Update architectures for tables of signal numbers

utf-8.7
    Brian M. Carlson
        Two clarifications
            This patch clarifies that 0xc0 and 0xc1 are not valid in any UTF-8
            encoding[0], and it also references RFC 3629 instead of RFC 2279.

            [0] In order to have 0xc0, you'd have to have a two-byte encoding
            with all the data bits zero in the first byte (and thus only six
            bits of data), which would be an ASCII character encoded in the
            non-shortest form.  Similarly with 0xc1.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=538641

ldconfig.8
nscd.8
    Michael Kerrisk
        Remove path prefix from NAME line
            Command names shown in NAME are normally just the basename,
            not the full pathname of the command.


==================== Changes in man-pages-3.42 ====================

Released: 2012-08-14, Konolfingen


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Aaron Peschel <aaron.peschel@gmail.com>
Adrian Dabrowski <atrox@seclab.tuwien.ac.at>
Akihiro MOTOKI <amotoki@gmail.com>
Alan Curry <pacman@kosh.dhis.org>
Bjarni Ingi Gislason <bjarniig@rhi.hi.is>
Christoph Lameter <cl@linux.com>
Colin McCabe <cmccabe@alumni.cmu.edu>
Daniel Zingaro <daniel.zingaro@utoronto.ca>
David Prévot <taffit@debian.org>
Denys Vlasenko <vda.linux@gmail.com>
Henry Hu <henry.hu.sh@gmail.com>
Herbert Xu <herbert@gondor.apana.org.au>
Jan Engelhardt <jengelh@medozas.de>
Jim Hill <gjthill@gmail.com>
JoonSoo Kim <js1304@gmail.com>
Kalle Olavi Niemitalo <kon@iki.fi>
Martin H <textshell-tSIEzQ@neutronstar.dyndns.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Michael S. Tsirkin <mst@redhat.com>
Rasmus Villemoes <Rasmus.Villemoes@decode.is>
Sami Kerola <kerolasa@iki.fi>
Sam Varshavchik <mrsam@courier-mta.com>
Shawn Landden <shawnlandden@gmail.com>
Simon Paillard <spaillard@debian.org>
Tolga Dalman <tolga.dalman@googlemail.com>
Ulrich Drepper <drepper@gmail.com>
Марк Коренберг <socketpair@gmail.com>

Apologies if I missed anyone!


Global changes
--------------

Various pages
    Sami Kerola
        Global fix: use UR macro where applicable
            The syntax .UR http://example.com paired with .UE will create
            links which one can interact, if the pager allows that.  One
            way to see the effect is ask the man(1) command to use browser
            display, e.g.:

                man -H man7/uri.7

            ("\:" is optional groff syntax to permit hyphenless line breaks.)


Changes to individual pages
---------------------------

ldd.1
    Michael Kerrisk
        Add security note on untrusted executables
            See also http://www.catonmat.net/blog/ldd-arbitrary-code-execution/
            and
            http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html

clone.2
    Michael Kerrisk
        Rewrite discussion of sys_clone

futex.2
    Марк Коренберг
        Consolidate error descriptions to ERRORS
    Michael Kerrisk
        Various wording fix-ups
    Michael Kerrisk
        Fix description of EINVAL error
            The current text seems incorrect. Replace with a more general
            description.

getdents.2
select_tut.2
atof.3
atoi.3
pthread_create.3
pthread_sigmask.3
rtime.3
setbuf.3
tsearch.3
netlink.7
    Michael Kerrisk  [Jan Engelhardt]
        Remove unneeded casts

get_robust_list.2
get_thread_area.2
getcpu.2
getdents.2
gettid.2
io_cancel.2
io_destroy.2
io_getevents.2
io_setup.2
io_submit.2
ioprio_set.2
kexec_load.2
llseek.2
modify_ldt.2
mq_getsetattr.2
pivot_root.2
readdir.2
rt_sigqueueinfo.2
set_thread_area.2
sgetmask.2
spu_create.2
spu_run.2
subpage_prot.2
sysctl.2
tkill.2
    Michael Kerrisk
        Add note to SYNOPSIS that there is no glibc wrapper for system call
            Reduce the chance that the reader may be misled into thinking
            that there is a wrapper function for this system call by noting
            explicitly in the SYNOPSIS that there is no glibc wrapper and
            pointing the reader to NOTES for further details.

ioprio_set.2
    Colin McCabe
        Clarify the multithreaded behavior of ioprio_set(2)
    Michael Kerrisk  [Марк Коренберг, Kalle Olavi Niemitalo]
        Document who==0 for IOPRIO_WHO_PROCESS and IOPRIO_WHO_PGRP
            For IOPRIO_WHO_PROCESS, who==0 means operate on the caller.
            For IOPRIO_WHO_PGRP, who==0 means operate on the caller's
            process group.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=652443

migrate_pages.2
    Michael Kerrisk  [Christoph Lameter, JoonSoo Kim]
        Fix description of return value

mount.2
    Michael Kerrisk
        For MS_REMOUNT, source is ignored

mprotect.2
    Michael Kerrisk  [Rasmus Villemoes]
        'addr' argument is not const
            As reported by Rasmus:

                Both my system's man-pages (3.22) and the latest online
                (3.41) show:

                    int mprotect(const void *addr, size_t len, int prot);

                as the prototype for mprotect(2). However, POSIX [1] and the
                actual sys/mman.h (on all the systems I checked) do not have
                the const qualifier on the first argument.

msgctl.2
semctl.2
shmctl.2
svipc.7
    Michael Kerrisk
        Don't mention that ipc_perm is defined in <sys/ipc.h>
            There's no need to mention that the 'ipc_perm' structure
            is defined in <sys/ipc.h>. That's an implementation detail,
            and furthermore <sys/ipc.h> is itself included by the other
            System V IPC header files. The current text might lead the
            reader to conclude that they must include <sys/ipc.h>, which
            is not the case (it is required neither on Linux, nor by the
            standards).

msgctl.2
msgget.2
msgop.2
semctl.2
semget.2
semop.2
shmctl.2
shmget.2
    Michael Kerrisk
        NOTES: <sys/types.h> and <sys/ipc.h> aren't strictly needed
            Add text to NOTES to say that the <sys/types.h> and <sys/ipc.h>
            header files aren't required by Linux or the standards, but may
            be needed for portability to old systems.

ptrace.2
    Denys Vlasenko
        Explain WNOHANG behavior and EINTR bug
            I didn't like the "SIGKILL operates similarly, with exceptions"
            phrase (if it's different, then it's not "similar", right?),
            and now I got around to changing it. Now it says simply:
            "SIGKILL does not generate signal-delivery-stop and therefore
            the tracer can't suppress it."

            Replaced "why WNOHANG is not reliable" example with a more
            realistic one (the one which actually inspired to add this
            information to man page in the first place): we got
            ESRCH - process is gone! - but waitpid(WNOHANG) can still
            confusingly return 0 "no processes to wait for".

            Replaced "This means that unneeded trailing arguments may
            be omitted" part with a much better recommendation
            to never do that and to supply zero arguments instead.
            (The part about "undocumentedness" of gcc behavior was bogus,
            btw - deleted).

            Expanded BUGS section with the explanation and an example
            of visible strace behavior on the buggy syscalls which
            exit with EINTR on ptrace attach. I hope this will lead
            to people submitting better bug reports to lkml about
            such syscalls.

seteuid.2
    Michael Kerrisk
        Note glibc version where setegid() implementation changed
            In glibc 2.2/2.3, setegid() switched from setregid() to setresgid().

set_tid_address.2
    Michael Kerrisk
        Rename 'ctid' argument for consistency with clone(2) page
    Michael Kerrisk
        Some rewordings and minor clarifications

sigwaitinfo.2
    Michael Kerrisk  [Daniel Zingaro]
        Some wording clarifications
            Mainly rewording things like "is delivered" to "becomes pending",
            which is more accurate terminology.

syscall.2
    Michael Kerrisk
        Add some more details to the description of syscall(2)
            And add another example of using syscall() to the program example.

syscalls.2
    Michael Kerrisk
        Add kcmp(2)
    Michael Kerrisk
        Move discussion of set_zone_reclaim(2) out of main table
            This system call was never visible to user space, so it makes
            sense to move it out of the main table of system calls into
            the notes below the table.

getifaddrs.3
    Michael Kerrisk  [Adrian Dabrowski]
        Note that ifa_addr and ifa_netmask can be NULL

readdir.3
    Michael Kerrisk  [Jan Engelhardt]
        Handle -1 error from pathconf() in example code snippet
            Improve the example demonstrating allocation of a buffer
            for readdir_r() to handle -1 error return from pathconf().
            Otherwise, naive readers may think that pathconf() return
            value can be used without checking.

realpath.3
    Shawn Landden
        Use past tense with ancient history (libc4, libc5)

regex.3
    Michael Kerrisk
        Correct SEE ALSO reference to glibc manual "regex" section

rtime.3
    Michael Kerrisk  [Jan Engelhardt]
        Fix broken pointer cast in example code

sem_close.3
sem_destroy.3
sem_getvalue.3
sem_init.3
sem_open.3
sem_post.3
sem_unlink.3
sem_wait.3
sem_overview.7
    Michael Kerrisk
        Note that "cc -pthread" is required; "-lrt" no longer works
            See https://bugs.launchpad.net/ubuntu/+source/manpages/+bug/874418

sigwait.3
    Michael Kerrisk
        Reword "is delivered" to "becomes pending"

strcat.3
    Michael Kerrisk
        Add some text to emphasize the dangers of buffer overruns
    Michael Kerrisk
        NOTES: Add discussion of strlcat()

strcpy.3
    Michael Kerrisk
        Note that info is lost when strncpy() doesn't null terminate
    Michael Kerrisk
        Add some text to emphasize possibility of buffer runs with strcpy()
    Michael Kerrisk
        NOTES: Add a discussion of strlcpy()
            Inspired by https://lwn.net/Articles/506530/
    Michael Kerrisk
        Fix description of the null-byte padding performed by strncpy()

tsearch.3
    Michael Kerrisk
        NOTES: remove redundant discussion of unorthodox use of term "postorder"
            This point is already covered at greater length in the main
            text of the page (See the piece "More commonly, ...").
    Michael Kerrisk
        Clarify use for first argument to the twalk() 'action' function
            There's a number of details in POSIX that are omitted in
            the current version of this page.
    Michael Kerrisk
        Some wording fixes

core.5
    Michael Kerrisk
        Note effect of madvise(2) MADV_DONTDUMP flag

capabilities.7
    Michael Kerrisk
        Document CAP_BLOCK_SUSPEND

glob.7
    Bjarni Ingi Gislason
        Change 8 bit characters to 7 bit representation
            Fixes rendering errors for accented 'a' characters.
    Michael Kerrisk  [Aaron Peschel]
        Update bash(1) command used to obtain classical globbing behavior
            The man page formerly noted the bash(1) v1 command to do this.

iso_8859-1.7
    Bjarni Ingi Gislason
        Explanation of SOFT HYPHEN and the code for it
            <groff: iso_8859-2.7>:89: warning: can't find special character `shc'

            This is the only "iso_8859-*.7" file that has this (now)
            undefined character.  The code in column four in "iso_8859-1.7" is
            "0x2D" ("HYPHEN, MINUS SIGN" or "HYPHEN-MINUS") instead of "0xAD".
            See Debian bug 156154 (or package "manpages").

            There should be an explanation for this graphic character and the
            code should be 0xAD in iso_8859-1.7 (as in all others), even
            though "[gn]roff" does not display a "HYPHEN" in that position of
            the table.

            The line with "SOFT HYPHEN" gets a footnote and a short
            explanation.

mdoc.7
    Bjarni Ingi Gislason
        Fixing a warning and a table
            Fis warning from "groff -ww ..." (or "man --warnings=w ..."):

                <groff: mdoc.7>:294: warning:
                tab character in unquoted macro argument

            In one table the distance between columns is too small in the
            "ps" output.  (Bug in the groff "doc.tmac" macro?)

mdoc.samples.7
    Bjarni Ingi Gislason
        Fix warnings from [ng]roff, corrections
            From "man -ww ..." (groff -ww ...):

                <standard input>:541: warning:
                tab character in unquoted macro argument
                [+3 similar warnings]
                <standard input>:813: warning: macro `Pu' not defined
                Usage: .Rv -std in sections 2 and 3 only (#1669)
                mdoc warning: A .Bl directive has no matching .El (#1821)

            String "Pu" defined as a row of punctuation characters.
            ".Bl" and ".El" fixed.
            Some arguments, that start with a period or are the name of a
            macro, protected with "\&".
            Variable name for macro ".Rv" corrected.

netdevice.7
    Bjarni Ingi Gislason
        Line in table too long
            Fix warning from "man ..." ("nroff -ww ..."):

                nroff: netdevice.7: warning: around line 98:
                table wider than line width

            Fix: No right adjustment in text blocks in tables.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=673873

netlink.7
    Bjarni Ingi Gislason
        Line in table is too long
            Fix warning from "man ..." ("nroff -ww ..."):

                nroff: netlink.7: warning: around line 195:
                table wider than line width

            Horizontal line incorporated into table.
            No right adjustment of text blocks in tables.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=673875
    Simon Paillard  [Herbert Xu]
        Change description of "*_pid" fields to "Port ID"
            As reported by Herbert Xu, these should not be considered as PIDs.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=383296

rtnetlink.7
    Bjarni Ingi Gislason
        Line in table too long
            Fix warning from "man ..." ("nroff -ww ..."):

                nroff: rtnetlink.7: warning: around line 415:
                table wider than line width

            Column gutter reduced to fit line length.
            Right adjustment in text blocks removed in tables.
            Some header made centered in tables.
            One table put on same page.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=674051

socket.7
    Martin H
        Document SO_MARK socket option
            Commit 4a19ec5800fc3bb64e2d87c4d9fdd9e636086fe0 in Jan 2008 added
            the new SO_MARK socket option.

            This patch is based on text from the commit message.

            See https://bugzilla.kernel.org/show_bug.cgi?id=16461.

svipc.7
    Michael Kerrisk
        SYNOPSIS: Remove include of <sys/types.h> and <sys/ipc.h>
            Including <sys/types.h> and <sys/ipc.h> isn't needed on Linux
            and isn't really relevant for the explanation on this page.


==================== Changes in man-pages-3.43 ====================

Released: 2012-10-05, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Adrian Bunk <bunk@kernel.org>
Anatoli Klassen <anatoli@aksoft.net>
Andreas Schwab <schwab@linux-m68k.org>
Bjarni Ingi Gislason <bjarniig@rhi.hi.is>
David Prévot <taffit@debian.org>
Eric Dumazet <edumazet@google.com>
Florian Weimer <fweimer@redhat.com>
Frédéric Brière <fbriere@fbriere.net>
Fredrik Arnerup <arnerup@kth.se>
Guillem Jover <guillem@hadrons.org>
Jan Engelhardt <jengelh@inai.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Simon Josefsson <simon@josefsson.org>
Stephane Fillod <fillods@users.sf.net>
Trevor Woerner <twoerner@gmail.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


Newly documented interfaces in existing pages
---------------------------------------------

getenv.3
    Michael Kerrisk  [Florian Weimer, Andreas Schwab]
        Document secure_getenv(3)


New and changed links
---------------------

phys.2
    Michael Kerrisk
        New link to unimplemented.2

secure_getenv.3
    Michael Kerrisk
        New link to getenv.3


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix: s/-/\\-/ when real hyphen is required (e.g., in code)

Various pages
    David Prévot [Michael Kerrisk]
        Global fix: Various consistency fixes for SEE ALSO

Various pages
    Michael Kerrisk
        Global fix: use "Linux kernel source" consistently
            Rather than "kernel source".

Various pages
    Michael Kerrisk
        Global fix: disable justification and hyphenation in SEE ALSO
            For a better visual result, disable justification and hyphenation
            in SEE ALSO where page names are long.

syscalls.2
uname.2
boot.7
    Michael Kerrisk
        Global fix: s/OS/operating system/


Changes to individual pages
---------------------------

epoll_wait.2
    Michael Kerrisk  [Fredrik Arnerup]
        Describe timeout limitation in kernels < 2.6.37
            As reported by Fredrik (and as far as I can tell the problem
            went back to 2.6.0):

            The timeout argument has an upper limit. Any values above that
            limit are treated the same as -1, i.e. to wait indefinitely.
            The limit is given by:

                #define EP_MAX_MSTIMEO min(1000ULL * MAX_SCHEDULE_TIMEOUT / HZ, \
                (LONG_MAX - 999ULL) / HZ)

            That is, the limit depends on the size of a long and the timer
            frequency.  Assuming the long is never smaller than 32 bits
            and HZ never larger than 1000, the worst case is 35 minutes.
            I think this should be mentioned under "BUGS".

            Although this is likely to be fixed in the future
            (http://lkml.org/lkml/2010/8/8/144), the problem exists in
            at least 2.6.14 - 2.6.35. I don't know if select(2) and poll(2)
            are affected.

            https://bugzilla.kernel.org/show_bug.cgi?id=20762
    Michael Kerrisk
        Add pointer to select(2) for discussion of close in another thread

getitimer.2
    Michael Kerrisk  [Trevor Woerner]
        Note Linux's odd handling of the new_value==NULL case
    Michael Kerrisk  [Trevor Woerner]
        Fix types used to declare fields in timeval struct

keyctl.2
    David Prévot
        Reorder SEE ALSO, without .br

poll.2
    Michael Kerrisk
        Add pointer to select(2) for discussion of close in another thread

select.2
    Michael Kerrisk  [Stephane Fillod]
        Note behavior if monitored file descriptor is closed in another thread
            Executive summary: a sane application can't rely on any
            particular behavior if another thread closes a file descriptor
            being monitored by select().

            See https://bugzilla.kernel.org/show_bug.cgi?id=40852
    Michael Kerrisk
        Clarify equivalent pselect() code in terms of threads
            s/sigprogmask/pthread_sigmask/

semop.2
    Michael Kerrisk
        Recast discussion of blocking behavior in terms of threads
            semop() blocks the calling thread, not the process.
    Michael Kerrisk
        SEE ALSO: Add clone(2)
            Give reader a clue about CLONE_SYSVSEM.

shutdown.2
    Michael Kerrisk  [Eric Dumazet]
        Document EINVAL error (and associated bug)
            Eric Dumazet noted that EINVAL was not documented. Some further
            digging shows that it's also not diagnosed consistently.
            See https://bugzilla.kernel.org/show_bug.cgi?id=47111.

sigaction.2
    Michael Kerrisk
        Tweak SA_RESETHAND description

timer_settime.2
    Michael Kerrisk
        Small rewording around discussion of pointer arguments

wait4.2
    Adrian Bunk
        Note that these functions are nonstandard and recommend alternatives
            Some edits to Adrian's patch by mtk.
    Michael Kerrisk
        CONFORMING TO: Note SUS details for wait3()

gnu_get_libc_version.3
    Michael Kerrisk
        Remove unneeded "#define _GNU_SOURCE" from SYNOPSIS

pthread_kill.3
pthread_sigqueue.3
    Michael Kerrisk
        Remove wording "another"
            Writing "another thread" in these pages implies that these
            functions can't be used to send a signal to the calling thread
            itself, which is of course untrue.

sigvec.3
    Michael Kerrisk
        Add "int" arg to sv_handler definition in sigvec structure
    Michael Kerrisk
        Fix small error in discussion of blocking of signals
            The signal that causes the handler to be invoked is blocked,
            but saying "by default" implies that this can be changed via
            the API. It cannot. (One needs sigaction(2) for that.)

syslog.3
    Simon Josefsson
        Remove (apparently bogus) text claiming LOG_AUTH is deprecated
            LOG_AUTH is in POSIX, and widely available. There
            seems to be no basis to the claim it is deprecated.

            Quoting Simon:
                I cannot find any other source that claim LOG_AUTH is
                deprecated in any way.  LOG_AUTH is distinct from
                LOG_AUTHPRIV.  The GNU C Library manual only documents
                LOG_AUTH.  The header files contains both without any
                comment.  Common systems like Debian appear to refer to
                both auth and authpriv facilities in syslog configurations.
                Popular daemons appear to use both facilities.
                Both facilities are discussed in several RFCs.

            See https://bugzilla.kernel.org/show_bug.cgi?id=46091

ttyname.3
    Michael Kerrisk
        SEE ALSO: Add ctermid(3)

proc.5
    Michael Kerrisk
        Clarify header file related to 'flags' field of /proc/PID/stat
    Michael Kerrisk  [Frédéric Brière]
        Update description of 'starttime' field of /proc/PID/stat
            The unit of measurement changed from jiffies to clock ticks in
            Linux 2.6.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=675891
    Michael Kerrisk
        Document /proc/sys/kernel/kptr_restrict
    Michael Kerrisk [Kees Cook]
        Document /proc/sys/fs/protected_symlinks
            Based on text in Documentation/sysctl/fs.txt by Kees Cook
    Michael Kerrisk [Kees Cook]
        Document /proc/sys/fs/protected_hardlinks
            Based on text in Documentation/sysctl/fs.txt by Kees Cook

capabilities.7
    Michael Kerrisk
        Document interaction of CAP_SYSLOG and /proc/sys/kernel/kptr_restrict

ip.7
    Michael Kerrisk
        SEE ALSO: Add ipv6(7)
        SEE ALSO: Add icmp(7)

man-pages.7
    Michael Kerrisk
        Add some advice about disabling hyphenation in SEE ALSO

ld.so.8
    Michael Kerrisk
        Describe interpretation of slashes in dependency strings
    Michael Kerrisk
        Repeat note that LD_LIBRARY_PATH is ignored in privileged programs
            This point is already noted when discussing search order for
            libraries, but it's worth repeating under the specific discussion
            of LD_LIBRARY_PATH further down the page.
    Michael Kerrisk
        Add some details for LD_PRELOAD
        Note that LD_PRELOAD list separator can be space or colon


==================== Changes in man-pages-3.44 ====================

Released: 2012-11-07, Barcelona


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Bert Hubert <bert.hubert@netherlabs.nl>
David Prévot <taffit@debian.org>
James Youngman <jay@gnu.org>
Kees Cook <keescook@chromium.org>
Lars Wirzenius <liw@iki.fi>
Lucas De Marchi <lucas.de.marchi@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Rusty Russell <rusty@rustcorp.com.au>
Simon Paillard <spaillard@debian.org>
Thomas Habets <thomas@habets.se>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

delete_module.2
    Michael Kerrisk
        Rewrite to Linux 2.6+ reality
    Michael Kerrisk
        Change license and copyright
            There is now nothing left of the original FSF-copyrighted
            page. So, change the copyright and license.
    Michael Kerrisk  [Lucas De Marchi, Rusty Russell]
        Substantial reorganization after comments from Rusty Russell
            Rusty notes that O_NONBLOCK is almost always used in
            practice. Therefore, it would be better to reorganize
            the page to consider that "the default".

init_module.2
    Michael Kerrisk
        Rewrite to Linux 2.6+ reality
    Michael Kerrisk
        Change copyright and license
            Little of the original page now remains. Change
            copyright and license
    Michael Kerrisk  [Rusty Russell]
        Changes after review comments from Rusty Russell
    Kees Cook
        Add various pieces describing Linux 2.6+ behavior
            Pieces take from, or inspired by, a patch sent by Kees.

getauxval.3
    Michael Kerrisk
        Document getauxval() function added in glibc 2.16


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix: Use consistent capitalization in NAME section
            The line(s) in the NAME section should only use capitals
            where English usage dictates that. Otherwise, use
            lowercase throughout.

Various pages
    Michael Kerrisk
        Global fix: "userspace" ==> "user space" or "user-space"
            Existing pages variously use "userspace or "user space".
            But, "userspace" is not quite an English word.
            So change "userspace" to "user space" or, when used
            attributively, "user-space".


Changes to individual pages
---------------------------

clock_getres.2
clock_nanosleep.2
    Michael Kerrisk
        Linking with -lrt is no longer needed from glibc 2.17 onward

create_module.2
    Michael Kerrisk
        Note that this system call is present only in kernels before 2.6
    Michael Kerrisk
        Note that ENOSYS probably indicates kernel 2.6+

execve.2
    Michael Kerrisk
        Document treatment of PR_SET_PDEATHSIG on execve()
    Michael Kerrisk
        Document treatment of SECBIT_KEEP_CAPS securebits flag on execve()

fork.2
    Michael Kerrisk
        Note treatment of default timer slack value on fork()

getdomainname.2
    Simon Paillard  [Lars Wirzenius]
        Point out that these calls relate to NIS, not DNS
            See http://bugs.debian.org/295635

get_kernel_syms.2
    Michael Kerrisk
        Note that this system call is present only in kernels before 2.6

ipc.2
    Michael Kerrisk
        Update note on architectures that don't have ipc()
            Replace mention of ia64 with x86-64 and ARM.

link.2
    Michael Kerrisk
        Add EPERM error triggered by /proc/sys/fs/protected_hardlink

prctl.2
    Michael Kerrisk
        Mention Documentation/prctl/no_new_privs.txt for PR_SET_NO_NEW_PRIVS
    Kees Cook
        update seccomp sections for mode 2 (BPF)
            This adds a short summary of the arguments used
            for "mode 2" (BPF) seccomp.
    Michael Kerrisk
        Small improvements to PR_SET_SECCOMP discussion
            Note type of 'arg3' for SECCOMP_MODE_FILTER.
            Add pointer to Documentation/prctl/seccomp_filter.txt.
    Michael Kerrisk
        Note 'seccomp' semantics with respect to fork(), execve(), and prctl()
    Michael Kerrisk
        Document PR_SET_TIMERSLACK and PR_GET_TIMERSLACK
    Michael Kerrisk
        Reword PR_SET_NAME and PR_GET_NAME in terms of threads
            Plus tfix
    Kees Cook
        document PR_SET_NO_NEW_PRIVS, PR_GET_NO_NEW_PRIVS
            This adds a short description of the no_new_privs bit,
            as described in Documentation/prctl/no_new_privs.txt.

ptrace.2
    Michael Kerrisk
        Clarify that some operations are not present on all architectures
            PTRACE_GETREGS, PTRACE_SETGREFS, PTRACE_GETFPREGS,
            and PTRACE_GETSPREGS are not present on all architectures.
            PTRACE_SYSEMU and PTRACE_SYSEMU_SINGLESTEP are present only
            on x86.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=122383

query_module.2
    Michael Kerrisk
        Add a few words clarifying reference to /sys/module
    Michael Kerrisk
        Note that this system call is present only in kernels before 2.6
    Michael Kerrisk
        Note that ENOSYS probably indicates kernel 2.6+
    Michael Kerrisk
        SEE ALSO: Add modinfo(8) and lsinfo(8)
    Michael Kerrisk
        Move some information in NOTES to VERSIONS

socketcall.2
    Michael Kerrisk
        Update note on architectures that don't have socketcall()
            Replace mention of ia64 with x86-64 and ARM.

times.2
    Thomas Habets
        Recommend clock_gettime(2) as alternative to times(2)

clock_getcpuclockid.3
    Michael Kerrisk
        Linking with -lrt is no longer needed from glibc 2.17 onward

fts.3
    Simon Paillard  [James Youngman]
        Improve description of physical vs. logical tree walking
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=633505

getenv.3
    Michael Kerrisk
        SEE ALSO: add getauxval(3)

proc.5
    Michael Kerrisk
        Document /proc/meminfo
            Info mostly taken from Documentation/filesystems/proc.txt
            and Documentation/vm/hugetlbpage.txt.
    Michael Kerrisk
        Default for /proc/sys/fs/protected_{hardlinks,symlinks} is now 0
            The default setting of 1 in/proc/sys/fs/protected_hardlinks
            and /proc/sys/fs/protected_symlinks caused one too many
            breakages for Linus's taste, so commit 561ec64ae67e changed
            the default for both files to 0.
        Note system call error yielded by /proc/sys/fs/protected_symlinks
            Note that violating 'protected_symlinks' restrictions
            causes system calls to fail with the error EACCES.
    Michael Kerrisk
        Since Linux 2.6.27, /proc/sys/kernel/modprobe depends on CONFIG_MODULES

ipv6.7
    Bert Hubert
        Document IPV6_RECVPKTINFO

man-pages.7
    Michael Kerrisk
        Note rules for capitalization in NAME section

time.7
    Michael Kerrisk
        Add a subsection on timer slack

ld.so.8
    Michael Kerrisk
        SEE ALSO: add getauxval(3)


==================== Changes in man-pages-3.45 ====================

Released: 2012-12-21, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
Cyril Hrubis <chrubis@suse.cz>
David Prévot <taffit@debian.org>
Elie De Brauwer <eliedebrauwer@gmail.com>
Eric Dumazet <eric.dumazet@gmail.com>
Felipe Pena <felipensp@gmail.com>
Florian Weimer <fweimer@redhat.com>
Gao Feng <gaofeng@cn.fujitsu.com>
Jan Glauber <jang@linux.vnet.ibm.com>
Jim Paris <jim@jtan.com>
Jon Grant <jg@jguk.org>
Julien Cristau <jcristau@debian.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Rens van der Heijden <rens.vanderheijden@uni-ulm.de>
Simon Paillard <spaillard@debian.org>
Thierry Vignaud <thierry.vignaud@gmail.com>
Trevor Woerner <twoerner@gmail.com>
YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

s390_runtime_instr.2
    Jan Glauber
        New page for s390-specific s390_runtime_instr(2)

if_nameindex.3
    YOSHIFUJI Hideaki
        Document if_nameindex(3) and if_freenameindex(3)
    Michael Kerrisk
        Edits, improvements and corrections to Hideaki's page
    Michael Kerrisk
        Add an example program

if_nametoindex.3
    YOSHIFUJI Hideaki
        New page documenting if_nametoindex(3) and if_indextoname(3)


New and changed links
---------------------

if_freenameindex.3
    Michael Kerrisk
        New link to if_nameindex.3

if_indextoname.3
    Michael Kerrisk
        New link to if_nametoindex.3


Global changes
--------------

sysconf.3
cciss.4
    Michael Kerrisk
        Global fix: s/runtime/run time/


Changes to individual pages
---------------------------

clone.2
    Michael Kerrisk
        Since 2.6.30, CLONE_NEWIPC also supports POSIX message queues

delete_module.2
    Michael Kerrisk
        Small rewording of description of effect of O_TRUNC

getrlimit.2
    Michael Kerrisk  [Trevor Woerner]
        Document Linux's nonstandard treatment or RLIMIT_CPU soft limit
            Upon encountering the RLIMIT_CPU soft limit when a SIGXCPU handler
            has been installed, Linux invokes the signal handler *and* raises
            the soft limit by one second. This behavior repeats until the
            limit is encountered.  No other implementation that I tested
            (Solaris 10, FreeBSD 9.0, OpenBSD 5.0) does this, and it seems
            unlikely to be POSIX-conformant. The (Linux-specific)
            RLIMIT_RTTIME soft limit exhibits similar behavior.
    Michael Kerrisk
        Point reader at discussion of /proc/[pid]/limits in proc(5)

io_getevents.2
    Michael Kerrisk
        io_getevents() may cause segfault when called with invalid ctx_id
            For reference see: http://marc.info/?l=linux-aio&m=130089887002435&w=2

recv.2
    Michael Kerrisk  [Eric Dumazet]
        UNIX domain sockets support MSG_TRUNC since 3.4

sendmmsg.2
    Elie De Brauwer
        Add example program for sendmmsg()

stat.2
    Simon Paillard
        Clarify description of EOVERFLOW error
            The EOVERFLOW error is not only for st_size, but also
            inode and block size fields. See glibc source file
            sysdeps/unix/sysv/linux/xstatconv.c and kernel source
            file fs/stat.c. Also, fix bit/byte confusion
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=604928

syscalls.2
    Michael Kerrisk
        Update various references to "i386" to "x86"
    Michael Kerrisk
        Add s390_runtime_instr(2)

sysctl.2
    Michael Kerrisk
        Mention CONFIG_SYSCTL_SYSCALL
    Michael Kerrisk
        Calls to sysctl() log warnings to the kernel log since 2.6.24

syslog.2
    Michael Kerrisk
        Substantially reorganize discussion of commands
            Make the layout of the discussion of the commands
            more readable.
    Michael Kerrisk
        Add kernel symbolic 'type' names
    Michael Kerrisk
        Clarify SYSLOG_ACTION_SIZE_UNREAD semantics
            SYSLOG_ACTION_SIZE_UNREAD returns the number of bytes
            available for reading via SYSLOG_ACTION_READ.
    Michael Kerrisk
        Clarify where SYSLOG_ACTION_READ_ALL places data it reads
    Michael Kerrisk
        Clarify semantics of SYSLOG_ACTION_CLEAR
            The SYSLOG_ACTION_CLEAR command (5) does not really clear
            the ring buffer; rather it affects the semantics of what
            is returned by commands 3 (SYSLOG_ACTION_READ_ALL) and
            4 (SYSLOG_ACTION_READ_CLEAR).
    Michael Kerrisk
        Clarify discussion of privileges for commands 3 and 10
    Michael Kerrisk
        Add mention of CONFIG_LOG_BUF_SHIFT

wait.2
    Michael Kerrisk
        BUGS: Document odd waitid() behavior when 'infop' is NULL

getifaddrs.3
    Michael Kerrisk  [Julien Cristau]
        Update description of ifa_data to Linux 2.6+ reality
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=526778

memcmp.3
    Michael Kerrisk  [Jon Grant]
        Enhance RETURN VALUE text and remove redundant text from DESCRIPTION
            Note that sign of result equals sign of difference between
            first two bytes that differ (treated as "unsigned char")."

mkstemp.3
    Michael Kerrisk  [Florian Weimer]
        Deemphasize discussion of mode 066 in glibc 2.0.6
            Glibc 2.0.6 is now so ld that the discussion of details
            of that version can be deemphasized placing just under
            NOTES.

            See https://bugzilla.kernel.org/show_bug.cgi?id=51811

strcmp.3
    Michael Kerrisk  [Jon Grant]
        Enhance RETURN VALUE text and remove redundant text from DESCRIPTION
            Note that sign of result equals sign of difference between
            first two bytes that differ (treated as "unsigned char")."

ttyname.3
    Michael Kerrisk
        Fix confused text in ERRORS
            The existing text suggested that the ERRORS applied
            only for ttyname_r(). However, 2 of the 3 errors
            can occur for ttyname().

undocumented.3
    Michael Kerrisk
        Remove some now documented functions

proc.5
    Michael Kerrisk  [Jim Paris]
        Correct description of SwapFree in /proc/meminfo
    Michael Kerrisk
        Note change of /proc/[pid]/limits file permissions in 2.6.36

resolv.conf.5
    Simon Paillard
        Document IPv6 format for nameserver
            See: http://bugs.debian.org/610036

capabilities.7
    Michael Kerrisk  [Rens van der Heijden]
        Correct URL for POSIX.1e draft

ipv6.7
    Gao Feng
        Add description of getsockopt() for IPV6_MTU
            In IPv4,IP_MTU is only supported by getsockopt.
            In IPv6, we can use IPV6_MTU to set socket's MTU,
            but the return value of getsockopt() is the path MTU.

rtnetlink.7
    Michael Kerrisk  [Julien Cristau]
        Update description of IFLA_STATS to Linux 2.6+ reality
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=526778

socket.7
    Michael Kerrisk  [YOSHIFUJI Hideaki]
        Document 'sockaddr' and 'sockaddr_storage' types
    Andi Kleen
        Explain effect of SO_SNDTIMEO for connect()
            When SO_SNDTIMEO is set before connect(), then connect()
            may return EWOULDBLOCK when the timeout fires.


==================== Changes in man-pages-3.46 ====================

Released: 2013-01-27, Canberra


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andrew Perepechko <andrew_perepechko@xyratex.com>
Cédric Boutillier <cedric.boutillier@gmail.com>
Cyrill Gorcunov <gorcunov@openvz.org>
Daan Spitz <daan.f.spitz@gmail.com>
David Prévot <taffit@debian.org>
Elie De Brauwer <eliedebrauwer@gmail.com>
Garrett Cooper <yanegomi@gmail.com>
James Noble <James.Noble@daktronics.com>
Justin Lebar <justin.lebar@gmail.com>
Kees Cook <keescook@chromium.org>
Lucas De Marchi <lucas.demarchi@profusion.mobi>
Mark Hills <mark@pogo.org.uk>
Maxin B. John <maxin.john@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Michal Gorny <mgorny@gentoo.org>
Peter Budny <bigpeteb@gmail.com>
Peter Lekeynstein <lekensteyn@gmail.com>
Rusty Russell <rusty@rustcorp.com.au>
Samuel Thibault <sthibault@debian.org>
Sam Varshavchik <mrsam@courier-mta.com>
Shawn Landden <shawnlandden@gmail.com>
Simon Paillard <spaillard@debian.org>
Starlight <starlight.2013q1@binnacle.cx>
Theodore Ts'o <tytso@mit.edu>
Wolfgang Rohdewald <wolfgang@rohdewald.de>
Zsbán Ambrus <ambrus@math.bme.hu>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

kcmp.2
    Cyrill Gorcunov, Michael Kerrisk
        New page for kcmp(2)


Newly documented interfaces in existing pages
---------------------------------------------

init_module.2
    Michael Kerrisk  [Kees Cook, Rusty Russell, Lucas De Marchi]
        Document finit_module(2)
    Rusty Russell  [Lucas De Marchi, Kees Cook]
        Document finit_module() 'flags' argument
            Document MODULE_INIT_IGNORE_MODVERSIONS and
            MODULE_INIT_IGNORE_VERMAGIC. (Some edits by mtk.)


New and changed links
---------------------

finit_module.2
    Michael Kerrisk
        New link to init_module.2

__after_morecore_hook.3
__free_hook.3
__malloc_initialize_hook.3
__memalign_hook.3
__realloc_hook.3
    Michael Kerrisk
        New link to malloc_hook.3


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix: s/tty/terminal/


Changes to individual pages
---------------------------

clone.2
    Michael Kerrisk
        Add kernel versions for various CLONE_* constants
    Michael Kerrisk
        CLONE_NEWIPC governs mechanisms that don't have filesystem pathnames
    Michael Kerrisk
        CLONE_NEWIPC doesn't mount the POSIX MQ file system
    Michael Kerrisk
        Add an example program (CLONE_NEWUTS)
    Michael Kerrisk
        Some reworking of CLONE_NEWIPC text
            No substantial content changes.
    Michael Kerrisk
        SEE ALSO: add kcmp(2)
        SEE ALSO: add setns(2)

fallocate.2
    Michael Kerrisk
        FALLOC_FL_* flags are defined in glibc only since 2.18

getxattr.2
removexattr.2
setxattr.2
    Michael Kerrisk  [Andrew Perepechko, ]
        Note that ENOATTR is a synonym for ENODATA
            Various people have pointed out that strace(1) shows ENODATA
            for the case where the named attribute does not exist, or
            the process has no access to this attribute. ENODATA
            and ENOATTR are in fact defined as synonyms. Point this out
            in the man page, so that people understand the strace(1) info.

            See https://bugzilla.kernel.org/show_bug.cgi?id=51871

getxattr.2
listxattr.2
removexattr.2
setxattr.2
    Michael Kerrisk
        Put errors under ERRORS section
            The errno values on these pages were listed in a nonstandard
            way under the RETURN VALUE section. Put them in ERRORS sections.

init_module.2
    Michael Kerrisk  [Rusty Russell]
        ERRORS: Add errors for module signatures (EBADMSG, ENOKEY)

link.2
mkdir.2
mknod.2
open.2
rename.2
symlink.2
write.2
mkfifo.3
    Mark Hills
        Document EDQUOT error
            The return error EDQUOT is not documented in open(2), write(2),
            symlink(2) etc.

            Whether inodes or disk blocks are required for each function
            is something I based on received wisdom and BSD documentation,
            rather than tracing the code to the kernel. For symlink(2)
            this certainly depends on the file system type.

listxattr.2
    Michael Kerrisk  [Theodore Ts'o]
        Fix RETURN VALUE description
            On success, 0 may be returned, so change wording from
            "positive number" to "nonnegative number".

outb.2
    Michael Kerrisk
        Add SYNOPSIS

prctl.2
    Kees Cook
        Document PR_SET_PTRACER
            Document the Yama LSM's prctl handler that allows processes to
            declare ptrace restriction exception relationships via
            PR_SET_PTRACER.
    Michael Kerrisk
        Make it explicit that PR_SET_PTRACER replaces previous setting
            The attribute is a scalar, not a list.
    Shawn Landden
        Document EINVAL error for PR_SET_PTRACER
    Michael Kerrisk
        Document PR_GET_TID_ADDRESS

ptrace.2
    Michael Kerrisk
        Document PTRACE_O_EXITKILL
    Michael Kerrisk
        Place PTRACE_SETOPTIONS list in alphabetical order

query_module.2
    Michael Kerrisk
        Must be called using syscall(2)
            Yes, the call is way obsolete, but add this info
            for completeness.

recvmmsg.2
    Elie De Brauwer
        Add/correct kernel version info for recvmmsg() and MSG_WAITFORNONE
            This patch isolates the since/version related fixes as requested.
            This change introduces the following delta:
             * The page states it was added in 2.6.32 but it is only added
                2.6.33 (ref: http://kernelnewbies.org/Linux_2_6_33)
             * The MSG_WAITFORONE flag was in turn only added in 2.6.34
               (ref: http://kernelnewbies.org/Linux_2_6_34)
    Elie De Brauwer
        Add an example program

setns.2
    Michael Kerrisk
        Add example program

sigaction.2
    Michael Kerrisk  [Zsbán Ambrus]
        Note feature test macro requirements for 'siginfo_t'
            See https://bugzilla.kernel.org/show_bug.cgi?id=52931

syscalls.2
    Michael Kerrisk
        Add kern_features(2)
    Michael Kerrisk
        Add utrap_install(2)
            Sparc-specific, present since ancient times
    Michael Kerrisk
        Add finit_module(2)

sysctl.2
    Michael Kerrisk  [Garrett Cooper]
        ERRORS: EACCES as a synonym for EPRM
            See https://bugzilla.kernel.org/show_bug.cgi?id=46731
            and http://thread.gmane.org/gmane.linux.ltp/11413/focus=957635
                From: Garrett Cooper <yanegomi <at> gmail.com>
                Subject: Re: [LTP] [PATCH] sysctl03: sysctl returns EACCES after 2.6.33-rc1
                Newsgroups: gmane.linux.kernel, gmane.linux.ltp
                Date: 2010-03-04 18:35:33 GMT

unshare.2
    Michael Kerrisk
        Update NOTES on unimplemented flags
    Michael Kerrisk
        Fix text problems in description of CLONE_FS
    Michael Kerrisk
        SEE ALSO: add kcmp(2)
        SEE ALSO: add setns(2)
    Michael Kerrisk
        Reorder CLONE_NEWUTS entry in list

difftime.3
    Michael Kerrisk  [Michal Gorny]
        Remove crufty text about 'time_t' on "other systems"
            Back in 2006, some text came in via Debian patches that seems
            crufty. Remove it.

            See https://bugzilla.kernel.org/show_bug.cgi?id=46731

getaddrinfo.3
getnameinfo.3
    Michael Kerrisk  [Peter Budny]
        Fix some confused references to function names
            See https://bugzilla.kernel.org/show_bug.cgi?id=52741

getspnam.3
    Michael Kerrisk  [Wolfgang Rohdewald]
        ERRORS: Add EACCES
            See https://bugzilla.kernel.org/show_bug.cgi?id=52681

__setfpucw.3
    Michael Kerrisk
        Add proper page cross refs for alternate functions

core.5
proc.5
    Kees Cook
        Clarify suid_dumpable versus core_pattern
            In Linux 3.6, additional requirements were placed on core_pattern
            when suid_dumpable is set to 2. Document this and include commit
            references.
    Justin Lebar
        statm's "shared" field refers to pages backed by files
            I noticed that statm's "shared" field doesn't match the sum of
            all the "shared" entries in smaps [1].

            The kernel docs explain that statm's "shared" field is "number of
            pages that are shared (i.e. backed by a file)" [2].  smaps appears
            to call a page shared if it's mapped by at least two processes,
            which explains this discrepancy.

            I'm not a kernel hacker, but it appears to me they do mean "i.e."
            and not "e.g." in the statm description: In
            fs/proc/task_mmu.c::task_statm, I see

                *shared = get_mm_counter(mm, MM_FILEPAGES);

            Here's a patch which updates the man page to match the (hopefully
            correct) kernel docs.

            [1] https://bugzilla.mozilla.org/show_bug.cgi?id=807181
            [2] http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=blob;f=Documentation/filesystems/proc.txt;h=a1793d670cd01bd374eddf54ffdfc768504291ff;hb=HEAD

proc.5
    Kees Cook
        Put /proc/sys/kernel/hotplug in alphabetical order
    Kees Cook
        Document /proc/sys/kernel/dmesg_restrict
    Kees Cook
        Linux 3.4 changed permissions needed to change kptr_restrict
    Michael Kerrisk  [Samuel Thibault, Simon Paillard]
        Add field numbers for /proc/PID/stat
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=553413
        Add numbering to /proc/stat "cpu" fields
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=553413
    Michael Kerrisk
        Reorganize text describing /proc/stat "cpu" fields
    Michael Kerrisk
        Rewording of suid_dumpable text after comments from Kees Cook
    Michael Kerrisk  [Samuel Thibault, Simon Paillard]
        Add field numbers for /proc/[pid]/statm
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=553413
    Michael Kerrisk
        Document /proc/stat "cpu" "nice_guest" field
            Info taken from commit ce0e7b28fb75cb003cfc8d0238613aaf1c55e797
    Michael Kerrisk  [Peter Lekeynstein]
        Document /prod/[pid]/oom_score_adj
            Text taken directly from Documentation/filesystems/proc.txt,
            with some light editing.

            See https://bugzilla.kernel.org/show_bug.cgi?id=50421

shells.5
    Michael Kerrisk
        Add /etc/bash to list of example shells

ttytype.5
    Michael Kerrisk
        Add proper xref for termcap and terminfo pages

capabilities.7
    Michael Kerrisk
        Add kcmp(2) under CAP_SYS_PTRACE

man-pages.7
    Michael Kerrisk
        Update description of Section 7


==================== Changes in man-pages-3.47 ====================

Released: 2013-02-12, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

David Prévot <taffit@debian.org>
D. Barbier <bouzim@gmail.com>
Lennart Poettering <lennart@poettering.net>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Peter Schiffer <pschiffe@redhat.com>
Radek Pazdera <rpazdera@redhat.com>
Reuben Thomas <rrt@sc3d.org>
Shawn Landden <shawnlandden@gmail.com>
Simon Paillard <spaillard@debian.org>
Vince Weaver <vweaver1@eecs.utk.edu>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

perf_event_open.2
    Vincent Weaver
        New page documenting perf_event_open(2)

pthread_setname_np.3
    Chandan Apsangi, Michael Kerrisk
        New page for pthread_setname_np(3) and pthread_getname_np(3)

sln.8
    Michael Kerrisk  [Peter Schiffer]
        New page documenting the 'sln' command provided by glibc
            Inspired by a Red Hat downstream page, but with rather
            more detail.


Newly documented interfaces in existing pages
---------------------------------------------

prctl.2
    Michael Kerrisk  [Shawn Landden, Lennart Poettering]
        Document PR_SET_CHILD_SUBREAPER and PR_GET_CHILD_SUBREAPER

ip.7
    Radek Pazdera
        Add source-specific multicast sockopts
            This patch adds documentation of several source-specific multicast
            socket options that were added to kernel with implementation
            of IGMPv3 in 2.5.68.

            The following socket options were added:
              IP_ADD_SOURCE_MEMBERSHIP
              IP_DROP_SOURCE_MEMBERSHIP
              IP_BLOCK_SOURCE
              IP_UNBLOCK_SOURCE
              IP_MSFILTER


Pages moved across sections
---------------------------

getcontext.3
    Michael Kerrisk
        This page really belongs in Section 3 (moved from Section 2)

getdtablesize.3
    Michael Kerrisk
        Move from Section 2


New and changed links
---------------------

getcontext.2
    Michael Kerrisk
        Make link to page moved into Section 3

getdtablesize.2
    Michael Kerrisk
        Link to renamed getdtablesize.3

setcontext.2
    Michael Kerrisk
        Modify link to point to Section 3

pthread_getname_np.3
    Michael Kerrisk
        New link to new pthread_setname_np.3

setcontext.3
    Michael Kerrisk
        Link to getcontext page renamed into Section 3


Changes to individual pages
---------------------------

fallocate.2
    Michael Kerrisk
        SEE ALSO: add fallocate(1)

flock.2
    Michael Kerrisk
        SEE ALSO: add flock(1)

fork.2
    Michael Kerrisk
        SEE ALSO: add exit(2)

getpriority.2
    Michael Kerrisk
        BUGS: note that nice value is per-thread on Linux

getrlimit.2
    Michael Kerrisk
        SEE ALSO: add prlimit(1)

gettid.2
    Michael Kerrisk
        SEE ALSO: add various system calls that use thread IDs

ioprio_set.2
    Michael Kerrisk
        SEE ALSO: add ionice(1)

sched_setaffinity.2
    Michael Kerrisk
        SEE ALSO: add taskset(1)

sched_setparam.2
    Michael Kerrisk
        Scheduling policy and parameters are per-thread on Linux
            Direct the reader to the discussion in sched_setscheduler(2).

sched_setscheduler.2
    Michael Kerrisk
        Scheduling policy and parameters are per-thread on Linux
    Michael Kerrisk
        SEE ALSO: add chrt(1)

setsid.2
    Michael Kerrisk
        SEE ALSO: add setsid(1)

shmop.2
    Michael Kerrisk  [Peter Schiffer]
        ERRORS: Add EIDRM
            Taken from Red Hat downstream patch

sigaction.2
makecontext.3
    Michael Kerrisk
        Change getcontext/setcontext page ref to Section 3

signal.2
    Michael Kerrisk  [Reuben Thomas]
        Clarify System V vs BSD semantics for signal()

syscalls.2
    Michael Kerrisk
        The list on this page is not just syscalls common to all platforms
    Michael Kerrisk
        Add perfctr(2)
        Add ppc_rtas(2)
    Michael Kerrisk
        Add kernel version number of utrap_install(2)

unimplemented.2
    Michael Kerrisk  [Peter Schiffer]
        Remove mention of kernel version number in DESCRIPTION

inet.3
    Michael Kerrisk  [Peter Schiffer]
        Fix error in EXAMPLE using inet_aton()
            See https://bugzilla.redhat.com/show_bug.cgi?id=837090
            Patch taken from Red Hat downstream.

posix_fallocate.3
    Michael Kerrisk
        SEE ALSO: add fallocate(1)

regex.3
    Reuben Thomas
        Clarify details of matching
            The first is that it's far from clear that the end points of the
            complete string match are stored in the zero'th element of the
            regmatch_t array; secondly, the phrase "next largest substring
            match" is positively misleading, implying some sort of size
            ordering, whereas in fact they are ordered according to their
            appearance in the regex pattern.

scanf.3
    Michael Kerrisk
        Clarify meaning of "string conversions" for 'm' modifier
    Mike Frysinger
        Update %a vs %m documentation
            POSIX.1-2008 adopted the 'm' flag for dynamic allocation. Update
            page to cover it and relegate the glibc-specific 'a' flag to
            NOTES.

strtol.3
    Michael Kerrisk  [Peter Schiffer]
        Replace some bogus text about "thousands separator"
            See https://bugzilla.redhat.com/show_bug.cgi?id=652870

sysconf.3
    Michael Kerrisk  [Peter Schiffer]
        Use "_SC_PAGESIZE" consistently on page
            s/_SC_PAGE_SIZE/_SC_PAGESIZE/ in one instance.
            From Red Hat downstream patch.

nscd.conf.5
    Peter Schiffer
        Add max-db-size and auto-propagate descriptions, default values, + misc
             * added missing valid services (services and netgroup)
             * added many default values for options
             * reordered options according to the nscd.conf file
               (logical order)
             * added 2 missing options: max-db-size and auto-propagate

nsswitch.conf.5
    Peter Schiffer
        Mention initgroups db

proc.5
    Michael Kerrisk
        Document /proc/profile
    Michael Kerrisk  [Peter Schiffer]
        Update /proc/sys/fs/file-nr to include Linux 2.6 details
    Michael Kerrisk
        Clarify relationship between file-max and file-nr
            The third value in /proc/sys/fs/file-nr is the same as
            the value in /proc/sys/fs/file-max.
    Michael Kerrisk
        Note message written to kernel log when file-max limit is hit
            Info from Documentation/sysctl/fs.txt.
    Michael Kerrisk
        Mention lscpu(1) under discussion of /proc/cpuinfo

resolv.conf.5
    Michael Kerrisk  [Peter Schiffer]
        Document "single-request-reopen" option
            Taken from Red Hat downstream patch

            See https://bugzilla.redhat.com/show_bug.cgi?id=717770
            See http://thread.gmane.org/gmane.linux.man/3161

utmp.5
    Michael Kerrisk
        SEE ALSO: add utmpdump(1)

cpuset.7
    Simon Paillard
        Add missing 'cpuset.' prefix for some flags
            See kernel commit e21a05cb408bb9f244f11a0813d4b355dad0822e

svipc.7
    Michael Kerrisk
        SEE ALSO: add ipcmk(1), ipcrm(1), ipcs(1)

termio.7
    Michael Kerrisk
        SEE ALSO: add reset(1), setterm(1), stty(1), tty(4)

ld.so.8
    Michael Kerrisk  [Peter Schiffer]
        LD_VERBOSE does not work with ld.so --list and --verify
            From Red Hat downstream patch

            See https://bugzilla.redhat.com/show_bug.cgi?id=532629
    Michael Kerrisk
        SEE ALSO: add sln(8)

zdump.8
    Michael Kerrisk  [Peter Schiffer]
        Bring up to date with zdump --help
            Patch taken from Red Hat downstream.


==================== Changes in man-pages-3.48 ====================

Released: 2013-03-05, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andrey Vagin <avagin@openvz.org>
Aristeu Rozanski <aris@ruivo.org>
Colin Walters <walters@verbum.org>
Cyril Hrubis <chrubis@suse.cz>
Cyrill Gorcunov <gorcunov@openvz.org>
Daniel P. Berrange <berrange@redhat.com>
David Prévot <taffit@debian.org>
D. Barbier <bouzim@gmail.com>
Denys Vlasenko <vda.linux@googlemail.com>
Flavio Leitner <fbl@redhat.com>
Graham Gower <graham.gower@gmail.com>
Ivana Varekova <varekova@redhat.com>
Kai Kunschke <kai@kunfoo.org>
Marcela Maslanova <mmaslano@redhat.com>
Marc Lehmann <debian-reportbug@plan9.de>
Marshel Abraham <Marshel.Abraham@in.bosch.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Nathan Stratton Treadway <kernelbugs@nathanst.com>
Pavel Emelyanov <xemul@parallels.com>
Peter Schiffer <pschiffe@redhat.com>
Simon Heimberg <simohe@besonet.ch>
Simon Paillard <spaillard@debian.org>
Török Edwin <edwintorok@gmail.com>
Ulrich Drepper <drepper@redhat.com>
Zack Weinberg <zackw@panix.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

getunwind.2
    Marcela Maslanova
        New page documenting getunwind(2)
            Taken from Red Hat downstream man pages set
    Michael Kerrisk
        Much rewriting
            Some text taken from arch/ia64/kernel/unwind.c.

perfmonctl.2
    Ivana Varekova
        New page documenting IA-64-specific perfmonctl(2)
            Taken from Red Hat downstream man pages
    Michael Kerrisk
        Rework discussion of PFM_CREATE_CONTEXT
        Add VERSIONS and CONFORMING TO
        Note that there is no glibc wrapper
        Remove PFM_CREATE_EVTSETS, PFM_DELETE_EVTSETS, PFM_GETINFO_EVTSETS
            These don't exist, and it appears they never have.
        Fix argument types for PFM_WRITE_PMCS, PFM_WRITE_PMDS, PFM_READ_PMDS
            The types that were being used don't exist!
        Briefly document PFM_GET_FEATURES, PFM_DEBUG, PFM_GET_PMC_RESET_VAL

gai.conf.5
    Ulrich Drepper
        New page documenting gai.conf
            Taken from Red Hat downstream pages

nss.5
    Ulrich Drepper
        New page describing nss.conf


Newly documented interfaces in existing pages
---------------------------------------------

clock_getres.2
    Cyril Hrubis
        Document CLOCK_REALTIME_COARSE and CLOCK_MONOTONIC_COARSE
    Cyril Hrubis
        Document CLOCK_BOOTTIME
    Michael Kerrisk
        Some improvements to CLOCK_BOOTTIME description

ptrace.2
    Denys Vlasenko
        Document PTRACE_GETREGSET, PTRACE_SETREGSET, PTRACE_SEIZE, and friends
            Document PTRACE_GETREGSET, PTRACE_SETREGSET,
            PTRACE_SEIZE, PTRACE_INTERRUPT, and PTRACE_LISTEN.


New and changed links
---------------------

fattach.2
fdetach.2
getmsg.2
isastream.2
putmsg.2
    Michael Kerrisk  [Peter Schiffer]
        New link to unimplemented.2
            Taken from Red Hat downstream.

            See https://bugzilla.redhat.com/show_bug.cgi?id=436407


Global changes
--------------

Many pages
    Michael Kerrisk
        Global fix: remove unneeded double quotes in .SH headings

Many pages
    Michael Kerrisk
        Global fix: remove unneeded double quotes in .SS headings

Many pages
    Michael Kerrisk
        Global fix: use consistent capitalization in .SS headings
            Capitalization in .SS sections across pages (and sometimes even
            within a single page) is wildly inconsistent. Make it consistent.
            Capitalize first word in heading, but otherwise use lower case,
            except where English usage (e.g., proper nouns) or programming
            language requirements (e.g., identifier names) dictate otherwise.

Many pages
    Michael Kerrisk  [Denys Vlasenko]
        Remove double blank lines in output

Various pages
    Michael Kerrisk
        Fix order of SH sections


Changes to individual pages
---------------------------

accept.2
    Michael Kerrisk
        NAME: Add "accept4"

access.2
    Colin Walters
        Note that access() may also fail for FUSE
            Since in some cases (e.g. libguestfs's guestmount) it also has the
            semantics where files can appear owned by root, but are actually
            mutable by the user, despite what one might infer from the Unix
            permissions.

getpeername.2
    Michael Kerrisk  [Kai Kunschke]
        Clarify semantics of getpeername() for datagram sockets
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=674034

getuid.2
    Michael Kerrisk
        Remove duplicate section heading

mmap.2
    Cyril Hrubis
        Add note about partial page in BUGS section
            This adds a note about Linux behavior with partial page at the end
            of the object. The problem here is that a page that contains only
            part of a file (because the file size is not multiple of PAGE_SIZE)
            stays in page cache even after the mapping is unmapped and the file
            is closed. So if some process dirties such page, other mappings
            will see the changes rather than zeroes.
    Michael Kerrisk  [Török Edwin]
        Some 'flags' values require a feature test macro to be defined
            Add text to NOTES noting that some MAP_* constants are
            defined only if a suitable feature test macro is defined.
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=542601
    Cyril Hrubis
        Document EOVERFLOW error

open.2
    Michael Kerrisk
        Clarify list of file creation flags
            POSIX.1-2008 TC1 clarified this, so that O_CLOEXEC,
            O_DIRECTORY, and O_NOFOLLOW are also in this list.

prctl.2
    Cyrill Gorcunov
        Add some details for PR_GET_TID_ADDRESS

read.2
    Michael Kerrisk  [Zack Weinberg]
        Clarify interaction of count==0 and error checking
            POSIX deliberately leaves this case open, so the man
            page should be less specific about what happens.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=533232
    Michael Kerrisk  [Marc Lehmann]
        Remove crufty text about O_NONBLOCK on files
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=700529
    Michael Kerrisk
        Clarify details for seekable files

unimplemented.2
    Michael Kerrisk  [Peter Schiffer]
        Add various STREAMS interfaces to NAME
            Taken from Red Hat downstream.

            See https://bugzilla.redhat.com/show_bug.cgi?id=436407

cexp2.3
    Michael Kerrisk
        Still does not exist in glibc 2.17

exit.3
    Michael Kerrisk
        Note that a call to execve() clears exit handler registrations

getaddrinfo.3
    Michael Kerrisk
        SEE ALSO: Add gai.conf(5)

malloc_trim.3
    Michael Kerrisk
        Remove duplicate section title

printf.3
    Marshel Abraham  [Graham Gower, Graham Gower]
        Fix error handling in example code
            See https://bugzilla.kernel.org/show_bug.cgi?id=23282

pthread_yield.3
    Michael Kerrisk  [Aristeu Rozanski]
        Add _GNU_SOURCE feature test macro to SYNOPSIS

resolver.3
resolv.conf.5
    Michael Kerrisk  [Nathan Stratton Treadway, Simon Heimberg]
        RES_DEBUG is only available if glibc is compiled with debug support
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=692136
            and https://bugzilla.kernel.org/show_bug.cgi?id=43061

strtol.3
    Michael Kerrisk  [Peter Schiffer]
        Remove crufty text from previous fix

core.5
    Michael Kerrisk
        Document CONFIG_COREDUMP

capabilities.7
    Andrey Vagin
        Nonexistent bits are no longer shown as set in /proc/PID/status Cap*

inotify.7
    Michael Kerrisk
        A monitoring process can't easily distinguish events triggered by itself

ip.7
    Flavio Leitner  [Peter Schiffer]
        Improve explanation about calling listen() or connect()

man-pages.7
    Michael Kerrisk
        Describe rules for capitalization in .SS headings

rtnetlink.7
    Pavel Emelyanov
        Add info about ability to create links with given index
            Since kernel v3.7 the RTM_NEWLINK message now accepts nonzero
            values in ifi_index field. Mention this fact in the respective
            rtnetlink.7 section.

socket.7
    Pavel Emelyanov
        SO_BINDTODEVICE is now readable
            SO_BINDTODEVICE is readable since kernel 3.8.


==================== Changes in man-pages-3.49 ====================

Released: 2013-03-10, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Michael Kerrisk <mtk.manpages@gmail.com>


Global changes
--------------

The goal of the changes below to consistently format copyright
and license information in the comments in the page source
at the top of each page. This allows for easy scripting to
extract that information. Following these changes the comments
the top of the page source should now consistently have the form:

    .\" <copyright info, possibly spread over several lines>
    .\"
    .\" %%%LICENSE_START(<license-type>)
    .\" <license text>
    .\" %%%LICENSE_END
    .\" <other comments>

Note that the 'license-type' is merely descriptive.  Its purpose is
to simplify scripting for the purpose of gathering statistics on
types of licenses used in man-pages.  It is NOT a statement about
the actual licensing of the page; that license is contain INSIDE the
LICENSE_START...LICENSE_END clause.

All pages
    Michael Kerrisk
        Add a LICENSE_START()...LICENSE_END clause in source at
        top of each page that encapsulates the license text.
    Michael Kerrisk
        Put copyright info at top of page, followed by blank line and LICENSE

Various pages
    Michael Kerrisk
         Update info in source comments on where to get a copy of the GPL

Various pages
    Michael Kerrisk
        Remove "Hey Emacs" comment in page source
            Only certain pages have this; there is no consistency, so
            remove it from all pages
    Michael Kerrisk
        Remove "-*- nroff -*-" comment at top of source


==================== Changes in man-pages-3.50 ====================

Released: 2013-03-15, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andrey Vagin <avagin@openvz.org>
Bernhard Kuemel <bernhard@bksys.at>
Elie De Brauwer <eliedebrauwer@gmail.com>
Erik Saule <erik.saule@bmi.osu.edu>
Florian Weimer <fweimer@bfk.de>
Friedrich Delgado Friedrichs <friedel@nomaden.org>
Jonathan Nieder <jrnieder@gmail.com>
Jose Luis Domingo Lopez <debian@24x7linux.com>
Mark R Bannister <mark@proseconsulting.co.uk>
Michael Kerrisk <mtk.manpages@gmail.com>
Sam Varshavchik <mrsam@courier-mta.com>
Simon Paillard <spaillard@debian.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

canonicalize_file_name.3
    Michael Kerrisk
        Rewrite page, adding much more detail


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix: s/END_LICENSE/LICENSE_END/

Various pages
    Michael Kerrisk
        Global fix: s/bitmask/bit mask/


Changes to individual pages
---------------------------

getent.1
    Mark R Bannister
        netgroup description incorrectly refers to initgroups

capget.2
    Michael Kerrisk
        Update URL for libcap

fork.2
    Michael Kerrisk
        Port access permission bits (ioperm()) are turned off in the child

futex.2
    Michael Kerrisk
        'timeout' is a minimum duration that the call will wait, not a maximum

ioperm.2
    Michael Kerrisk
        Note that iopl() level of 3 is needed to access ports
    Michael Kerrisk
        'num' is *bits* not bytes!
    Michael Kerrisk
        Linux 2.6.8 lifted the port limit to 65,536
            See http://article.gmane.org/gmane.linux.kernel/202624/
            From: Stas Sergeev <stsp <at> aknet.ru>
            Subject: [patch][rfc] Larger IO bitmap
            Date: 2004-05-07 19:55:03 GMT
    Michael Kerrisk
        ioperm() operates on the calling *thread* (not process)
    Michael Kerrisk
        Clarify meaning of 'turn_on' argument
            Plus form formatting fixes.
    Michael Kerrisk
        Clarify that default state of permission bits in child is off
    Michael Kerrisk
        NOTES: add mention of /proc/ioports
    Michael Kerrisk
        SEE ALSO: add outb(2)

iopl.2
    Michael Kerrisk
        CAP_SYS_RAWIO is required to *raise* the I/O privilege level
    Michael Kerrisk
        Clarify that the two least significant bits of 'level' are what matter
    Michael Kerrisk
        SEE ALSO: add outb(2)

syscalls.2
    Michael Kerrisk
        Add version information for all (other) syscalls
    Michael Kerrisk
        Add perfmonctl(2)

futimes.3
    Michael Kerrisk  [Jonathan Nieder]
        ERRORS: Add ENOSYS for lutimes()
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=620746

getpass.3
    Michael Kerrisk  [Erik Saule]
        Suggest use of the ECHO flag as an alternative
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=644261

realpath.3
    Michael Kerrisk
        Document GNU extensions for EACCES and ENOENT errors

stdarg.3
    Michael Kerrisk  [Friedrich Delgado Friedrichs]
        Describe va_copy()
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=575077

termios.3
    Michael Kerrisk  [Bernhard Kuemel]
        Mention that noncanonical mode does not do input processing
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=643854

random.4
    Elie De Brauwer
        Document write and document the ioctl interface of /dev/random
            The update consists out of two parts:
             - a minor thing which just documents what happens if a write to
               /dev/(u)random is performed, which is used in the example
               script but not explicitly mentioned.
             - the other (biggest) part is the documentation of the ioctl()
               interface which /dev/(u)random exposes. This ioctl() lives in
               drivers/char/random.c and the primitives can be found in
               include/linux/random.h

            One comment remains, there used to be an RNDGETPOOL ioctl() which
            disappeared in v2.6.9. I found two patches on the net:
            - http://www.kernel.org/pub/linux/kernel/people/akpm/patches/2.6/2.6.8.1/2.6.8.1-mm4/broken-out/dev-random-remove-rndgetpool-ioctl.patch
            - https://lkml.org/lkml/2004/3/25/168

            But as far as I can tell the first one got applied but the 2nd
            one seems more correct. The result is that even today one can
            still find traces of the RNDGETPOOL ioctl() in the header files.
            Is this there for historical reasons or because it might break
            userspace, even though using it will just give an EINVAL.

bootparam.7
    Jose Luis Domingo Lopez
        Document 'rootfstype' option
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=182014

capabilities.7
    Michael Kerrisk
        Add various pieces under CAP_SYS_RAWIO
            Info obtained by grepping the kernel source.
    Michael Kerrisk
        Add CAP_SYS_RESOURCE /proc/PID/oom_score_adj case

netlink.7
    Andrey Vagin
        Add a note about broadcast messages to multiple groups

socket.7
    Michael Kerrisk  [Florian Weimer]
        Define _GNU_SOURCE to obtain the definition of 'struct ucred'
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=572210


==================== Changes in man-pages-3.51 ====================

Released: 2013-04-17, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andreas Jaeger <aj@suse.de>
Andrew Clayton <andrew@digital-domain.net>
Brian M. Carlson <sandals@crustytoothpaste.net>
Changhee Han <ch0.han@lge.com>
Cyril Hrubis <chrubis@suse.cz>
Damien Grassart <damien@grassart.com>
David Prévot <taffit@debian.org>
Denis Barbier <bouzim@gmail.com>
Jeff Moyer <jmoyer@redhat.com>
Krzysztof Konopko <krzysztof.konopko@gmail.com>
Kyle McMartin <kyle@mcmartin.ca>
Mark H Weaver <mhw@netris.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Nicolas Hillegeer <nicolas@hillegeer.com>
Pavel Emelyanov <xemul@parallels.com>
Peter Schiffer <pschiffe@redhat.com>
Radek Pazdera <rpazdera@redhat.com>
Ralph Loader <suckfish@ihug.co.nz>
Simon Paillard <spaillard@debian.org>
The Wanderer <wanderer@fastmail.fm>

Apologies if I missed anyone!


Newly documented interfaces in existing pages
---------------------------------------------

sched_rr_get_interval.2
    Michael Kerrisk
        Document /proc/sys/kernel/sched_rr_timeslice_ms

proc.5
    Pavel Emelyanov
        Document /proc/[pid]/map_files directory
            This directory was added in Linux v3.3 and provides info about
            files being mmap-ed in a way very similar to how /proc/[pid]/fd
            works.

            v2: Added examples of how links look like and noted dependency
            on kernel config option CONFIG_CHECKPOINT_RESTORE.
    Michael Kerrisk
        Document /proc/sys/kernel/shm_rmid_forced

capabilities.7
    Michael Kerrisk
        Document /proc/sys/kernel/cap_last_cap


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix: fix placement of word "only"

Various pages
    Simon Paillard
        License headers: consistent format

Various pages
    Michael Kerrisk
        Global fix: s/since kernel/since Linux/

Various System V IPC pages in Section 2
    Michael Kerrisk
        Add "System V" to .TH line and text
            Make it clear that these pages relate to System V IPC,
            not POSIX IPC.


Changes to individual pages
---------------------------

access.2
    Michael Kerrisk  [The Wanderer]
        Clarify RETURN VALUE for F_OK
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=705293

alarm.2
    Michael Kerrisk
        Correct the description of behavior when 'seconds' is 0

clone.2
    Michael Kerrisk  [Peter Schiffer]
        Add prototype for syscall to SYNOPSIS
            And further clarify the distinction between the system call
            and the wrapper function in the introductory text.
    Michael Kerrisk
        Update feature test macro requirements
            The requirements quietly changed in glibc 2.14

            See also http://www.sourceware.org/bugzilla/show_bug.cgi?id=4749
    Michael Kerrisk  [Mike Frysinger]
        Clarify differences between clone2() syscall and wrapper function
    Michael Kerrisk  [Mike Frysinger]
        Note those architectures where the sys_clone argument order differs
    Michael Kerrisk  [Mike Frysinger]
        Add short subsection noting that blackfin, m68k, and sparc are different
    Michael Kerrisk
        Move clone2() text to subsection in description
            The description of ia64 clone2() should follow the discussion
            of the raw system call interface.
    Michael Kerrisk
        Change subhead for ia64 discussion

getcpu.2
    Michael Kerrisk
        Recommend that 'tcache' should be specified as NULL nowadays

io_cancel.2
    Jeff Moyer, Michael Kerrisk  [Cyril Hrubis]
        Improve description

io_destroy.2
    Jeff Moyer
        Improve description
            The description was rather vague, citing a "list of I/O contexts"
            and stating that it "can" cancel outstanding requests.  This
            update makes things more concrete so that the reader knows exactly
            what's going on.

io_getevents.2
    Jeff Moyer
        The 'timeout' argument is not updated
            I looked back through the kernel code, and the timeout was
            never updated in any case.  I've submitted a patch upstream
            to change the comment above io_getevents.

io_setup.2
    Jeff Moyer
        Clarify nr_events
            nr_events is technically the number of completion events that can
            be stored in the completion ring.  The wording of the man page:
            "capable of receiving at least nr_events" seems dubious to me,
            only because I worry that folks might interpret that to mean
            'nr_events' total, instead of 'nr_events' concurrently.

            Further, I've added information on where to find the per-user
            limit on 'nr_events', /proc/sys/fs/aio-max-nr.  Let me know if
            you think that is not relevant.

listxattr.2
    Michael Kerrisk
        Explain use of 'size' argument

lseek.2
    Michael Kerrisk  [Andreas Jaeger]
        _GNU_SOURCE must be defined to get SEEK_DATA and SEEK_HOLE definitions
            See http://sourceware.org/bugzilla/show_bug.cgi?id=15312

mmap.2
    Michael Kerrisk
        Add pointers to relevant /proc files described in proc(5)

posix_fadvise.2
pread.2
readahead.2
sync_file_range.2
truncate.2
    Michael Kerrisk
        Refer to syscall(2) for ABI semantics on certain 32-bit architectures
            Also: in sync_file_range.2 and posix_fadvise.2 remove description
            of conventional calling signature as flawed, and in
            posix_fadvise.2, de-emphasize focus on ARM, and rather phrase
            as a more general discussion of certain architectures.

readdir.2
    Michael Kerrisk
        readdir(2) doesn't exist on x86-64

semop.2
    Michael Kerrisk
        Clarify the discussion of 'semadj'

shmctl.2
    Michael Kerrisk
        Refer to proc(5) for description of /proc/sys/kernel/shm_rmid_forced

syscall.2
    Changhee Han
        Add notes that caution users when passing arguments to syscall()
            For example, passing 'long long' on ARM-32 requires special
            treatment.
    Mike Frysinger [Michael Kerrisk]
        Document the exact calling convention for architecture system calls
    Mike Frysinger  [Kyle McMartin]
        Add PA-RISC details under calling conventions
    Michael Kerrisk  [Mike Frysinger]
        Refine discussion of ARM and other ABIs

syscalls.2
    Michael Kerrisk
        Update kernel version number at start of list

umask.2
    Michael Kerrisk
        SEE ALSO: add acl(5)

unshare.2
    Michael Kerrisk
        Update feature test macro requirements
            The requirements quietly changed in glibc 2.14

            See also http://www.sourceware.org/bugzilla/show_bug.cgi?id=4749

fopencookie.3
    Michael Kerrisk  [Ralph Loader]
        Correct definition of cookie_io_functions_t

pthread_setname_np.3
    Andrew Clayton
        The thread argument is passed in by value

readir.3
seekdir.3
telldir.3
    Michael Kerrisk
        Eliminate the implication that these functions deal with "offsets"
            The directory position dealt with by the readdir() and
            friends is not a simple file offset in modern file systems.
            Typically, it is some kind of cookie value. Add text and
            make other changes to these pages to eliminate the
            implication that this is an offset, and warn the reader
            that directory positions should be treated strictly as
            opaque values.

            In the process, rename the 'offset' argument of seekdir(3)
            to 'loc', and add some text to readdir(3) to note that
            the 'd_off' field is the same value returned by telldir(3)
            at the current directory position.

            See also https://lwn.net/Articles/544298/

scalb.3
    Mark H Weaver
        Fix prototypes for scalbf() and scalbl()

sched_getcpu.3
    Michael Kerrisk
        Update feature test macro requirements
            The requirements quietly changed in glibc 2.14

            See also http://www.sourceware.org/bugzilla/show_bug.cgi?id=4749

ualarm.3
    Michael Kerrisk  [Nicolas Hillegeer]
        Add note on the behavior when 'usecs' is zero
            POSIX.1-2001 does not specify the behavior in this case
            and no other system that I checked documented the behavior.
            Probably, most or all systems do what Linux does in this
            case: cancel any pending alarm, just as alarm(0) does.
            Add that info in NOTES.

elf.5
    Mike Frysinger
        Add byte positions for all EI_xxx fields
            When describing e_ident, most of the EI_xxx defines mention the
            exact byte number.  This is useful when manually hacking an ELF
            with a hex editor.  However, the last few fields don't do this,
            which means you have to count things up yourself.
            Add a single word to each so you don't have to do that.

proc.5
    Michael Kerrisk
        Refer to sched_rr_get_interval(2) for info on sched_rr_timeslice_ms
            Since Linux 3.9, /proc/sys/kernel/sched_rr_timeslice_ms can
            be used to change the SCHED_RR quantum.
    Michael Kerrisk
        SEE ALSO: Add sysctl(8)
    Krzysztof Konopko
        Simplify the example of printing out environ
            The binutils package contains a very handy utility to
            print out null-byte delimited strings from a file.  This
            can replace a rather complex expression with cat(1)
            provided as an example for printing out /proc/[pid]/environ.
    Michael Kerrisk
        Update /proc/PID/maps example
            Update to 64-bit example that includes "[heap]", "[stack],
            and "[vdso]"
    Michael Kerrisk
        Formatting fixes for /proc/PID/maps
    Mike Frysinger
        Document the "pathname" field of /proc/PID/maps
    Michael Kerrisk
        Add reference to capabilities(7) for /proc/sys/kernel/cap_last_cap
    Michael Kerrisk
        /proc/PID/maps: add a reference to mmap(2)

ip.7
    Radek Pazdera
        Document IP_MULTICAST_ALL
            This commit adds documentation for the IP_MULTICAST_ALL socket
            option.

            The option was added to the Linux kernel in 2.6.31:

                Author Nivedita Singhvi <niv@us.ibm.com>
                Commit f771bef98004d9d141b085d987a77d06669d4f4f

            The description is based on a previous one [3] posted by the
            original author of the code -- Nivedita, but it is slightly
            re-worded.

            I tested it myself and it works as described.

            References:
                [1] http://lxr.free-electrons.com/source/net/ipv4/ip_sockglue.c#L972
                [2] http://lxr.free-electrons.com/source/net/ipv4/igmp.c#L2267
                [3] http://patchwork.ozlabs.org/patch/28902/

units.7
    Brian M. Carlson
        units should use an actual µ
            The units(7) man page uses an ASCII u in place of the actual Greek
            letter mu.  Since we're in the twenty-first century, with
            UTF-8-compatible terminals and terminal emulators, we should use
            the actual letter µ instead of an ASCII approximation.

            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=704787


==================== Changes in man-pages-3.52 ====================

Released: 2013-07-04, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Adrian Bunk <bunk@kernel.org>
Andrea Remondini <andrea@undeadlinks.com>
Anthony Foiani <anthony.foiani@gmail.com>
Brian Norris <computersforpeace@gmail.com>
Cyril Hrubis <chrubis@suse.cz>
Dan Jacobson <jidanni@jidanni.org>
David Prévot <taffit@debian.org>
Eric S. Raymond <esr@thyrsus.com>
Georg Sauthoff <mail@georg.so>
Jeff Moyer <jmoyer@redhat.com>
Jérémie Galarneau <jeremie.galarneau@efficios.com>
Jon Grant <jg@jguk.org>
Manuel Traut <manut@linutronix.de>
Марк Коренберг <socketpair@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Pavel Emelyanov <xemul@parallels.com>
Peng Haitao <penght@cn.fujitsu.com>
Peter LaDow <petela@gocougs.wsu.edu>
Petr Gajdos <pgajdos@suse.cz>
Regid <regid23@nt1.in>
Siddhesh Poyarekar <siddhesh@redhat.com>
Simone Piccardi <piccardi@truelite.it>
Simon Paillard <spaillard@debian.org>
Vince Weaver <vincent.weaver@maine.edu>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


Newly documented interfaces in existing pages
---------------------------------------------

perf_event_open.2
    Vince Weaver
        Add PERF_IOC_FLAG_GROUP documentation
            The perf_event_open() ENABLE/DISABLE/RESET ioctls can take an
            argument, PERF_IOC_FLAG_GROUP.  This wasn't documented at all
            until about a year ago (despite the support being there from
            the beginning) so I missed this when initially writing
            the man page.

socket.7
    Pavel Emelyanov, Michael Kerrisk
        Document SO_PEEK_OFF option
            Since Linux 3.4 there appeared an ability to specify the
            offset in bytes from which the data will be MSG_PEEK-ed.
            Describe this socket option in the socket(7) page, where
            all the other socket options are described.


Global changes
--------------

Various pages
    Michael Kerrisk
        Convert inline formatting (\fX...\fP) to dot-directive formatting

readdir.2
asprintf.
getline.3
getlogin.3
pthread_setname_np.3
readdir.3
strerror.3
    Michael Kerrisk  [Jon Grant]
        Clarify that terminating null byte is '\0'


Changes to individual pages
---------------------------

execve.2
    Peter LaDow
       Add envp to the Linux notes about NULL pointers
            During the review of static analysis results, we discovered a
            functional, but non-portable, use of execve().  For example:

                char *cmd[] = { "/path/to/some/file", NULL };
                execve(cmd[0], cmd, NULL);

            The call succeeds.  Yet, the static analysis tool (rightly)
            pointed out that envp could be dereferenced.  But digging into
            glibc and the kernel, it appears that like argv, envp when NULL
            is treated as if it were an empty list.

            So, to clear things up, I'm submitting this patch to update the
            man page to indicate that envp is treated like argv.

fallocate.2
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

io_setup.2
    Cyril Hrubis  [Jeff Moyer]
        Clarify the nr_events parameter
            Currently the io_setup.2 man page describes what the kernel really
            does, i.e., that the resulting context may be able to hold more
            than the 'nr_event's operations because the memory allocated in
            kernel is rounded to be multiple of page size.

            It is better not to expose this implementation detail and
            simply state that the resulting context is suitable for
            'nr_events' operations.

perf_event_open.2
    Vince Weaver
        Clarify the perf_event_open() wakeup_events/wakeup_watermark fields
            Clarify the perf_event_open() wakeup_events/wakeup_watermark
            fields a bit, based on info from kernel commit cfeb1d90a1b1.
    Vince Weaver
        Update to match the Linux 3.10 release
            This patch updates the perf_event_open() documentation to include
            new interfaces added in the 3.10 kernel.

            It also documents a few [To be documented] instances left over
            from the 3.7 kernel.
    Vince Weaver
        Small correction to description of 'flags' argument

prctl.2
    Michael Kerrisk
        Note equivalents of PR_SET_NAME
            pthread_setname_np() and pthread_getname_np() and
            /proc/self/task/TID/comm provide access to the same
            attribute.

pread.2
    Michael Kerrisk  [Марк Коренберг]
        pread() and pwrite() are especially useful in multithreaded applications

recv.2
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

semctl.2
    Michael Kerrisk  [Simone Piccardi]
        'sem_nsems' is 'unsigned long' since Linux 2.4

shmget.2
    Michael Kerrisk
        Rewrite RETURN VALUE and mention that 'errno' is set on error

sigaction.2
    Michael Kerrisk  [Brian Norris]
        RETURN VALUE: mention that 'errno' is set on error

signal.2
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

sigpending.2
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

sigprocmask.2
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

sigsuspend.2
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

syscall.2
    Mike Frysinger
        Document s390/s390x calling convention

a64l.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function l64a() is not thread safe.

abs.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions abs(), labs(), llabs() and imaxabs() are
            thread-safe.

aio_error.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function aio_error() is thread safe.

aio_return.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function aio_return() is thread safe.

alloca.3
    Adrian Bunk
        Correct information on getting non-inlined version with gcc+glibc
            - remove the incorrect information that -fno-builtin would help
            - add -std=c11 to the list of strict options
            - emphasize more that both the gcc option and not including
              alloca.h are needed
            - add the #ifdef from the glibc alloca.h to make the situation
              clearer

bindresvport.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            Before glibc 2.17, bindresvport() is not thread-safe.
            Since glibc 2.17, it is thread-safe, the patch can refer to URL:
            http://sourceware.org/git/?p=glibc.git;a=commit;h=f6da27e53695ad1cc0e2a9490358decbbfdff5e5

canonicalize_file_name.3
    Michael Kerrisk
        Put CONFORMING TO section in right location

catgets.3
    Michael Kerrisk  [Jon Grant]
        Clarify that null byte is '\0'

ceil.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions ceil(), ceilf() and ceill() are thread safe.

cimag.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions cimag(), cimagf() and cimagl() are thread safe.

clock_getcpuclockid.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function clock_getcpuclockid() is thread safe.

conj.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions conj(), conjf() and conjl() are thread safe.

crypt.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function crypt() is not thread safe.

ctermid.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function ctermid() is thread safe with exceptions.

dirfd.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

drand48.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions drand48(), erand48(), lrand48(), nrand48(),
            mrand48(), jrand48(), srand48(), seed48() and lcong48() are
            not thread safe.

ecvt.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions ecvt() and fcvt() return a string located in a
            static buffer which is overwritten by the next call to the
            functions, so they are not thread-safe.

encrypt.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions encrypt() and setkey() are not thread safe.

ether_aton.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions ether_aton() and ether_ntoa() are not thread safe.

fcloseall.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function fcloseall() is not thread safe.

ferror.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions ferror(), clearerr(), feof() and fileno() are
            thread safe.

fgetgrent.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

fgetpwent.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

fgetwc.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

fmtmsg.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            Before glibc 2.16, fmtmsg() is not thread-safe.
            Since glibc 2.16, it is thread-safe, the patch can refer to URL:
            http://sourceware.org/git/?p=glibc.git;a=commit;h=7724defcf8873116fe4efab256596861eef21a94

fputwc.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

getdate.3
    Peng Haitao
        ATTRIBUTES: Note functions that are and aren't thread-safe

getgrent.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function getgrent() is not thread safe.

getgrnam.3
    Peng Haitao
        ATTRIBUTES: Note functions that are and aren't thread-safe

getline.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

getlogin.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function getlogin() is not thread safe.
            The function cuserid() is thread-safe with exceptions.
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

getpass.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe

getpwent.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function getpwent() is not thread safe.

getpwnam.3
    Peng Haitao
        ATTRIBUTES: Note functions that are and aren't thread-safe

getspnam.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

getttyent.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe

getusershell.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions getusershell(), setusershell() and endusershell()
            are not thread safe.

getutent.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

hsearch.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

hsearch.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions hsearch(), hcreate() and hdestroy() are not
            thread-safe.

localeconv.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The function localeconv() returns a pointer to a structure which
            might be overwritten by subsequent calls to localeconv() or by
            calls to setlocale(), so it is not thread-safe.
    Peng Haitao
        Add RETURN VALUE section

malloc_info.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

mblen.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function mblen() is not thread safe.

mbrlen.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function mbrlen() is thread safe with exceptions.

mbrtowc.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function mbrtowc() is thread safe with exceptions.

mktemp.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

modf.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions modf(), modff() and modfl() are thread safe.

popen.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

pthread_attr_setinheritsched.3
    Michael Kerrisk
        Note the scheduling attributes affected by this function

pthread_attr_setschedparam.3
pthread_attr_setschedpolicy.3
pthread_attr_setscope.3
    Michael Kerrisk  [Manuel Traut, Siddhesh Poyarekar]
        The inherit-scheduler attribute must be set to PTHREAD_EXPLICIT_SCHED
            In order for the attributes set by these functions to have
            an effect, the caller must use pthread_attr_setinheritsched(3)
            to set the inherit-scheduler attribute of the attributes object
            to PTHREAD_EXPLICIT_SCHED.

ptsname.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function ptsname() is not thread safe.

putenv.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

putpwent.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

qecvt.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions qecvt() and qfcvt() are not thread-safe.

random.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error
    Michael Kerrisk
        Add EINVAL error for setstate()
    Michael Kerrisk
        BUGS: initstate() does not return NULL on error
            http://sourceware.org/bugzilla/show_bug.cgi?id=15380

random_r.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

readdir.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The data returned by readdir() may be overwritten by subsequent
            calls to readdir() for the same directory stream, so it is not
            thread-safe.

re_comp.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions re_comp() and re_exec() are not thread safe.

rexec.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions rexec() and rexec_af() are not thread safe.

round.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions round(), roundf() and roundl() are thread safe.

scalbln.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions scalbn(), scalbnf(), scalbnl(), scalbln(),
            scalblnf() and scalblnl() are thread safe.

scandir.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

siginterrupt.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

signbit.3
    Peng Haitao
        ATTRIBUTES: Note macro that is thread-safe
            The macro signbit() is thread safe.

sigsetops.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

stdio_ext.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions __fbufsize(), __fpending(), __fpurge() and
            __fsetlocking() are not thread safe.

strdup.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

strerror.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function strerror() is not thread safe.

strftime.3
    Michael Kerrisk
        Clarify details of return value
    Michael Kerrisk
        BUGS: 'errno' is not set if the result string would exceed 'max' bytes

strtok.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function strtok() is not thread safe.
    Michael Kerrisk  [Georg Sauthoff]
        Add more detail on the operation of strtok()
            Add a number of missing details on the operation of strtok()

tempnam.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

timegm.3
    Jérémie Galarneau
        copy the string returned by getenv()
            The example of a portable version of timegm() uses the string
            returned by getenv() after calling setenv() on the same
            environment variable. The tz string may be invalid as per
            getenv.3:

                    "The string pointed to by the return value of getenv()
                     may be statically allocated, and can be modified by a
                     subsequent call to getenv(), putenv(3), setenv(3), or
                     unsetenv(3)."

tmpnam.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function tmpnam() is thread safe with exceptions.

trunc.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions trunc(), truncf() and truncl() are thread safe.

ttyname.3
    Michael Kerrisk
        ATTRIBUTES: Note functions that are and aren't thread-safe

ttyslot.3
    Michael Kerrisk
        ATTRIBUTES: Note functions that are not thread-safe

usleep.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

wcsdup.3
    Michael Kerrisk
        RETURN VALUE: mention that 'errno' is set on error

core.5
    Michael Kerrisk
        Implicitly adding the PID to a core filename was dropped in 2.6.27

proc.5
    Michael Kerrisk
        Document /proc/[pid]/fd/ anon_inode symlinks
    Mike Frysinger
        Document /proc/[pid]/fd/ symlinks a bit more
            Describe the type:[inode] syntax used in this dir

bootparam.7
    Michael Kerrisk  [Dan Jacobson]
        Remove outdated text on LILO and LoadLin
            Strike the discussion of LILO and LoadLin, which
            are long obsolete, and make a brief mention of GRUB.
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=604019
    Regid
        Remove mention of the deprecated rdev(8)
            The deprecated rdev(8) command was removed from util-linux in 2010.
            See https://git.kernel.org/?p=utils/util-linux/util-linux.git;a=commit;h=a3e40c14651fccf18e7954f081e601389baefe3fO
    Andrea Remondini
        Document the 'resume' boot parameter

inotify.7
    Michael Kerrisk  [Jon Grant]
        Clarify that null byte is '\0'

iso_8859-2.7
    Eric S. Raymond
        Remove incorrect reference to nonexistent groff glyph \[shc]
            The reference incorrectly attempted to duplicate an
            actual soft hyphen (hex 0xad) just before it in the file.

man-pages.7
    Peng Haitao
        Add description of "ATTRIBUTES"
            "ATTRIBUTES" section can mention thread safety,
            cancellation safety, and async-cancel-safety.

socket.7
    Michael Kerrisk
        Note that 'optval' for socket options is an 'int' in most cases

tcp.7
    Michael Kerrisk
        Note that 'optval' for socket options is an 'int' in most cases

udp.7
    Michael Kerrisk
        Note that 'optval' for socket options is an 'int' in most cases


==================== Changes in man-pages-3.53 ====================

Released: 2013-07-31, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Al Viro <viro@ZenIV.linux.org.uk>
Andrey Vagin <avagin@openvz.org>
Benjamin Poirier <bpoirier@suse.de>
Chris Heath <chris@heathens.co.nz>
Chuck Coffing <clc@alum.mit.edu>
David Prévot <taffit@debian.org>
Denys Vlasenko <dvlasenk@redhat.com>
Dmitry V. Levin <ldv@altlinux.org>
Felix Schulte <Felix_Schulte@McAfee.com>
Graud <graud@gmx.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Oleg Nesterov <oleg@redhat.com>
Peng Haitao <penght@cn.fujitsu.com>
Peter Schiffer <pschiffe@redhat.com>
Simon Paillard <spaillard@debian.org>
Vince Weaver <vincent.weaver@maine.edu>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

restart_syscall.2
    Michael Kerrisk
        New page for restart_syscall(2) system call


Newly documented interfaces in existing pages
---------------------------------------------

fchownat.2
    Michael Kerrisk
        Document AT_EMPTY_PATH

fstatat.2
    Michael Kerrisk
        Document AT_EMPTY_PATH

linkat.2
    Michael Kerrisk
        Document AT_EMPTY_PATH

open.2
    Michael Kerrisk [Al Viro]
        Document O_PATH
            See also https://bugzilla.redhat.com/show_bug.cgi?id=885740


Changes to individual pages
---------------------------

clock_nanosleep.2
futex.2
nanosleep.2
poll.2
sigaction.2
sigreturn.2
signal.7
    Michael Kerrisk
        SEE ALSO: add restart_syscall(2)

open.2
    Michael Kerrisk [Geoffrey Thomas]
        Remove warning that O_DIRECTORY is only for use with opendir(3)
            O_DIRECTORY can also be used with, for example, O_PATH.

perf_event_open.2
    Vince Weaver
        Improve PERF_SAMPLE_BRANCH_STACK documentation
    Vince Weaver
        Fix indentation of the MMAP layout section
            The indentation of the MMAP layout section wasn't quite right.
            I think this improves things but I admit I'm not an expert at the
            low-level indentation directives.
    Vince Weaver
        Update PERF_IOC_FLAG_GROUP info
            It turns out PERF_IOC_FLAG_GROUP was broken from 75f937f24bd9
            (in Linux 2.6.31, the initial perf_event release) until
            724b6daa1 (Linux 3.4).

            I've done some extensive kernel source code digging plus
            running tests of various kernels and I hope the info
            presented is accurate now.

            (Patch edited somewhat by mtk.)
    Vince Weaver
        Improve sysfs files documentation
            This improves the documentation of the various
            perf_event_open()-related sysfs files.

ptrace.2
    Denys Vlasenko  [Oleg Nesterov, Dmitry V. Levin]
        If SEIZE was used, initial auto-attach stop is EVENT_STOP
            For every PTRACE_O_TRACEfoo option, mention that old-style SIGSTOP
            is replaced by PTRACE_EVENT_STOP if PTRACE_SEIZE attach was used.

            Mention the same thing again in the description of
            PTRACE_EVENT_STOP.
    Denys Vlasenko  [Oleg Nesterov, Dmitry V. Levin]
        Mention that PTRACE_PEEK* libc API and kernel API are different
    Denys Vlasenko  [Oleg Nesterov, Dmitry V. Levin]
        Clarify PTRACE_INTERRUPT, PTRACE_LISTEN, and group-stop behavior

readlink.2
    Michael Kerrisk
        Document use of empty 'pathname' argument
    Michael Kerrisk
        Change error check in example program from "< 0" to "== -1"
    Chuck Coffing
        Fix possible race condition in readlink.2 example
            I noticed that the example in the readlink.2 man pages does error
            checking for a race condition that would cause the value of the
            symbolic link to get larger.  However, it doesn't handle the
            opposite case, in which the value gets shorter.  (The NULL
            terminator is always set at the old, longer offset.)  This could
            cause the program to operate on uninitialized data.

setpgid.2
    Michael Kerrisk  [Graud]
        s/SIGTSTP/SIGTTIN/ when discussing reads from terminal
            See https://bugzilla.kernel.org/show_bug.cgi?id=60504

clog2.3
    Michael Kerrisk
        Note that these functions are still not present in glibc 2.17

dirfd.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function dirfd() is thread safe.

div.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions div(), ldiv(), lldiv() and imaxdiv() are thread
            safe.

fabs.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions fabs(), fabsf() and fabsl() are thread safe.

fdim.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions fdim(), fdimf() and fdiml() are thread safe.

fflush.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function fflush() is thread safe.

finite.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions finite(), finitef(), finitel(), isinf(), isinff(),
            isinfl(), isnan(), isnanf() and isnanl() are thread safe.

flockfile.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions flockfile(), ftrylockfile() and funlockfile() are
            thread safe.

floor.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions floor(), floorf() and floorl() are thread safe.

resolv.conf.5
    Simon Paillard
        Explain how to set empty domain
            See http://bugs.debian.org/463575

capabilities.7
    Michael Kerrisk
        Add open_by_handle_at(2) under CAP_DAC_READ_SEARCH

inotify.7
    Michael Kerrisk  [Felix Schulte]
        Clarify description of IN_MOVED_FROM and IN_MOVED_TO

man-pages.7
    Michael Kerrisk
        DESCRIPTION should note versions for new interface features or behavior

udp.7
    Benjamin Poirier
        Add missing #include directive
            Using the UDP_CORK socket option documented in udp.7 requires
            including <netinet/udp.h>.

ld.so.8
    Michael Kerrisk
        Rework rpath token expansion text
    Michael Kerrisk
        Describe $PLATFORM rpath token
    Michael Kerrisk
        Describe $LIB rpath token
    Michael Kerrisk
        Document LD_BIND_NOT
    Michael Kerrisk  [Simon Paillard]
        Add reference to pthreads(7) in discussion of LD_ASSUME_KERNEL


==================== Changes in man-pages-3.54 ====================

Released: 2013-09-17, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

A. Costa <agcosta@gis.net>
Akihiro MOTOKI <amotoki@gmail.com>
Andreas Wiese <aw-lkml@instandbesetzt.net>
Andrew Hunter <andrewhhunter@gmail.com>
Chen Gang <gang.chen@asianux.com>
Christopher Hall <chall0@gmail.com>
Christos Tsopokis <christos@tsopokis.gr>
David Prévot <taffit@debian.org>
D. Barbier <bouzim@gmail.com>
Doug Goldstein <cardoe@cardoe.com>
Elie De Brauwer <eliedebrauwer@gmail.com>
Eugen Dedu <Eugen.Dedu@pu-pm.univ-fcomte.fr>
Felix Janda <felix.janda@posteo.de>
G.raud <graud@gmx.com>
Hannes Landeholm <hannes@jumpstarter.io>
J. Bruce Fields <bfields@fieldses.org>
J. Bruce Fields <bfields@redhat.com>
Johan Erlandsson <jeoerl@gmail.com>
Jon Grant <jg@jguk.org>
Magnus Reftel <magnus.reftel@gmail.com>
Marko Myllynen <myllynen@redhat.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Oleg Nesterov <oleg@redhat.com>
Peng Haitao <penght@cn.fujitsu.com>
Peter Schiffer <pschiffe@redhat.com>
Robert Harris <robert.harris@fixnetix.com>
Rodrigo Campos <rodrigo@sdfg.com.ar>
Simon Paillard <spaillard@debian.org>
Stas <stas.grumbler@gmail.com>
Vince Weaver <vincent.weaver@maine.edu>
Will Newton <will.newton@linaro.org>
Zdenek Pavlas <zpavlas@redhat.com>
Zsbán Ambrus <ambrus@math.bme.hu>

Apologies if I missed anyone!



Newly documented interfaces in existing pages
---------------------------------------------

ioctl_list.2
    Zsbán Ambrus
        Document FAT_IOCTL_GET_ATTRIBUTES
            The attached patch adds four ioctls from linux/msdos_fs.h to the
            ioctl_list(2) manpage.

            The ioctl FAT_IOCTL_GET_ATTRIBUTES reads FAT attributes of a
            file a mounted vfat file system.  I tested this on Linux
            2.6.33, an example script can be found at
            http://www.perlmonks.com/?node_id=832623


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix: s/file system/filesystem/
            Notwithstanding 24d01c530c5a3f75217543d02bf6712395e5f90c,
            "filesystem" is the form used by the great majority of man pages
            outside the man-pages project and in a number of other sources,
            so let's go with that.


Changes to individual pages
---------------------------

access.2
    J. Bruce Fields
        Fix outdated NFS information
            Note that NFS versions since version 3 support an "access" call
            so that the client doesn't have to guess permissions or ID
            mapping on its own.

            (See RFC 1813 sections 1.7 and 3.3.4.)

adjtimex.2
    Michael Kerrisk
        SEE ALSO: Add adjtimex(8)

clock_getres.2
    Michael Kerrisk  [Rodrigo Campos]
        Note circumstances in which "SMP" note applies.
    Michael Kerrisk
        Add kernel version for CLOCK_*_CPUTIME_ID
            CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID
            appeared in 2.6.12.
    Michael Kerrisk
        Add VERSIONS section

futex.2
    Michael Kerrisk
        The 'timeout' can be rounded upwards by clock granularity and also overrun

kill.2
    Michael Kerrisk
        Small improvements to text on historical rules for permissions

nfsservctl.2
    Michael Kerrisk
        Note commands that were only in Linux 2.4.x and earlier

open.2
    Robert Harris
        Add mmap(2) to list of calls that fail when given an O_PATH descriptor
    Doug Goldstein
        Add EINVAL to errors list
            EINVAL can be returned by open(2) when the underlying filesystem
            doesn't support O_DIRECT. It is documented in the NOTES section
            but this patch adds it to the list of possible errors.

perf_event_open.2
    Vince Weaver
        PERF_SAMPLE_BRANCH_STACK updates
            This started out as just adding the new perf_event_open features
            from Linux 3.11 (which was the addition of transactional memory
            defines for PERF_SAMPLE_BRANCH_STACK samples) but turned into a
            general cleanup of the PERF_SAMPLE_BRANCH_STACK documentation.

            The main clarification is that at least one of the non-privilege
            values must be set or else perf_event_open() will return an EINVAL
            error.
    Michael Kerrisk
        Reorder text describing fields of 'perf_event_header' structure
            Place the fields with the shorter descriptions first, to make the
            information easier to read.

poll.2
    Michael Kerrisk
        Clarify wording of 'timeout' as a "minimum" interval

sched_setaffinity.2
    Michael Kerrisk  [Christos Tsopokis]
        Clarify that these system calls affect a per-thread attribute

sched_setparam.2
    Michael Kerrisk
        Clarify that this system call applies to threads (not processes)

sched_setscheduler.2
    Michael Kerrisk
        Clarify that this system call applies to threads (not processes)

select.2
    Michael Kerrisk  [G.raud]
        Clarify wording of 'timeout' as a "minimum" interval

setfsgid.2
    Michael Kerrisk  [Oleg Nesterov]
        Clarify description of return value
            More clearly describe the weirdness in the return value of this
            system call, and note the problems it creates in BUGS
    Michael Kerrisk
        Correct header file in SYNOPSIS
    Michael Kerrisk
        Refer to setfsuid(2) for an explanation of why setfsgid() is obsolete
    Michael Kerrisk
        Wording improvements

setfsuid.2
    Michael Kerrisk  [Oleg Nesterov]
        Clarify description of return value
            More clearly describe the weirdness in the return value of this
            system call, and note the problems it creates in BUGS
    Michael Kerrisk  [Chen Gang]
        Clarify historical details and note that setfsuid() is obsolete
    Michael Kerrisk
        Wording improvements
    Michael Kerrisk
        Correct header file in SYNOPSIS

sigwaitinfo.2
    Michael Kerrisk
        Clarify wording of 'timeout' as a "minimum" interval

syscall.2
    Johan Erlandsson
        Add missing argument in example
    Johan Erlandsson
        Correct registers for arm/EABI
            Registers was off by one.

            Reference:
            http://www.arm.linux.org.uk/developer/patches/viewpatch.php?id=3105/4

            See also:
            http://peterdn.com/post/e28098Hello-World!e28099-in-ARM-assembly.aspx
            https://wiki.debian.org/ArmEabiPort
            http://en.wikipedia.org/wiki/Calling_convention#ARM

wait.2
    Michael Kerrisk  [Hannes Landeholm]
        Add details on the fifth argument provided by raw waitid() system call
            See https://bugzilla.kernel.org/show_bug.cgi?id=60744

clock.3
    Michael Kerrisk
        clock() switched from using times(2) to clock_gettime() in glibc 2.18

drand48_r.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions drand48_r(), erand48_r(), lrand48_r(),
            nrand48_r(), mrand48_r(), jrand48_r(), srand48_r(), seed48_r(),
            and lcong48_r() are thread safe.

fma.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions fma(), fmaf() and fmal() are thread safe.

fmax.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions fmax(), fmaxf() and fmaxl() are thread safe.

fmin.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions fmin(), fminf() and fminl() are thread safe.

fpclassify.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions fpclassify(), isfinite(), isnormal(), isnan(), and
            isinf() are thread safe.

frexp.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions frexp(), frexpf() and frexpl() are thread safe.

gethostbyname.3
    Michael Kerrisk  [Jon Grant]
        gai_strerror() is the modern replacement for herror() and hstrerror()
    Michael Kerrisk
        Update feature test macro requirements for herror() and hstrerror()
    Michael Kerrisk
        Add feature test macro requirements for h_errno

ilogb.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions ilogb(), ilogbf() and ilogbl() are thread safe.

ldexp.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions ldexp(), ldexpf() and ldexpl() are thread safe.

lrint.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions lrint(), lrintf(), lrintl(), llrint(), llrintf(),
            and llrintl() are thread safe.

lround.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions lround(), lroundf(), lroundl(), llround(),
            llroundf() and llroundl() are thread safe.

lseek64.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function lseek64() is thread safe.

mbsinit.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function mbsinit() is thread safe.

nextafter.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions nextafter(), nextafterf(), nextafterl(),
            nexttoward(), nexttowardf() and nexttowardl() are thread safe.

posix_memalign.3
    Michael Kerrisk  [Will Newton]
        'errno" is indeterminate after a call to posix_memalign()
    Michael Kerrisk  [Will Newton]
        Clarify wording on "return value" when size==0

printf.3
    Christopher Hall
        Correctly describe the meaning of a negative precision
            The printf(3) manpage says that a negative precision is taken to
            be zero, whereas printf(3p) says that a negative precision is
            taken as if the precision were omitted.  glibc agrees with the
            latter (POSIX) specification.

            Test code:

                printf("%f\n",42.0);      // "42.000000"
                printf("%.*f\n",0,42.0);  // "42"
                printf("%.*f\n",-1,42.0); // "42.000000"

            This patch corrects the explanation to match what actually happens.

rewinddir.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function rewinddir() is thread safe.

rint.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions nearbyint(), nearbyintf(), nearbyintl(), rint(),
            rintf() and rintl() are thread safe.

seekdir.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function seekdir() is thread safe.

telldir.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function telldir() is thread safe.

wctomb.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function wctomb() is not thread safe.

wavelan.4
    Michael Kerrisk  [Elie De Brauwer]
        This driver disappeared in 2.56.35

dir_colors.5
    Michael Kerrisk  [Stas]
        Add various synonyms
            See http://bugs.debian.org/553477
    Simon Paillard  [Stas]
        Add keywords SUID, SGID, STICKY, STICKY_OTHER_WRITABLE, OTHER_WRITABLE
            See http://bugs.debian.org/553477
            See ls.c and dircolors.c in coreutils

proc.5
    Peter Schiffer
        Document /proc/[pid]/io file
            Attempt to document fields in the /proc/[pid]/io file, based on
            the Documentation/filesystems/proc.txt. The text will probably
            need some grammar corrections.
    Michael Kerrisk  [Marko Myllynen]
        /proc/sys/fs/inode-max went away in Linux 2.4
            Also, the 'preshrink' field in /proc/sys/fs/inode-state became
            a dummy value in Linux 2.4.

            See https://bugzilla.kernel.org/show_bug.cgi?id=60836
    Michael Kerrisk  [A. Costa]
        Note block size used by /proc/partitions
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=666972
    Michael Kerrisk
        Add rationale on drop_caches and note that it can hurt performance
            See also http://lwn.net/Articles/562211/

bootparam.7
    Michael Kerrisk  [Eugen Dedu]
        Remove "lilo" entries from SEE ALSO
            See http://bugs.debian.org/604019

inotify.7
    Michael Kerrisk
        SEE ALSO: add inotifywait(1) and inotifywatch(1)

ip.7
    Simon Paillard
        IP_MULTICAST_IF setsockopt recognizes struct mreq (compatibility)
            Kernel added compatibility only recently in
            3a084ddb4bf299a6e898a9a07c89f3917f0713f7
            See: http://bugs.debian.org/607979

standards.7
    Michael Kerrisk
        Add mention of SUSv4-TC1 (POSIX.1-2013)


==================== Changes in man-pages-3.55 ====================

Released: 2013-12-12, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alfred Agrell <alfred@agrell.info>
Andreas Sandberg <andreas.sandberg@it.uu.se>
Christoph Hellwig <hch@infradead.org>
David Gibson <david@gibson.dropbear.id.au>
David Prévot <taffit@debian.org>
Fabrice Bauzac <libnoon@gmail.com>
Greg Price <price@mit.edu>
Jon Grant <jg@jguk.org>
KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Liu Jiaming <storypku@gmail.com>
Maxin B. John <maxin.john@enea.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Paolo Bonzini <bonzini@gnu.org>
Peng Haitao <penght@cn.fujitsu.com>
Robert P. J. Day <rpjday@crashcourse.ca>
Rodrigo Campos <rodrigo@sdfg.com.ar>
Shawn Landden <shawn@churchofgit.com>
Trevor Bramwell <trevor@bramwell.net>
Vince Weaver <vincent.weaver@maine.edu>
Yang Yang <yangyang.gnu@gmail.com>
Yuanhang Zheng <zhengyhn@gmail.com>
Yuri Kozlov <yuray@komyakino.ru>
janh <a0vhv@t-online.de>

Apologies if I missed anyone!


Global changes
--------------

assert.3
assert_perror.3
rexec.3
rpc.3
    Michael Kerrisk  [Jon Grant]
        Reword a sentence to use more gender-neutral language


Changes to individual pages
---------------------------

execve.2
    Michael Kerrisk
        'arg...' for interpreter scripts starts with argv[1]

fallocate.2
    Christoph Hellwig
        Clarify the zeroing behavior
            fallocate() zeroes only space that did not previously contain
            data, but leaves existing data untouched.

futex.2
    Rodrigo Campos
        Fix link to Rusty's futex example library
            When I asked to webmaster@kernel.org, Konstantin Ryabitsev
            answered that the ".nl." is "an obsolete scheme and really
            should be changed to just ftp.kernel.org".

getgroups.2
    Michael Kerrisk
        Note that NGROUPS_MAX is defined in <limits.h>
    Michael Kerrisk
        Clarify that sysconf(_SC_NGROUPS_MAX) is a run-time technique
    Michael Kerrisk
        Document /proc/sys/kernel/ngroups_max

ioctl.2
    Michael Kerrisk  [KOSAKI Motohiro, David Gibson]
        'request' argument is typed as 'unsigned long' in glibc
            See https://bugzilla.kernel.org/show_bug.cgi?id=42705

perf_event_open.2
    Vince Weaver
        Linux 3.12 rdpmc/mmap
            It turns out that the perf_event mmap page rdpmc/time setting was
            broken, dating back to the introduction of the feature.  Due
            to a mistake with a bitfield, two different values mapped to
            the same feature bit.

            A new somewhat backwards compatible interface was introduced
            in Linux 3.12.  A much longer report on the issue can be found
            here:
               https://lwn.net/Articles/567894/
    Vince Weaver
        Linux 3.12 adds PERF_SAMPLE_IDENTIFIER
            A new PERF_SAMPLE_IDENTIFIER sample type was added in Linux 3.12.
    Vince Weaver
        E2BIG documentation
            The following documents the E2BIG error return for
            perf_event_open().

            I actually ran into this error the hard way and it took me
            half a day to figure out why my ->size value was changing.
    Vince Weaver
        Linux 3.12 adds PERF_EVENT_IOC_ID
            A new perf_event related ioctl, PERF_EVENT_IOC_ID, was added
            in Linux 3.12.
    Vince Weaver
        PERF_COUNT_SW_DUMMY support
            Support for the PERF_COUNT_SW_DUMMY event type was added in
            Linux 3.12.
    Vince Weaver  [Andreas Sandberg]
        PERF_EVENT_IOC_PERIOD update
            The PERF_EVENT_IOC_PERIOD ioctl was broken until 2.6.36,
            and it turns out that the ARM architecture has some
            differing behavior too.

pipe.2
    Trevor Bramwell
        Fix error in example program

poll.2
    Michael Kerrisk  [Paolo Bonzini]
        Clarify meaning of events==0
            events==0 does not mean that revents is always returned as
            zero. The "output only" events (POLLHUP, POLLERR, POLLNVAL)
            can still be returned.

            See https://bugzilla.kernel.org/show_bug.cgi?id=61911

readlink.2
    Michael Kerrisk  [Yuanhang Zheng]
        Fix typo in error message in example program

recv.2
    Michael Kerrisk
        Remove out-of-date statement that UNIX domain does not support MSG_TRUNC
            Should have removed that sentence as part of
            commit a25601b48b822eb1882ae336574b8d062a17e564

sched_get_priority_max.2
    Michael Kerrisk
        Add SCHED_IDLE to discussion

send.2
    Michael Kerrisk
        RETURN VALUE: these calls return number of bytes (not characters) sent

setreuid.2
    Michael Kerrisk
        Small clarification to description of when saved set-user-ID is set

sigpending.2
    Michael Kerrisk
        Note treatment of signals that are blocked *and* ignored

stat.2
    Michael Kerrisk
        Note filesystem support for nanosecond timestamps
            Add some detail on which native filesystems do and don't
            support nanosecond timestamps.
    Michael Kerrisk
        Cosmetic reworking of timestamp discussion in NOTES
    Michael Kerrisk  [Yang Yang]
        Update discussion of nanosecond timestamps
            The existing text describes the timestamp fields as 'time_t'
            and delegates discussion of nanosecond timestamps under NOTES.
            Nanosecond timestamps have been around for a while now,
            and are in POSIX.1-2008, so reverse the orientation of the
            discussion, putting the nanosecond fields into DESCRIPTION
            and detailing the historical situation under NOTES.

symlink.2
    Michael Kerrisk
        Further fine tuning of argument names
            Follow-up to f2ae6dde0c68448bec986d12fe32268a2c98bfd9
            See https://sourceware.org/bugzilla/show_bug.cgi?id=16073
    Michael Kerrisk  [Fabrice Bauzac]
        Give arguments of symlink() more meaningful names

adjtime.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function adjtime() is thread safe.

alloca.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function alloca() is thread safe.

asinh.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions asinh(), asinhf() and asinhl() are thread safe.

atan.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions atan(), atanf() and atanl() are thread safe.

atof.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function atof() is thread safe with exceptions.

atoi.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions atoi(), atol() and atoll() are thread safe with
            exceptions.

bcmp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function bcmp() is thread safe.

bcopy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function bcopy() is thread safe.

bsd_signal.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function bsd_signal() is thread safe.

bzero.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function bzero() is thread safe.

cbrt.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions cbrt(), cbrtf() and cbrtl() are thread safe.

copysign.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions copysign(), copysignf() and copysignl() are thread
            safe.

cos.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions cos(), cosf() and cosl() are thread safe.

cproj.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions cproj(), cprojf() and cprojl() are thread safe.

creal.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions creal(), crealf() and creall() are thread safe.

daemon.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function daemon() is thread safe.

des_crypt.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions ecb_crypt(), cbc_crypt() and des_setparity() are
            thread safe.

difftime.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function difftime() is thread safe.

dysize.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function dysize() is thread safe.

erf.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions erf(), erff() and erfl() are thread safe.

erfc.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions erfc(), erfcf() and erfcl() are thread safe.

euidaccess.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions euidaccess() and eaccess() are thread safe.

expm1.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions expm1(), expm1f() and expm1l() are thread safe.

fexecve.3
    Michael Kerrisk
        POSIX.1-2008 specifies fexecve()
    Michael Kerrisk
        Explain the use and rationale of fexecve()

ftime.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function ftime() is thread safe.

ftok.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function ftok() is thread safe.

ftw.3
    Michael Kerrisk
        nftw() visits directories with FTW_D if FTW_DEPTH was not specified
    Michael Kerrisk
        Explain probable cause of FTW_NS

futimes.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions futimes() and lutimes() are thread safe.

getaddrinfo.3
    Michael Kerrisk
        Explain one use case for AI_ADDRCONFIG
    Michael Kerrisk
        Highlight difference in ai_flags when hints==NULL
            NOTES already described how glibc differs from POSIX.
            Add a pointer to that text from the point in DESCRIPTION
            where hints==NULL is discussed.

kcmp.3
    Shawn Landden
        Reword slightly awkward section

malloc.3
    Greg Price
        Scale back promises of alignment
            It's not true that the return value is suitably aligned for "any
            variable"; for example, it's unsuitable for a variable like
              float *x __attribute__ ((__vector_size__ (32)));
            which requires 32-byte alignment.  Types like this are defined in
            <avxintrin.h>, and with 16-byte alignment in <emmintrin.h> and
            <xmmintrin.h>, so the application programmer need not even know
            that a vector_size attribute has been applied.

            On an x86 architecture, a program that loads from or stores to a
            pointer with this type derived from malloc can crash because GCC
            generates an aligned load/store, like MOVDQA.

            The C99 standard (TC3, as of N1256) does say the return value is
            suitably aligned for "any type of object".  The C11 standard (as
            of N1570) revises this to any type with "fundamental alignment",
            which means an alignment "supported by the implementation in all
            contexts", which I suppose tautologically includes aligning
            malloc/realloc return values.

            The actual behavior of current glibc malloc is to align to the
            greater of 2 * sizeof(size_t) and __alignof__ (long double),
            which may be one bit greater than this commit promises.

mq_receive.3
    Michael Kerrisk  [janh]
        msg_len must be greater than *or equal to* mq_msgsize
            See https://bugzilla.kernel.org/show_bug.cgi?id=64571

setenv.3
    Michael Kerrisk
        Clarify that setenv() returns success in the overwrite==0 case

sigsetops.3
    Michael Kerrisk  [Robert P. J. Day]
        Add 'const' to sigisemptyset(), sigorset(), sigandset() declarations
    Michael Kerrisk
        Rework text describing sigisemptyset(), sigorset(), and sigandset()

statvfs.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions statvfs() and fstatvfs() are thread safe.

stdarg.3
    Peng Haitao
        ATTRIBUTES: Note macros that are thread-safe
            The macros va_start(), va_arg(), va_end() and va_copy() are
            thread safe.

termios.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions tcgetattr(), tcsetattr(), tcsendbreak(),
            tcdrain(), tcflush(), tcflow(), cfmakeraw(), cfgetispeed(),
            cfgetospeed(), cfsetispeed(), cfsetospeed() and cfsetspeed()
            are thread safe.

ungetwc.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function ungetwc() is thread safe.

unlockpt.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function unlockpt() is thread safe.

usleep.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function usleep() is thread safe.

wcpcpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcpcpy() is thread safe.

wcscasecmp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function wcscasecmp() is thread safe with exceptions.

wcscat.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcscat() is thread safe.

wcschr.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcschr() is thread safe.

wcscmp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcscmp() is thread safe.

wcscpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcscpy() is thread safe.

wcscspn.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcscspn() is thread safe.

wcslen.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcslen() is thread safe.

wcsncasecmp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function wcsncasecmp() is thread safe with exceptions.

wcsncat.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcsncat() is thread safe.

wcsncmp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcsncmp() is thread safe.

wcsncpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcsncpy() is thread safe.

wcsnlen.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcsnlen() is thread safe.

wcspbrk.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcspbrk() is thread safe.

wcsrchr.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcsrchr() is thread safe.

wcsspn.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcsspn() is thread safe.

wcsstr.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcsstr() is thread safe.

wcstoimax.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions wcstoimax() and wcstoumax() are thread safe with
            exceptions.

wcstok.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcstok() is thread safe.

wcswidth.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function wcswidth() is thread safe with exceptions.

wctrans.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function wctrans() is thread safe with exceptions.

wctype.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function wctype() is thread safe with exceptions.

wcwidth.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function wcwidth() is thread safe with exceptions.

wmemchr.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wmemchr() is thread safe.

wmemcmp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wmemcmp() is thread safe.

wmemcpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wmemcpy() is thread safe.

wmemmove.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wmemmove() is thread safe.

wmemset.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wmemset() is thread safe.

tty_ioctl.4
    Michael Kerrisk  [Liu Jiaming]
        Note that 'arg' should be 0 in the usual case when using TIOCSCTTY
    Michael Kerrisk
        Rework text on root to discuss just in terms of capabilities

proc.5
    Michael Kerrisk
        Document /proc/sys/kernel/ngroups_max

capabilities.7
    Michael Kerrisk
        Fix 2 version numbers under "Effect of user ID changes on capabilities"

feature_test_macros.7
    Michael Kerrisk
        Add _ISOC11_SOURCE to example program

tcp.7
    Michael Kerrisk
        Fix (nontrivial) wordo in discussion of MSG_TRUNC
            s/MSG_PEEK/MSG_TRUNC/

ld.so.8
    Michael Kerrisk  [Alfred Agrell]
        Fix crufty wording in one sentence


==================== Changes in man-pages-3.56 ====================

Released: 2014-01-11, Christchurch

In memory of Doris Church (1939-2013)


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andre Majorel <aym-xunil@teaser.fr>
Arif Zaman <arifz@lums.edu.pk>
Bert Wesarg <bert.wesarg@googlemail.com>
Daniel Borkmann <dborkman@redhat.com>
David Malcolm <dmalcolm@redhat.com>
David Prévot <taffit@debian.org>
Dongsheng Song <dongsheng.song@gmail.com>
Elie De Brauwer <eliedebrauwer@gmail.com>
James Smith <james@theta.pw>
Janne Blomqvist <blomqvist.janne@gmail.com>
Joseph S. Myers <joseph@codesourcery.com>
Luke Hutchison <luke.hutch@mit.edu>
Marco Dione <mdione@grulic.org.ar>
Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Mathieu Malaterre <malat@debian.org>
Matthias Klose <doko@debian.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Moritz 'Morty' Strübe <morty@gmx.net>
Nadav Har'El <nyh@math.technion.ac.il>
Ondřej Bílka <neleai@seznam.cz>
Prádraig Brady <P@draigBrady.com>
Peng Haitao <penght@cn.fujitsu.com>
Raphael Geissert <geissert@debian.org>
Shawn Landden <shawn@churchofgit.com>
Simon Paillard <spaillard@debian.org>
Stephen Kell <srk31@srcf.ucam.org>
Sudhanshu Goswami <Sudhanshu.Goswami@emc.com>
Sworddragon2 <sworddragon2@aol.com>
Vince Weaver <vincent.weaver@maine.edu>
Willem de Bruijn <willemb@google.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

fgetc.3
gets.3
    David Malcolm
        Split gets(3) to isolate unsafe gets(3) to a page on its own
            Currently man3/gets.3 documents various safe I/O functions, along
            with the toxic "gets" function.

            At the risk of being melodramatic, this strikes me as akin to
            storing rat poison in a food cabinet, in the same style of
            packaging as the food, but with a post-it note on it saying
            "see warnings below".

            I think such "never use this" functions should be quarantined
            into their own manpages, rather than listing them alongside
            sane functions.

            The attached patch does this for "gets", moving the documentation
            of the good functions from man3/gets.3 into man3/fgetc.3,
            updating the SO links in the relevant functions to point at the
            latter.

            It then rewrites man3/gets.3 to spell out that "gets" is toxic
            and should never be used (with a link to CWE-242 for good
            measure).
    Michael Kerrisk  [Andre Majorel]
        Tweaks to David Malcolm's patch

vdso.7
    Mike Frysinger
        New page documenting the vDSO mapped into each process by the kernel


Newly documented interfaces in existing pages
---------------------------------------------

reboot.2
    Elie De Brauwer
        Document LINUX_REBOOT_SW_SUSPEND


New and changed links
---------------------

fgets.3
getc.3
getchar.3
ungetc.3
    Michael Kerrisk
        Adjust links to gets(3) to point to fgetc(3)


Global changes
--------------

Various pages
    Michael Kerrisk
        Global fix of "NULL pointer"
            Change "NULL pointer" to "NULL" or null pointer".
            POSIX uses the term "null pointer", not "NULL pointer".

Various pages
    Michael Kerrisk
        Stylistic changes to code example
            For ease of reading, don't embed assignments inside if().

Various pages
    Michael Kerrisk
        Replace uses of "i.e.," in main text with "that is" or similar
            Usual man-pages style is to use "i.e." only within
            parenthetical expressions.

Various pages
    Michael Kerrisk
        Replace uses of "e.g." in main text with "for example" or similar
                Usual man-pages style is to use "e.g." only within
                parenthetical expressions.

Various pages
    Michael Kerrisk
        Add "Program source" subheading under EXAMPLE

Various pages
    Michael Kerrisk
        Add "static" to global variables and functions in example program


Changes to individual pages
---------------------------

clock_getres.2
    Michael Kerrisk  [Nadav Har'El]
        Improve description of CLOCK_PROCESS_CPUTIME_ID
            See https://bugzilla.kernel.org/show_bug.cgi?id=67291

close.2
    Michael Kerrisk  [P?draig Brady]
        Note that errors from close() should be used only for diagnosis
            In particular, retrying after EINTR is a bad idea.

            See http://austingroupbugs.net/view.php?id=529

            See http://thread.gmane.org/gmane.comp.lib.glibc.alpha/37702
            Subject: [RFC][BZ #14627] Make linux close errno to EINPROGRESS
                     when interrupted in signal.

execve.2
    Michael Kerrisk  [Marco Dione]
        Add further cases to EFAULT error
            See https://sourceware.org/bugzilla/show_bug.cgi?id=16402

perf_event_open.2
    Vince Weaver  [Sudhanshu Goswami]
        Clarify issues with the disabled bit
            Clarify the perf_event_open behavior with respect to the disabled
            bit and creating event groups.
    Vince Weaver  [Sudhanshu Goswami]
        Clarify issues with the exclusive bit
            Warn that using the perf_event_open "exclusive" bit, while
            it might seem like a good idea, might lead to all 0 results
            in some common usage cases.

reboot.2
    Elie De Brauwer
        Mention RB_POWER_OFF
            The manpage did not mention RB_POWER_OFF which is the glibc
            symbolic name for LINUX_REBOOT_CMD_POWER_OFF.

            $ cd /usr/include
            $ cat x86_64-linux-gnu/sys/reboot.h | grep POWER_OFF
             define RB_POWER_OFF        0x4321fedc
    Elie De Brauwer
        Add "Linux" to kernel version numbers
    Michael Kerrisk
        Add RB_SW_SUSPEND synonym
    Michael Kerrisk
        Add RB_KEXEC synonym

setpgid.2
    Michael Kerrisk  [Joseph S. Myers]
        BSD getpgrp() and setpgrp() go away in glibc 2.19

socket.2
    Michael Kerrisk  [Dongsheng Song]
        Remove crufty statement that AF_INET does not support SOCK_SEQPACKET
            Linux AF_INET supports SOCK_SEQPACKET via SCTP.

syscall.2
    Mike Frysinger
        Fix ia64 registers
            The original list of registers was created by confusing strace
            source code--this is for parsing legacy 32-bit code (which is
            dead and no one cares). Update the list to reflect native ia64
            syscall interface.

syscall.2
syscalls.2
getauxval.3
    Mike Frysinger
        Add references to new vdso(7) page

utimensat.2
    Michael Kerrisk
        Small wording improvement for times!=NULL case

dlopen.3
    Michael Kerrisk  [Mike Frysinger]
        Update remarks on cast needed when assigning dlsym() return value
            POSIX.1-2013 eases life when casting the dlsym() return value to a
            function pointer
    Michael Kerrisk  [Stephen Kell]
        Fix description of dli_sname
            See https://sourceware.org/bugzilla/show_bug.cgi?id=16262

getline.3
    Michael Kerrisk  [Luke Hutchison]
        Correct description of how '*n' is used when '*lineptr' == NULL
            See https://sourceware.org/bugzilla/show_bug.cgi?id=5468
    Michael Kerrisk
        Remove SEE ALSO reference to unsafe gets(3)

mcheck.3
    Simon Paillard  [Raphael Geissert]
        typo in compiler flag
            See http://bugs.debian.org/732464

mkstemp.3
    Michael Kerrisk  [Janne Blomqvist]
        Better describe 'flags' that can be specified for mkostemp()

printf.3
    Michael Kerrisk  [Arif Zaman]
        Fix memory leak in snprintf() example
            See http://stackoverflow.com/questions/19933479/snprintf-man-page-example-memory-leak

pthread_kill.3
    Michael Kerrisk  [Mathieu Desnoyers]
        POSIX.1-2008 removes ESRCH
            POSIX.1-2001 mistakenly documented an ESRCH error, and
            POSIX.1-2008 removes this error. Glibc does return
            this error in cases where it can determine that a thread ID
            is invalid, but equally, the use of an invalid thread ID
            can cause a segmentation fault.

puts.3
    Michael Kerrisk
        SEE ALSO: replace reference to gets(3) with fgets(3)

scanf.3
    Michael Kerrisk  [Ondřej Bílka]
        Improve discussion of obsolete 'a' dynamic allocation modifier

setjmp.3
    Michael Kerrisk  [Joseph S. Myers]
        BSD setjmp() semantics go away in glibc 2.19

sigpause.3
    Michael Kerrisk  [Joseph S. Myers]
        BSD sigpause() goes away in glibc 2.19
    Michael Kerrisk
        Correct feature text macro requirements
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sigpause() is thread safe.

sigqueue.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sigqueue() is thread safe.

sigwait.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sigwait() is thread safe.

sin.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions sin(), sinf() and sinl() are thread safe.

sincos.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions sincos(), sincosf() and sincosl() are thread safe.

string.3
    Moritz 'Morty' Strübe
        Add short description of the functions
            It is helpful to have a short description about what the different
            functions in string.h do.
    Michael Kerrisk
        Fixes and enhancements to Moritz Strübe's patch

strptime.3
    Michael Kerrisk  [Mathieu Malaterre, Simon Paillard]
        Add number ranges to comments in 'tm' structure
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=729570
    Michael Kerrisk
        Point to ctime(3) for more details on 'tm' structure
    Michael Kerrisk
        Some rewording and reorganization

strsep.3
    Michael Kerrisk
        Clarify description
            The use of "symbols" in the existing description is confusing;
            it's "bytes". Other fixes as well.

strspn.3
    Michael Kerrisk  [Mathieu Malaterre]
        Improve description in NAME
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=723659

strstr.3
    Michael Kerrisk
        Clarify RETURN VALUE: s/substring/located substring/

sysv_signal.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sysv_signal() is thread safe.

tan.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions tan(), tanf() and tanl() are thread safe.

tanh.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions tanh(), tanhf() and tanhl() are thread safe.

toascii.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function toascii() is thread safe.

toupper.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions toupper() and tolower() are thread safe with
            exceptions.

towctrans.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function towctrans() is thread safe.

towlower.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function towlower() is thread safe with exceptions.

towupper.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function towupper() is thread safe with exceptions.

ualarm.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function ualarm() is thread safe.

wcpncpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function wcpncpy() is thread safe.

proc.5
    Michael Kerrisk  [Sworddragon2]
        Fix formula for CommitLimit under /proc/meminfo
            See https://bugzilla.kernel.org/show_bug.cgi?id=60991

credentials.7
    Michael Kerrisk
        List APIs that operate on process groups
    Michael Kerrisk
        Add details on controlling terminal and foreground/background jobs

feature_test_macros.7
    Michael Kerrisk
        Document _DEFAULT_SOURCE
    Michael Kerrisk  [Joseph S. Myers]
        From glibc 2.19, _BSD_SOURCE no longer causes __FAVOR_BSD
            Starting with glibc 2.19, _BSD_SOURCE no longer causes BSD
            definitions to be favored in cases where standards conflict.

libc.7
    Mike Frysinger
        SEE ALSO: add various entries

man-pages.7
    Michael Kerrisk  [Mike Frysinger]
        Add STYLE GUIDE section
            Incorporate some of the existing material in the page
            into the STYLE GUIDE, and add a lot more material, mainly
            drawn from the "Global changes" sections in the release
            changelogs.
    Michael Kerrisk
        Add historical note on reason for use of American spelling
    Michael Kerrisk  [Mike Frysinger]
        Various improvements to style guide

packet.7
    Willem de Bruijn  [Daniel Borkmann]
        Document fanout, ring, and auxiliary options
            This patch adds descriptions of the common packet socket options
              PACKET_AUXDATA, PACKET_FANOUT, PACKET_RX_RING, PACKET_STATISTICS,
              PACKET_TX_RING
            and the ring-specific options
              PACKET_LOSS, PACKET_RESERVE, PACKET_TIMESTAMP, PACKET_VERSION
    Michael Kerrisk
        Add kernel version numbers for PACKET_VERSION and PACKET_TIMESTAMP

ld.so.8
    Michael Kerrisk  [Matthias Klose]
        Default output file for D_DEBUG is stderr not stdout
            See https://sourceware.org/bugzilla/show_bug.cgi?id=6874



==================== Changes in man-pages-3.57 ====================

Released: 2014-01-24, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andi Kleen <andi@firstfloor.org>
Andre Majorel <aym-xunil@teaser.fr>
Andrey Vagin <avagin@openvz.org>
Andy Lutomirski <luto@amacapital.net>
Axel Beckert <abe@debian.org>
Bernhard Walle <bernhard@bwalle.de>
Brandon Edens <bedens@fitbit.com>
Eliezer Tamir <eliezer.tamir@linux.intel.com>
Gioele Barabucci <gioele@svario.it>
Ian Abbott <abbotti@mev.co.uk>
Jerry Chu <hkchu@google.com>
Jonas Jonsson <jonas@websystem.se>
Marc Lehmann <debian-reportbug@plan9.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Peng Haitao <penght@cn.fujitsu.com>
Reuben Thomas <rrt@sc3d.org>
Simone Piccardi <piccardi@truelite.it>
Simon Paillard <spaillard@debian.org>
Thomas Posch <man-pages@online.posch.name>
Tilman Schmidt <tilman@imap.cc>
Vince Weaver <vincent.weaver@maine.edu>
Yuri Kozlov <yuray@komyakino.ru>
Марк Коренберг <socketpair@gmail.com>

Apologies if I missed anyone!


Newly documented interfaces in existing pages
---------------------------------------------

msgop.2
    Michael Kerrisk
        Document MSG_COPY

open.2
    Michael Kerrisk, Andy Lutomirski
        Document O_TMPFILE
            O_TMPFILE is new in Linux 3.11

perf_event_open.2
    Vince Weaver  [Andi Kleen]
        PERF_SAMPLE_TRANSACTION support in Linux 3.13
            The following patch adds descriptions of the new perf_event_open.2
            PERF_SAMPLE_TRANSACTION sample type as added in Linux 3.13.

            The descriptions are based on information provided by Andi Kleen,
            both in the e-mail

                [PATCH 1/6] perf, core: Add generic transaction flags v5

            sent to the linux-kernel list as well as an e-mail

                [PATCH] Document transaction flags in perf_event_open manpage

            sent to the linux-man list.

            The implementation is based heavily on the Intel Haswell
            processor.  Documentation can be found at this page:
            http://software.intel.com/en-us/blogs/2013/05/03/intelr-transactional-synchronization-extensions-intelr-tsx-profiling-with-linux-0
            as well as in section 18.11.5.1 of volume 3 of the
            Intel 64 and IA-32 Architecture Software Developer's Manual.

ptrace.2
    Andrey Vagin
        Add description for PTRACE_PEEKSIGINFO
            Retrieve signals without removing them from a queue.
    Andrey Vagin
        Add description for PTRACE_GETSIGMASK and PTRACE_SETSIGMASK
            These two commands allow to examine and change mask of blocked
            signals.

socket.7
    Eliezer Tamir
        Add description for SO_BUSY_POLL
            Add description for the SO_BUSY_POLL socket option.

tcp.7
    Michael Kerrisk  [Jerry Chu]
        Document TCP_USER_TIMEOUT
            Text slightly adapted from Jerry Chu's (excellent) commit
            message (commit dca43c75e7e545694a9dd6288553f55c53e2a3a3).
    Michael Kerrisk
        Document TCP_CONGESTION


Global changes
--------------

Various pages
    Michael Kerrisk
        Reword to avoid use of "etc."

Various pages
    Peng Haitao  [Andre Majorel]
        Make wording around thread-safety and setlocale() more precise

getdate.3
strptime.3
locale.5
    Michael Kerrisk
        Replace "weekday" with less ambiguous language
            Notwithstanding POSIX's use of the term "weekday", in everyday
            English, "weekday" is commonly understood to mean a day in the
            set [Monday..Friday] (vs one of the "weekend" days).


Changes to individual pages
---------------------------

epoll_wait.2
    Michael Kerrisk  [Jonas Jonsson]
        Clarify wording of EINTR error
            See https://bugzilla.kernel.org/show_bug.cgi?id=66571

faccessat.2
    Michael Kerrisk
        Note that the system call takes only three arguments

fallocate.2
    Michael Kerrisk
        Note filesystems that support  FALLOC_FL_PUNCH_HOLE operation

fcntl.2
    Michael Kerrisk
        BUGS: The O_SYNC and O_DSYNC flags are not modifiable using F_SETFL
    Michael Kerrisk
        Add subsections under BUGS
            There's several bugs listed. It's helpful to mark
            them separately.
    Michael Kerrisk
        POSIX.1 specifies F_SETOWN and F_GETOWN for sockets/SIGURG

getrlimit.2
    Michael Kerrisk  [Марк Коренберг]
        Note that rlim_cur can be set lower than current resource consumption

getsockopt.2
    Michael Kerrisk
        SEE ALSO: add ip(7) and udp(7)

keyctl.2
    Michael Kerrisk
        SEE ALSO: mention Documentation/security/keys.txt

linkat.2
    Michael Kerrisk
        Add ENOENT for O_TMPFILE created with O_EXCL
    Michael Kerrisk
        ERRORS: Add EINVAL

lseek.2
    Michael Kerrisk
        Note which filesystems support SEEK_HOLE/SEEK_DATA

msgop.2
    Michael Kerrisk
        Note that MSG_EXCEPT is Linux-specific

open.2
    Michael Kerrisk
        Update CONFORMING TO
            Add POSIX.1-2008.  Add mention of O_TMPFILE.
            Update text on various flags that were added in POSIX.1-2008, and
            whose definitions can, since glibc 2.12, be obtained by suitably
            defining _POSIX_C_SOURCE or _XOPEN_SOURCE
    Michael Kerrisk
        Add pointer in description to BUGS, for O_ASYNC limitation
    Michael Kerrisk
        Remove crufty duplicate text on modifying file status flags

ptrace.2
    Michael Kerrisk
        Add details to descriptions of PTRACE_GETSIGMASK and PTRACE_SETSIGMASK

select.2
    Michael Kerrisk  [Marc Lehmann]
        RETURN VALUE: Fix discussion of treatment of file descriptor sets
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=574370

syscalls.2
    Michael Kerrisk
        Remove madvise1() from main list
            madvise1() is one of the system calls that was never
            implemented, and listed toward the bottom of the page.

timer_create.2
    Michael Kerrisk
        Add pointer to proc(5) for info on /proc/[pid]/timers

unlinkat.2
    Michael Kerrisk  [Mike Frysinger:]
        ERRORS: Add EISDIR
            See https://bugzilla.kernel.org/show_bug.cgi?id=29702

ferror.3
    Michael Kerrisk
        clearerr(), feof(), and ferror() are also POSIX-conformant
    Michael Kerrisk  [Reuben Thomas]
        CONFORMING TO: add fileno()

gets.3
    Ian Abbott
        SEE ALSO: add fgets(3)

mq_receive.3
mq_send.3
    Michael Kerrisk  [Simone Piccardi]
        SYNOPSIS: s/unsigned/unsigned int/

printf.3
    Michael Kerrisk
        Small reorganization of text in EXAMPLE

rand.3
    Michael Kerrisk
        s/unsigned/unsigned int/ in example

stpcpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function stpcpy() is thread safe.

stpncpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function stpncpy() is thread safe.

strcat.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions strcat() and strncat() are thread safe.

strchr.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions strchr(), strrchr() and strchrnul() are thread safe.

strcmp.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions strcmp() and strncmp() are thread safe.

strftime.3
    Brandon Edens
        Change "week day" to "day of week"
            See https://bugzilla.kernel.org/show_bug.cgi?id=68861

strstr.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function strstr() is thread safe.
            The function strcasestr() is thread safe with exceptions.

strtod.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions strtod(), strtof() and strtold() are thread safe
            with exceptions.

strtoimax.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions strtoimax() and strtoumax() are thread safe with
            exceptions.

strtol.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions strtol(), strtoll() and strtoq() are thread safe
            with exceptions.

tcgetpgrp.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions tcgetpgrp() and tcsetpgrp() are thread safe.

tcgetsid.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function tcgetsid() is thread safe.

core.5
    Bernhard Walle
        Mention that %E exists since Linux 3.0
            '%E' in the 'core_pattern' has been introduced in kernel commit
            57cc083ad9e1bfeeb4a0ee831e7bb008c8865bf0 which was included in
            version 3.0. Add that information to the manual page.

filesystems.5
    Michael Kerrisk  [Axel Beckert]
        Add reference to proc(5) for more details on /proc/filesystems
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=735590

locale.5
    Michael Kerrisk
        SEE ALSO: add locale(7)

proc.5
    Michael Kerrisk
        Document /proc/[pid]/timers
    Michael Kerrisk
        Update discussion of wchan
            Remove crufty reference to /etc/psdatabase in /proc/PID/stat.
            Add /proc/PID/wchan.

            See https://bugs.launchpad.net/ubuntu/+source/manpages/+bug/737452

environ.7
    Michael Kerrisk  [Gioele Barabucci]
        Correct reference to locale(7) (not locale(5))
            locale(7) is the right place for details of the LC_*
            environment variables.

            See http://bugs.debian.org/638186
    Michael Kerrisk
        Improve references for discussion of locale environment variables
    Michael Kerrisk
        SEE ALSO: add catopen(3)
    Michael Kerrisk
        SEE ALSO: add locale(5)

man-pages.7
    Michael Kerrisk
        Prefer "usable" over "useable"

netdevice.7
    Tilman Schmidt
        Document SIOCGIFCONF case ifc_req==NULL
            Add the missing description of the possibility to call SIOCGIFCONF
            with ifc_req==NULL to determine the needed buffer size, as
            described in
            http://lkml.indiana.edu/hypermail/linux/kernel/0110.1/0506.html
            and verified against source files net/core/dev_ioctl.c and
            net/ipv4/devinet.c in the current kernel git tree.
            This functionality has been present since the beginning of the 2.6
            series. It's about time it gets documented.

            While I'm at it, also generally clarify the section on
            SIOCGIFCONF.

standards.7
    Michael Kerrisk
        Enhance description of V7
    Michael Kerrisk
        Add C11

tcp.7
    Michael Kerrisk
        Describe format of tcp_*_congestion_control /proc files
            Describe format of tcp_allowed_congestion_control and
            tcp_available_congestion_control.


==================== Changes in man-pages-3.58 ====================

Released: 2014-02-11, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Cyril Hrubis <chrubis@suse.cz>
Daniel Borkmann <dborkman@redhat.com>
David Prévot <taffit@debian.org>
Fabrice Bauzac <libnoon@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Network Nut <sillystack@gmail.com>
Ola Olsson <ola1olsson@gmail.com>
Peng Haitao <penght@cn.fujitsu.com>
Peter Schiffer <pschiffe@redhat.com>
Simone Piccardi <piccardi@truelite.it>
Simon Paillard <spaillard@debian.org>
Yuri Kozlov <yuray@komyakino.ru>
Марк Коренберг <socketpair@gmail.com>
未卷起的浪 <ayjj_8109@qq.com>

Apologies if I missed anyone!


Newly documented interfaces in existing pages
---------------------------------------------

pipe.2
    Michael Kerrisk
        Document the pipe2() O_DIRECT flag added in Linux 3.4

packet.7
    Daniel Borkmann
        Document PACKET_QDISC_BYPASS
            New in Linux 3.14.


Global changes
--------------

Various pages
    Simon Paillard
        Formatting fix: add space between function and () if BR or IR
            Detected through the regex:
                git grep -P '^\.(BR|IR) [\w]*\([\d]*\)$'

Various pages
    Simon Paillard
        Formatting fix: add space between word and punctuation if BR or IR
            Detected through the regex:
                git grep -P '^\.(BR|IR) [^ ]*[,\.]$'

            Could probably be extended to match more cases and fix in perl.

Various pages
    Michael Kerrisk
        Use Oxford comma

gettid.2
restart_syscall.2
passwd.5
socket.7
    Michael Kerrisk
        Fix order of SEE ALSO entries


Changes to individual pages
---------------------------

epoll_wait.2
    Michael Kerrisk  [Network Nut]
        Remove word "minimum" from the description of 'timeout'

epoll_wait.2
poll.2
select.2
    Michael Kerrisk
        Go into more detail on timeout and when call will cease blocking

getxattr.2
listxattr.2
removexattr.2
setxattr.2
    Michael Kerrisk  [Fabrice Bauzac]
        Correct header file is <sys/xattr.h> (not <xattr/xattr.h>)
            See https://bugzilla.kernel.org/show_bug.cgi?id=70141

msgctl.2
    Cyril Hrubis
        Add note about ignored arg to IPC_RMID

prctl.2
    Michael Kerrisk  [Марк Коренберг]
        PR_SET_PDEATHSIG value is preserved across execve(2)

recv.2
    Michael Kerrisk
        Rework and reorganize the text in various parts of the page.
        Isolate details specific to recv() vs recvfrom() vs recvmsg()
            Place details specific to each system call under a
            separate subheading.
        Rework discussion of 'src_addr' and 'addrlen' for recvfrom()
        Add description of 'buf' and 'len' in recvfrom() section
        'addrlen' should be 0 (*not* NULL) when 'src_addr' is NULL
        Improve text describing recvfrom() call that is equivalent to recv()
    Michael Kerrisk  [未卷起的浪]
        Describe the various cases where the return value can be 0

shmctl.2
    Michael Kerrisk
        Note that 'buf' is ignored for IPC_RMID

symlinkat.2
    Michael Kerrisk
        Make argument names consistent with symlink(2) page

isalpha.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions isalnum(), isalpha(), isascii(), isblank(),
            iscntrl(), isdigit(), isgraph(), islower(), isprint(),
            ispunct(), isspace(), isupper() and isxdigit() are thread safe.

isatty.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function isatty() is thread safe.

isgreater.3
    Peng Haitao
        ATTRIBUTES: Note macros that are thread-safe
            The macros isgreater(), isgreaterequal(), isless(),
            islessequal(), islessgreater() and isunordered() are thread safe.

iswalnum.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswalnum() is thread safe with exceptions.

iswalpha.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswalpha() is thread safe with exceptions.

iswblank.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswblank() is thread safe with exceptions.

iswcntrl.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswcntrl() is thread safe with exceptions.

lockf.3
    Michael Kerrisk  [Simone Piccardi]
        Fix incorrect argument mentioned under EINVAL error

pthread_kill.3
    Michael Kerrisk
        Add feature test macro requirements

pthread_sigmask.3
    Michael Kerrisk
        Add feature test macro requirements

strtoul.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions strtoul(), strtoull() and strtouq() are thread safe
            with exceptions.

nscd.conf.5
    Peter Schiffer
        Add note about default values

proc.5
    Michael Kerrisk
        SEE ALSO: Add some further kernel Documentation/sysctl files

man-pages.7
    Michael Kerrisk
        ATTRIBUTES sections come after VERSIONS
            Peng Haitao has consistently ordered the ATTRIBUTES after
            VERSIONS, so adjust the text in man-pages.7

vdso.7
    Michael Kerrisk
        Add words "virtual dynamic shared object" in DESCRIPTION


==================== Changes in man-pages-3.59 ====================

Released: 2014-02-16, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Michael Kerrisk <mtk.manpages@gmail.com>
Peter Schiffer <pschiffe@redhat.com>
Weizhou Pan <cs.wzpan@gmail.com>

Apologies if I missed anyone!


Global changes
--------------

Various pages
    Peter Schiffer, Michael Kerrisk  [Weizhou Pan]
        Convert pages containing non-ASCII in source code comments to use UTF-8
            Done using a slightly modified version of Peter Schiffer's
            convert_to_utf_8.sh script. The script was modified so as *not*
            a "coding:" marker to the groff source. For now, we'll only put
            that marker on pages that contain non-ASCII characters in the
            rendered text.

            See https://bugzilla.kernel.org/show_bug.cgi?id=60807

armscii-8.7
cp1251.7
iso_8859-1.7
iso_8859-10.7
iso_8859-11.7
iso_8859-13.7
iso_8859-14.7
iso_8859-15.7
iso_8859-16.7
iso_8859-2.7
iso_8859-3.7
iso_8859-4.7
iso_8859-5.7
iso_8859-6.7
iso_8859-7.7
iso_8859-8.7
iso_8859-9.7
koi8-r.7
koi8-u.7
    Peter Schiffer, Michael Kerrisk  [Weizhou Pan]
        Convert pages containing non-ASCII to use UTF-8
            Done using Peter Schiffer's convert_to_utf_8.sh script.
            These pages containing non-ASCII in the rendered characters, and
            so the script inserts a "coding:" marker into the groff source.

            See https://bugzilla.kernel.org/show_bug.cgi?id=60807


==================== Changes in man-pages-3.60 ====================

Released: 2014-02-18, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

David Prévot <taffit@debian.org>
D. Barbier <bouzim@gmail.com>
Kalle Olavi Niemitalo <kon@iki.fi>
Michael Kerrisk <mtk.manpages@gmail.com>
Simon Paillard <spaillard@debian.org>

Apologies if I missed anyone!


Changes to individual pages
---------------------------
sigvec.3
    Michael Kerrisk  [Kalle Olavi Niemitalo]
        Fix error in code snippet
            s/sigpause/sigmask/

armscii-8.7
cp1251.7
iso_8859-1.7
iso_8859-10.7
iso_8859-11.7
iso_8859-13.7
iso_8859-14.7
iso_8859-15.7
iso_8859-16.7
iso_8859-2.7
iso_8859-3.7
iso_8859-4.7
iso_8859-5.7
iso_8859-6.7
iso_8859-7.7
iso_8859-8.7
iso_8859-9.7
koi8-u.7
    Michael Kerrisk  [Simon Paillard]
        Remove comment that glyphs in column 4 may not display correctly
            With the conversion to UTF-8, the glyphs in column 4 of the
            tables in these pages will display regardless of whether the
            environment is configured for the corresponding character set.

iso_8859-11.7
iso_8859-13.7
    D. Barbier  [Simon Paillard]
        Fix encoding mistakes in 5f7f4042b8848127d852c6fa7c02e31ccfaeeae5
            Fixed via:

              for f in iso_8859-11 iso_8859-13; do
                cp man7/$f.7 $f
                iconv -f utf8 -t latin1 $f | iconv -f iso-${f#iso_} -t utf8 > man7/$f.7
              done




==================== Changes in man-pages-3.61 ====================

Released: 2014-02-26, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andrew Hunter <ahh@google.com>
Carlos O'Donell <carlos@redhat.com>
Christoph Hellwig <hch@infradead.org>
Daniel Borkmann <dborkman@redhat.com>
Duncan de Wet <duncandewet@gmail.com>
Kir Kolyshkin <kir@openvz.org>
KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Neil Horman <nhorman@tuxdriver.com>
Peng Haitao <penght@cn.fujitsu.com>
Simon Paillard <spaillard@debian.org>
Sulaiman Mustafa <seininn@hush.com>
Xiawei Chen <chenxiawei@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

A note from Christoph Hellwig prompted me to perform a task that has
been queued for a while: merging the text of the man pages for the
*at([23]) ("directory file descriptor") APIs into their corresponding
traditional pages.  When the *at([23]) pages were originally written
(mostly in 2006), the APIs were not part of POSIX and (in most cases)
were not available on other systems. So, it made some sense to wall
them off into their own separate pages. Eight years later, with the
APIs now all in POSIX (except scandirat()), it is much more sensible
to document the newer APIs alongside their traditional counterparts,
so that the newer APIs are not "hidden", and the reader can more
easily see the differences between the APIs.

Thus, the text of 14 pairs of pages has been merged, and the "merged
from" pages have been converted to links to the "merged to" pages.
Along the way, a few other fixes were made to the pages, as noted
below.

One page that did not undergo such a change was utimensat(2), which
is different enough from utime(2) that it warrants a separate page.
Unlike the other *at() pages, the utimensat(2) page was also already
self-contained, rather than defining itself in terms of differences
from utime(2) as the other *at() pages did.

access.2
    Michael Kerrisk
        Merge text from faccessat(2)
    Michael Kerrisk
        Remove faccessat() race warning
            That point is already covered in existing text in this page.
    Michael Kerrisk
        access() also conforms to POSIX.1-2008

chmod.2
    Michael Kerrisk
        Merge text from fchmodat(2)
    Michael Kerrisk
        Use argument name 'pathname' throughout page
            (Some APIs were using 'path' while others used 'pathname')
    Michael Kerrisk
        CONFORMING TO: chmod() and fchmod() are also in POSIX.1-2008

chown.2
    Michael Kerrisk
        Merge text of fchownat(2)
    Michael Kerrisk
        AT_EMPTY_PATH is Linux-specific and requires _GNU_SOURCE
    Michael Kerrisk
        Use argument name 'pathname' throughout page
            (Some APIs were using 'path' while others used 'pathname')
    Michael Kerrisk
        Remove sentence that fchownat() is present on Solaris
            That point was only really relevant before fchownat() was
            standardized in POSIX.1.2008.
    Michael Kerrisk
        CONFORMING TO: chown(), fchown(), lchown() are in POSIX.1-2008

link.2
    Michael Kerrisk
        Merge text of linkat(2)
    Michael Kerrisk
        CONFORMING TO: link() is in POSIX.1-2008
    Michael Kerrisk
        AT_EMPTY_PATH is Linux-specific and requires _GNU_SOURCE

mkdir.2
    Michael Kerrisk
        Merge text of mkdirat(2)
    Michael Kerrisk
        CONFORMING TO: mkdir() is in POSIX.1-2008

mknod.2
    Michael Kerrisk
        Merge text of mknodat(2)
    Michael Kerrisk
        CONFORMING TO: mknod(2) is in POSIX.1-2008

open.2
    Michael Kerrisk
        Merge text from openat(2)
    Michael Kerrisk
        Remove sentence that openat() is present on Solaris
            That point was only really relevant before openat() was
            standardized in POSIX.1.2008.

readlink.2
    Michael Kerrisk
        Merge text of readlinkat(2)
    Michael Kerrisk
        CONFORMING TO: readlink() is in POSIX.1-2008.
    Michael Kerrisk
        Use argument name 'pathname' throughout page
            (Some APIs were using 'path' while others used 'pathname')

rename.2
    Michael Kerrisk
        Merge text of renameat(2)
    Michael Kerrisk
        CONFORMING TO: rename(2) is in POSIX.1-2008

stat.2
    Michael Kerrisk
        Merge text from fstatat(2)
    Michael Kerrisk
        AT_EMPTY_PATH and AT_NO_AUTOMOUNT are Linux-specific
            These flags require _GNU_SOURCE.
    Michael Kerrisk
        Use argument name 'pathname' throughout page
            (Some APIs were using 'path' while others used 'pathname')
    Michael Kerrisk
        Remove sentence that fstatat() is present on Solaris
            That point was only really relevant before fstatat() was
            standardized in POSIX.1.2008.
    Michael Kerrisk
        CONFORMING TO: stat(), fstat(), lstat() are specified in POSIX.1-2008

symlink.2
    Michael Kerrisk
        Merge text of symlinkat(2)
    Michael Kerrisk
        CONFORMING TO: symlink() is in POSIX.1-2008

unlink.2
    Michael Kerrisk
        Merge text of unlinkat(2)
    Michael Kerrisk
        Remove sentence that unlinkat() is present on Solaris
            That point was only really relevant before unlinkat() was
            standardized in POSIX.1.2008.
    Michael Kerrisk
        CONFORMING TO: unlink() is in POSIX.1-2008

mkfifo.3
    Michael Kerrisk
        Merge text of mkfifoat(3)
    Michael Kerrisk
        CONFORMING TO: mkfifo() is in POSIX.1-2008

scandir.3
    Michael Kerrisk
        Merge text of scandirat(3)
    Michael Kerrisk
        Update feature test macro requirements
            The FTM requirements changed in glibc 2.10.
    Michael Kerrisk
        Remove libc4/libc5 note under CONFORMING TO
            No-one much cares about Linux libc these days.
    Michael Kerrisk
        Put detail about alphasort under a NOTES heading
            This text was under CONFORMING TO, which made no sense.
    Michael Kerrisk
        Rework CONFORMING TO text


Newly documented interfaces in existing pages
---------------------------------------------

prctl.2
    Kir Kolyshkin
        Document PR_SET_MM options in Linux 3.5
            Some of the PR_SET_MM options were merged to vanilla kernel
            later, and appeared in Linux 3.5. Those are:

               - PR_SET_MM_ARG_START
               - PR_SET_MM_ARG_END
               - PR_SET_MM_ENV_START
               - PR_SET_MM_ENV_END
               - PR_SET_MM_AUXV
               - PR_SET_MM_EXE_FILE

socket.7
    Neil Horman
        Document the SO_RXQ_OVFL socket option
    Michael Kerrisk
    	Add kernel version number for SO_RXQ_OVFL


New and changed links
---------------------

faccessat.2
    Michael Kerrisk
        Convert to link to access.2

fchmodat.2
    Michael Kerrisk
        Convert to link to chmod.2

fchownat.2
    Michael Kerrisk
        Convert to link to chown.2

fstatat.2
    Michael Kerrisk
        Convert to link to stat.2

linkat.2
    Michael Kerrisk
        Convert to link to link.2

mkdirat.2
    Michael Kerrisk
        Convert to link to mkdir.2

mknodat.2
    Michael Kerrisk
        Convert to link to mknod.2

openat.2
    Michael Kerrisk
        Convert to link to open.2

readlinkat.2
    Michael Kerrisk
        Convert to link to symlink.2

renameat.2
    Michael Kerrisk
        Convert to link rename.2

symlinkat.2
    Michael Kerrisk
        Convert to link to symlink.2

unlinkat.2
    Michael Kerrisk
        Convert to link to unlink.2

mkfifoat.3
    Michael Kerrisk
        Convert to link to mkfifo.3

scandirat.3
    Michael Kerrisk
        Convert to link to scandir.3


Changes to individual pages
---------------------------

alarm.2
    Michael Kerrisk
        Note semantics of alarm with respect to fork() and execve()

fcntl.2
    Michael Kerrisk
        Warn that F_GETLK info may already be out of date when the call returns

intro.2
    Michael Kerrisk
        Describe policy on documenting differences between syscall and glibc API

mmap2.2
    Michael Kerrisk
        Reword note on glibc mmap() wrapper invocation of mmap2()
    Michael Kerrisk
        This system call does not exist on x86-64

msgctl.2
    Michael Kerrisk
        ERRORS: add EPERM for unprivileged attempt to set msg_qbytes > MSGMNB

prctl.2
    Michael Kerrisk  [Xiawei Chen]
        Clarify that PR_GET_TIMERSLACK is returned as the function result
    Michael Kerrisk
        Clarify that PR_GET_SECCOMP is returned as function result
    Michael Kerrisk
        Clarify that PR_GET_NO_NEW_PRIVS is returned as function result

ptrace.2
    Michael Kerrisk  [Andrew Hunter]
        Make it clearer that glibc and syscall APIs differ for PTRACE_PEEK*
            Thanks to Denys Vlasenko's additions in 78686915aed6bd12
            this page does note that the glibc API for PTRACE_PEEK*
            differs from the raw syscall interface. But, as the report
            at https://bugzilla.kernel.org/show_bug.cgi?id=70801 shows,
            this information could be more obvious. This patch makes its so.

sgetmask.2
    Michael Kerrisk
        Note that these system calls don't exist on x86-64

swapon.2
    Michael Kerrisk
        Split EINVAL cases into separate entries under ERRORS
    Michael Kerrisk
        Add EINVAL error for invalid flags to swapon()

syscalls.2
    Michael Kerrisk
        SEE ALSO: add intro(2)

umount.2
    Michael Kerrisk
        Split EINVAL cases into separate items
    Michael Kerrisk
        ERRORS: Add EINVAL case that was new in 2.6.34

utime.2
    Michael Kerrisk
        Add note that modern applications probably want utimensat(2) etc.

crypt.3
    Michael Kerrisk  [KOSAKI Motohiro]
        ERRORS: Add EINVAL and EPERM errors
            See https://bugzilla.kernel.org/show_bug.cgi?id=69771

getifaddrs.3
    Michael Kerrisk
        Enhance example program
            Print statistics for AF_PACKET interfaces.
            Add missing feature test macro definition.
            Reformat output.

iswctype.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function iswctype() is thread safe.

sem_post.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sem_post() is thread safe.

sem_unlink.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sem_unlink() is thread safe.

sem_wait.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions sem_wait(), sem_trywait() and sem_timedwait() are
            thread safe.

setbuf.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions setbuf(), setbuffer(), setlinebuf() and setvbuf()
            are thread safe.

strlen.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function strlen() is thread safe.

strnlen.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function strnlen() is thread safe.

strpbrk.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function strpbrk() is thread safe.

strsep.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function strsep() is thread safe.

swab.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function swab() is thread safe.

resolv.conf.5
    Carlos O'Donell
        DESCRIPTION: mention that the data is trusted
            In a recent discussion about DNSSEC it was brought to my
            attention that not all system administrators may understand
            that the information in /etc/resolv.conf is fully trusted.
            The resolver implementation in glibc treats /etc/resolv.conf
            as a fully trusted source of DNS information and passes on
            the AD-bit for DNSSEC as trusted.

            This patch adds a clarifying sentence to make it absolutely
            clear that indeed this source of information is trusted.

ascii.7
    Michael Kerrisk  [Sulaiman Mustafa]
        Fix rendering of single quote (decimal character 39)
    Michael Kerrisk
        SEE ALSO: add utf-8(7)
    Michael Kerrisk  [Duncan de Wet]
        Remove mention of ISO 8859-1 as being the default encoding on Linux

packet.7
    Neil Horman
        Document PACKET_FANOUT_QM fanout mode
    Michael Kerrisk
        Add kernel version for PACKET_FANOUT_QM
    Daniel Borkmann
        Improve PACKET_QDISC_BYPASS description

socket.7
    Michael Kerrisk
        Add kernel version number for SO_BUSY_POLL


==================== Changes in man-pages-3.62 ====================

Released: 2014-03-11, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Cyril Hrubis <chrubis@suse.cz>
Joseph S. Myers <joseph@codesourcery.com>
Marius Gaubas <marius@livejournalinc.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Peng Haitao <penght@cn.fujitsu.com>
Rick Stanley <rstanley@rsiny.com>
Simon Paillard <spaillard@debian.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

locale.1
    Michael Kerrisk [review from Mike Frysinger]
        New page describing locale(1)


Newly documented interfaces in existing pages
---------------------------------------------

locale.5
    Michael Kerrisk
        Document LC_ADDRESS
    Michael Kerrisk
        Document LC_IDENTIFICATION
    Michael Kerrisk
        Document LC_MEASUREMENT
    Michael Kerrisk
        Document LC_NAME
    Michael Kerrisk
        Document LC_PAPER
    Michael Kerrisk
        Document LC_TELEPHONE


Removed Pages
-------------

sync.8
    Michael Kerrisk  [Christoph Hellwig, Pádraig Brady]
        Sometime in the 20th century (before my watch), a sync(8)
        page into man-pages. It documents the sync command from
        "fileutils", which long ago become coreutils, and the
        piece under NOTES note some behavior of sync(2)
        that ceased to be true many years ago.  The man-pages
	project generally focuses on only Linux kernel and
        (g)libc interfaces, so this sync(8) page doesn't really
	belong.  Furthermore, coreutils has a sync(1) page which
	covers the same command. After discussions on the
	coreutils list, I've decided to retire this page from
	man-pages.

Changes to individual pages
---------------------------

clone.2
    Michael Kerrisk
        Note that CLONE_THREAD also in effect requires CLONE_VM

stat.2
    Michael Kerrisk  [Marius Gaubas]
        Warn the reader that the 'stat' structure definition is not precise
            Padding fields aren't shown, and the order of fields varies
            somewhat across architectures.

gethostbyname.3
    Michael Kerrisk
        Remove redundant FTM requirements
            _GNU_SOURCE implies _SVID_SOURCE and _BSD_SOURCE, so

                _BSD_SOURCE || _SVID_SOURCE || _GNU_SOURCE

            is the same as

                _BSD_SOURCE || _SVID_SOURCE

getutmp.3
    Michael Kerrisk
        SEE ALSO: add utmpdump(1)

log1p.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions log1p(), log1pf() and log1pl() are thread safe.

logb.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions logb(), logbf() and logbl() are thread safe.

memccpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function memccpy() is thread safe.

memchr.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions memchr(), memrchr() and rawmemchr() are thread safe.

mktemp.3
    Michael Kerrisk
        Make warning not to use this function more prominent

qecvt.3
    Michael Kerrisk  [Joseph S. Myers]
        Recommend snprintf(3) not sprintf(3)

raise.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function raise() is thread safe.

remove.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function remove() is thread safe.

sem_destroy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sem_destroy() is thread safe.

sem_getvalue.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sem_getvalue() is thread safe.

sem_init.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sem_init() is thread safe.

sockatmark.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sockatmark() is thread safe.

strcpy.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions strcpy() and strncpy() are thread safe.
    Michael Kerrisk  [Rick Stanley]
        Fix a bug, and improve discussion of forcing termination with strncpy()

strspn.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions strspn() and strcspn() are thread safe.

tempnam.3
    Michael Kerrisk
        Make warning not to use this function more prominent

tmpnam.3
    Michael Kerrisk
        Recommend use mkstemp(3) or tmpfile(3) instead

locale.5
    Michael Kerrisk
        Add intro section that lists all of the LC categories
    Michael Kerrisk
        'p_cs_precedes' is for *positive* values
    Michael Kerrisk
        Clarify 'p_sign_posn' and 'n_sign_posn'; simplify 'n_sign_posn'
            Add initial sentence for 'p_sign_posn' and 'n_sign_posn'.
            Remove repeated list for 'n_sign_posn'.
    Michael Kerrisk
        Document LC_MESSAGES 'yesstr' and 'nostr'
    Michael Kerrisk
        Clarify LC_MONETARY 'n_cs_precedes'
    Michael Kerrisk
        LC_MONETARY: Document 'int_p_sign_posn' and 'int_n_sign_posn'
    Michael Kerrisk
        Clarify/rework 'p_cs_precedes' and 'n_cs_precedes'
    Michael Kerrisk
        LC_MONETARY: document 'int_p_sep_by_space' and 'int_n_sep_by_space'
    Michael Kerrisk
        Remove crufty reference to POSIX.2
    Michael Kerrisk
        LC_MONETARY: document 'int_p_cs_precedes' and 'int_n_cs_precedes'
    Michael Kerrisk
        Clarify/simplify 'n_sep_by_space'
    Michael Kerrisk
        LC_TIME: document 'cal_direction' and 'date_fmt'
    Michael Kerrisk
        Clarify 'p_sep_by_space'

feature_test_macros.7
    Michael Kerrisk
        _BSD_SOURCE and _SVID_SOURCE are deprecated in glibc 2.20
    Michael Kerrisk
        _GNU_SOURCE implicitly defines other macros
            Saying that _GNU_SOURCE has the "effects of" other macros is not
            quite precise.
    Michael Kerrisk
        Reword glibc version for _ISOC95_SOURCE
    Michael Kerrisk
        _ISOC99_SOURCE also exposes C95 definitions
    Michael Kerrisk
        _ISOC11_SOURCE implies the effects of _ISOC99_SOURCE
    Michael Kerrisk
        Note version number for _POSIX_C_SOURCE >= 200112L implies C99/C95
            _POSIX_C_SOURCE >= 200112L causes C95 definitions to be
            exposed only since glibc 2.12 and C99 definitions only
            since 2.10.
    Michael Kerrisk
        _XOPEN_SOURCE may implicitly define _POSIX_SOURCE and _POSIX_C_SOURCE
    Michael Kerrisk
        Reword glibc version for _ISOC99_SOURCE
    Michael Kerrisk
        Rework discussion of _ISOC99_SOURCE
    Michael Kerrisk
        Improve discussion of _DEFAULT_SOURCE
    Michael Kerrisk
        _POSIX_C_SOURCE >= 200112L implies C95 and C95 features



==================== Changes in man-pages-3.63 ====================

Released: 2014-03-18, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Carlos O'Donell <carlos@redhat.com>
Christoph Hellwig <hch@infradead.org>
Corrado Zoccolo <czoccolo@gmail.com>
Gregory P. Smith <gps@google.com>
Joseph S. Myers <joseph@codesourcery.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Peng Haitao <penght@cn.fujitsu.com>
Phillip Susi <psusi@ubuntu.com>
Robert P. J. Day <rpjday@crashcourse.ca>
Stefan Puiu <stefan.puiu@gmail.com>
Zhu Yanhai <zhu.yanhai@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

duplocale.3
    Michael Kerrisk
        New page documenting duplocale(3)

newlocale.3
    Michael Kerrisk  [Mike Frysinger]
        New page documenting newlocale(3) and freelocale(3)

towlower.3
    Michael Kerrisk
        Largely rewrite description of towlower() to be simpler and clearer

towupper.3
    Michael Kerrisk
        Largely rewrite description of towupper() to be simpler and clearer

uselocale.3
    Michael Kerrisk
        New page documenting uselocale(3)


Newly documented interfaces in existing pages
---------------------------------------------

open.2
    Michael Kerrisk
        Document O_DSYNC and rewrite discussion of O_SYNC

isalpha.3
    Michael Kerrisk
        Document the "_l" locale APIs
            The GNU C library v2.3 added some locale APIs, most of which
            were later specified in POSIX.1-2008, namely:

                   isalnum_l()
                   isalpha_l()
                   isblank_l()
                   iscntrl_l()
                   isdigit_l()
                   isgraph_l()
                   islower_l()
                   isprint_l()
                   ispunct_l()
                   isspace_l()
                   isupper_l()
                   isxdigit_l()
                   isascii_l()

            Also update and correct various pieces in CONFORMING TO
            (and remove a few crufty old pieces there).

strerror.3
    Michael Kerrisk
        Document strerror_l()

toupper.3
    Michael Kerrisk
        Document toupper_l() and tolower_l()

towlower.3
    Michael Kerrisk
        Document towlower_l()

towupper.3
    Michael Kerrisk
        Document towupper_l()

proc.5
    Michael Kerrisk
        Document /proc/sys/kernel/random/uuid

locale.7
    Michael Kerrisk
        Document LC_ADDRESS
        Document LC_IDENTIFICATION
        Document LC_MEASUREMENT
        Document LC_NAME
        Document LC_PAPER
        Document LC_TELEPHONE


New and changed links
---------------------

freelocale.3
    Michael Kerrisk
        New link to new newlocale.3 page

isalnum_l.3
isascii_l.3
isblank_l.3
iscntrl_l.3
isdigit_l.3
isgraph_l.3
islower_l.3
isprint_l.3
ispunct_l.3
isspace_l.3
isupper_l.3
isxdigit_l.3
    Michael Kerrisk
        New links to isalpha.3

tolower_l.3
toupper_l.3
    Michael Kerrisk
        New links to toupper.3

towlower_l.3
    Michael Kerrisk
        New link to towlower.3

towupper_l.3
    Michael Kerrisk
        New link to towupper.3


Global changes
--------------

Various pages
    Michael Kerrisk
        Global change: "upper case" ==> "uppercase", "lower case" ==> lowercase"


Changes to individual pages
---------------------------

mount.2
    Michael Kerrisk
        SEE ALSO: add blkid(1)

msgop.2
    Michael Kerrisk
        Document two MSG_COPY failure modes
            Since Linux 3.14, the kernel now diagnoses two errors
            when using msgrcv() MSG_COPY:
            * MSG_COPY must be specified with IPC_NOWAIT
            * MSG_COPY can't be specified with MSG_EXCEPT

open.2
    Michael Kerrisk
        Organize some material under additional subheadings in NOTES
            There's an amorphous mass of material under NOTES.  Structure
            it with some subheadings, and do a little reorganizing.
    Michael Kerrisk
        Add other system calls and functions that are like openat()
            fanotify_mark(2), name_to_handle_at(2), and scandirat(3) have a
            directory file descriptor argument for the same reason as openat().
            Also: reword the rationale for the *at() functions somewhat.
    Michael Kerrisk
        Clarify ELOOP error interaction with O_PATH

readahead.2
    Phillip Susi  [Corrado Zoccolo, Gregory P. Smith, Zhu Yanhai, Michael Kerrisk, Christoph Hellwig]
        Don't claim the call blocks until all data has been read
            The readahead(2) man page was claiming that the call blocks until
            all data has been read into the cache.  This is incorrect.

            See https://bugzilla.kernel.org/show_bug.cgi?id=54271

stat.2
    Michael Kerrisk
        SEE ALSO: add ls(1) and stat(1)

fts.3
    Christoph Hellwig  [Michael Kerrisk]
        The fts(3) API does not work with LFS builds
            As pointed out during a recent discussion on libc-hacker the
            fts(3) APIs can't be used with large file offsets:

                https://sourceware.org/bugzilla/show_bug.cgi?id=15838

mbrtowc.3
mbsnrtowcs.3
mbsrtowcs.3
mbtowc.3
    Michael Kerrisk
        Add entries in SEE ALSO
            Mainly inspired by the POSIX pages.

mbsinit.3
    Michael Kerrisk
        SEE ALSO: add mbrlen(3), mbrtowc(3), and wcrtomb(3)

mbsrtowcs.3
wcsrtombs.3
    Michael Kerrisk
        SEE ALSO: add mbsinit(3)

mbstowcs.3
    Michael Kerrisk  [Stefan Puiu]
        Add example program
            And add some SEE ALSO entries

memcmp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function memcmp() is thread safe.

memcpy.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function memcpy() is thread safe.

memfrob.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function memfrob() is thread safe.

memmem.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function memmem() is thread safe.

memmove.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function memmove() is thread safe.

mempcpy.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions mempcpy() and wmempcpy() are thread safe.

memset.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function memset() is thread safe.

strerror.3
    Michael Kerrisk
        CONFORMING TO: strerror() and strerror_r() are in POSIX.1-2008
    Michael Kerrisk
        Add SS heading for strerror_r()

toupper.3
    Michael Kerrisk
        Rewrite to more explicitly bring locales into the discussion
    Michael Kerrisk
        Retitle BUGS section to NOTES
            These are not really bugs, just background info.

wcrtomb.3
wcsnrtombs.3
wcsrtombs.3
wcstombs.3
wctomb.3
    Michael Kerrisk
        SEE ALSO: add various entries
            Mainly inspired by POSIX

core.5
    Mike Frysinger  [Michael Kerrisk]
        Document core_pattern %d specifier
        Document %P core_pattern specifier
    Michael Kerrisk
        Rearrange core_pattern specifiers alphabetically

locale.5
    Michael Kerrisk
        SEE ALSO: add newlocale(3) + duplocale(3)

feature_test_macros.7
    Michael Kerrisk  [Joseph S. Myers]
        Remove mention of bogus _ISOC95_SOURCE macro
            The _ISOC95_SOURCE macro is defined in <features.h>, but it
            does nothing. So remove discussion of it, and move some of
            the discussion of C95 under the _ISOC99_SOURCE subhead.
    Michael Kerrisk  [Carlos O'Donell]
        Add packaging note for _BSD_SOURCE/_SVID_SOURCE/_DEFAULT_SOURCE
            To compile warning-free across glibc < 2.20 and glibc >= 2.20
            code may been to define both _DEFAULT_SOURCE and either
            _BSD_SOURCE or _SVID_SOURCE.
    Michael Kerrisk
        Reword description of C90

locale.7
    Michael Kerrisk
        Add subsection on POSIX.1-2008 (originally GNU) extensions to locale API
    Michael Kerrisk
        Remove reference to LI18NUX2000
            LI18NUX2000 is difficult to even find these days, and in any case
            this page does not document gettext(), so notes about gettext()
            in the CONFORMING TO section here make no sense.
    Michael Kerrisk
        SEE ALSO: add mbstowcs(3) and wcstombs(3)
        SEE ALSO: add newlocale(3) + duplocale(3)

man-pages.7
    Michael Kerrisk
        Add preferred term "superblock"
    Michael Kerrisk
        Add preferred terms "uppercase" and "lowercase"



==================== Changes in man-pages-3.64 ====================

Released: 2014-04-06, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Abhay Sachan <sachan.abhay@gmail.com>
Alexey Samsonov <samsonov@google.com>
Andrey Vagin <avagin@openvz.org>
Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Christoph Hellwig <hch@infradead.org>
David Prévot <taffit@debian.org>
Eric Dumazet <edumazet@google.com>
Eric W. Biederman <ebiederm@xmission.com>
Jan Kara <jack@suse.cz>
Kir Kolyshkin <kir@openvz.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
NeilBrown <neilb@suse.de>
Peng Haitao <penght@cn.fujitsu.com>
Peter Hurley <peter@hurleysoftware.com>
Petr Gajdos <pgajdos@suse.cz>
Robert P. J. Day <rpjday@crashcourse.ca>
Vince Weaver <vincent.weaver@maine.edu>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

open_by_handle_at.2
    Michael Kerrisk [Mike Frysinger, Neil Brown, Aneesh Kumar K.V,
    Christoph Hellwig]
        New page describing name_to_handle_at(2) and open_by_handle_at(2)

inotify.7
    Michael Kerrisk
        Rewrite introductory section
        Reorganize "Limitations and caveats" subsection
    Michael Kerrisk
        Further describe the race when adding a watch to a new subtree
    Michael Kerrisk
        Directory renames may invalidate multiple paths cached by application
    Michael Kerrisk
        Add paragraph on cache consistency checking
    Michael Kerrisk
        Mention cache rebuilding to handle overflow events
    Michael Kerrisk
        Moving an object to another filesystem generates IN_DELETE_SELF
    Michael Kerrisk [Jan Kara]
        Add text on dealing with rename() events
    Michael Kerrisk
        Note rationale and consequences of event coalescing
    Michael Kerrisk  [Eric W. Biederman]
        Inotify doesn't work for remote and pseudo filesystems
    Michael Kerrisk
        Add some examples of events generated by various system calls
    Michael Kerrisk
        BUGS: IN_ONESHOT does now cause IN_IGNORED when the watch is dropped
            A silent change as a result of the fanotify work in kernel 2.6.36.
    Michael Kerrisk
        Note that IN_DELETE_SELF will be followed by IN_IGNORED
    Michael Kerrisk
        Note that IN_UNMOUNT will be followed by an IN_IGNORED event
    Michael Kerrisk
        Inotify does not report events for mmap(2) and msync(2)
    Michael Kerrisk
        Add examples of syscalls that trigger IN_ATTRIB
    Michael Kerrisk
        Add some examples of syscalls that trigger IN_MODIFY
    Michael Kerrisk
        execve(2) also generates IN_ACCESS
    Michael Kerrisk
        Add examples of syscalls that trigger IN_CREATE


Newly documented interfaces in existing pages
---------------------------------------------

perf_event_open.2
    Vince Weaver [Michael Kerrisk]
        Document the PERF_FLAG_FD_CLOEXEC flag
            The Linux 3.14 release adds support for the PERF_FLAG_FD_CLOEXEC
            flag.

feature_test_macros.7
    Michael Kerrisk
        Document _LARGEFILE_SOURCE

tcp.7
    Michael Kerrisk  [Eric Dumazet]
        Document /proc/sys/net/ipv4/tcp_autocorking
            Text heavily based on Documentation/networking/ip-sysctl.txt


New and changed links
---------------------

name_to_handle_at.2
    Michael Kerrisk
        New link to new open_by_handle_at(2) page


Global changes
--------------

fmemopen.3
getaddrinfo.3
mq_notify.3
offsetof.3
aio.7
    Michael Kerrisk
        Print size_t/ssize_t values using %z printf() modifier
            There are fewer and fewer systems these days that don't
            support the %z specifier mandated in C99.  So replace the
            use of %ld/%lu + (long) cast with %zd/%zu.


Changes to individual pages
---------------------------

bdflush.2
fsync.2
sync.2
    Kir Kolyshkin
        SEE ALSO: remove update(8) reference
            Remove reference to update(8) man page, since there is no such
            page. This is an ancient BSD leftover I believe.

chown.2
    Michael Kerrisk
        Note that 'dirfd' can be AT_FDCWD when AT_EMPTY_PATH is used

getxattr.2
    Abhay Sachan
        Fix RETURN VALUE description
            A EA can have length zero.

inotify_add_watch.2
    Michael Kerrisk
        ERRORS: add ENAMETOOLONG

inotify_init.2
    Michael Kerrisk
        Add pointer to inotify(7)

link.2
    Michael Kerrisk
        When AT_EMPTY_PATH is specified, 'olddirfd' must not refer to a
        directory

mmap.2
    Andrey Vagin
        The file descriptor for a file mapping must be readable
            There is no difference between MAP_SHARED and MAP_PRIVATE.

open.2
    Michael Kerrisk
        SEE ALSO: add open_by_name_at(2)

perf_event_open.2
    Vince Weaver
        Document PERF_EVENT_IOC_PERIOD behavior change
            Linux 3.14 (in commit bad7192b842c83e580747ca57104dd51fe08c223)
            changes the perf_event PERF_EVENT_IOC_PERIOD ioctl() behavior
            on all architectures to update immediately, to match the behavior
            found on ARM.

stat.2
    Michael Kerrisk
        Note that 'dirfd' can be AT_FDCWD when AT_EMPTY_PATH is used

syscalls.2
    Michael Kerrisk
        Add sched_getattr() and sched_setattr()
            And update kernel version to 3.14

abort.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function abort() is thread safe.

confstr.3
    Michael Kerrisk
        SEE ALSO: add getconf(1), fpathconf(3), sysconf(3), pathconf(3)

exit.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function exit() is not thread safe.

fenv.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions feclearexcept(), fegetexceptflag(), feraiseexcept(),
            fesetexceptflag(), fetestexcept(), fegetround(), fesetround(),
            fegetenv(), feholdexcept(), fesetenv(), feupdateenv(),
            feenableexcept(), fedisableexcept() and fegetexcept() are thread
            safe.

fpathconf.3
    Michael Kerrisk
        SEE ALSO: add confstr(3)

fseek.3
    Michael Kerrisk  [Petr Gajdos]
        Document EINVAL error for negative file offset

fseeko.3
    Michael Kerrisk
        Add feature test macro requirements

fts.3
    Michael Kerrisk  [Mike Frysinger]
        Remove mention of "32-bit systems" in BUGS

fwide.3
wprintf.3
    Michael Kerrisk  [Robert P. J. Day]
        Remove mention of bogus _ISOC95_SOURCE feature test macro

getline.3
    Alexey Samsonov
        Caller should free the allocated buffer even if getline() failed
            Relevant discussion in glibc bugzilla:
            https://sourceware.org/bugzilla/show_bug.cgi?id=5666

getloadavg.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function getloadavg() is thread safe.

getpt.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function getpt() is thread safe.

if_nametoindex.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions if_nametoindex() and if_indextoname() are thread safe.

index.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions index() and rindex() are thread safe.

mkfifo.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions mkfifo() and mkfifoat() are thread safe.

netlink.3
    Michael Kerrisk
        SEE ALSO: make the reference for libnetlink the libnetlink(3) man page

random.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions random(), srandom(), initstate() and setstate()
            are thread safe.

random_r.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions random_r(), srandom_r(), initstate_r() and
            setstate_r() are thread safe.

sigvec.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions sigvec(), sigblock(), sigsetmask() and
            siggetmask() are thread safe.

            The macro sigmask() is thread safe.

sysconf.3
    Michael Kerrisk
        SEE ALSO: add confstr(3)

termios.3
    Michael Kerrisk  [Peter Hurley]
        Fix error in discussion of MIN > 0, TIME == 0 noncanonical mode
            As reported by Peter Hurley, for the MIN > 0, TIME == 0 case:

                read() may unblock when MIN bytes are available but return
                up to the 'count' parameter if more input arrives in between
                waking and copying into the user buffer.
                ...
                read() may also _not_ return until MIN bytes have been
                received, even if 'count' bytes have been received.
    Michael Kerrisk
        Add a note on interaction of O_NONBLOCK with noncanonical MIN/TIME
            POSIX leaves the behavior open.
    Michael Kerrisk
        Clarify termination conditions for MIN > 0, TIME > 0
    Michael Kerrisk
        Clarify behavior if data is available before noncanonical read()
    Michael Kerrisk
        Add descriptive titles to noncanonical read() cases

symlink.7
    Michael Kerrisk
        Add subsection on opening a symbolic link with O_PATH
    Michael Kerrisk
        name_to_handle_at(2) and open_by_handle_at(2) optionally follow symlinks
    Michael Kerrisk
        Mention use of readlink(2) to read contents of a symlink


==================== Changes in man-pages-3.65 ====================

Released: 2014-04-20, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alex Thorlton <athorlton@sgi.com>
Ashish Sangwan <a.sangwan@samsung.com>
Christopher Covington <cov@codeaurora.org>
Christoph Hellwig <hch@infradead.org>
Craig McQueen <craig.mcqueen@beamcommunications.com>
Dave Chinner <david@fromorbit.com>
David Prévot <taffit@debian.org>
Greg Troxel <gdt@ir.bbn.com>
Matthew Dempsky <mdempsky@chromium.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Namjae Jeon <namjae.jeon@samsung.com>
Peng Haitao <penght@cn.fujitsu.com>
Petr Gajdos <pgajdos@suse.cz>
Richard Hansen <rhansen@bbn.com>
Simon Paillard <spaillard@debian.org>
Steven Stewart-Gallus <sstewartgallus00@mylangara.bc.ca>
Vince Weaver <vincent.weaver@maine.edu>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

inet_net_pton.3
    Michael Kerrisk
        New page describing inet_net_pton(3) and inet_net_ntop(3)


Newly documented interfaces in existing pages
---------------------------------------------

fallocate.2
    Michael Kerrisk, Namjae Jeon [Christoph Hellwig, Dave Chinner]
        Document FALLOC_FL_COLLAPSE_RANGE

prctl.2
    Michael Kerrisk  [Alex Thorlton]
        Document PR_SET_THP_DISABLE and PR_GET_THP_DISABLE

proc.5
    Michael Kerrisk
        Document /proc/[pid]/stack
    Michael Kerrisk
        Document /proc/[pid]/clear_refs


New and changed links
---------------------

inet_net_ntop.3
    Michael Kerrisk
        New link to new inet_net_pton.3


Changes to individual pages
---------------------------

fcntl.2
    Michael Kerrisk
        Note the race when O_CLOEXEC is used at same time as fork()+execve()

madvise.2
    Michael Kerrisk
        SEE ALSO: see prctl(2)
            Because of PR_SET_THP_DISABLE.

mlock.2
    Michael Kerrisk
        Describe treatment of MCL_FUTURE during fork(2) and execve(2)

msync.2
    Michael Kerrisk  [Richard Hansen, Greg Troxel]
        Warn that one of MS_SYNC or MS_ASYNC is required

open.2
    Michael Kerrisk
        Add more detail on the race that O_CLOEXEC is designed to avoid
    Michael Kerrisk  [Matthew Dempsky]
        Remove crufty text stating that O_DIRECTORY is Linux-specific
    Michael Kerrisk
        Note which filesystems support O_TMPFILE

perf_event_open.2
    Vince Weaver [Michael Kerrisk]
        Clarify EACCES and EPERM errors
            Clarify the reasons for EACCES and EPERM errors.
    Vince Weaver [Michael Kerrisk]
        Make the ERRORS section more comprehensive.
            Determined both by code inspection and by writing a large
            number of test programs.

personality.2
    Michael Kerrisk
        Available execution domains are listed in <sys/personality.h>
    Michael Kerrisk
        Fix discussion of return value

prctl.2
    Michael Kerrisk
        ERRORS: document EINVAL for PR_GET_NO_NEW_PRIVS
        ERRORS: document EINVAL for PR_SET_PDEATHSIG
        ERRORS: document EINVAL for PR_SET_TIMING
        ERRORS: document EINVAL for PR_SET_DUMPABLE
        ERRORS: document EINVAL for PR_SET_NO_NEW_PRIVS

shmget.2
    Michael Kerrisk
        Rewrite description of SHMMNI default value
    Michael Kerrisk
        Note default value of SHMMAX
        Note default value for SHMALL

byteorder.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions htonl(), htons(), ntohl() and ntohs() are thread
            safe.

fexecve.3
    Michael Kerrisk  [Steven Stewart-Gallus]
        If 'fd' is a close-on-exec file descriptor for a script, fexecve() fails
            See https://bugzilla.kernel.org/show_bug.cgi?id=74481

ffs.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions ffs(), ffsl() and ffsll() are thread safe.

getauxval.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function getauxval() is thread safe.

getcontext.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions getcontext() and setcontext() are thread safe.

getsubopt.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function getsubopt() is thread safe.

getutmp.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions getutmp() and getutmpx() are thread safe.

inet.3
    Michael Kerrisk
        Note success and error return for inet_aton()

inet.3
    Michael Kerrisk  [Craig McQueen]
        The form 'a.b' if is suitable for Class A addresses (not class C)
    Michael Kerrisk
        SEE ALSO: add inet_net_pton(3)

makecontext.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions makecontext() and swapcontext() are thread safe.

pthread_attr_setdetachstate.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setdetachstate() and
            pthread_attr_getdetachstate() are thread safe.

pthread_attr_setguardsize.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setguardsize() and
            pthread_attr_getguardsize() are thread safe.

sigsetops.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions sigemptyset(), sigfillset(), sigaddset(),
            sigdelset(), sigismember(), sigisemptyset(), sigorset() and
            sigandset() are thread safe.

proc.5
    Petr Gajdos
        Improve /proc/[pid]/smaps entries description
    Michael Kerrisk
        /proc/PID/smaps is present only if CONFIG_PROC_PAGE_MONITOR
    Michael Kerrisk
        Note kernel version for /proc/sys/kernel/{shmall,shmmax}
    Michael Kerrisk
        Note kernel version for /proc/sys/kernel/{msgmax,msgmnb}

capabilities.7
    Michael Kerrisk
        SEE ALSO: add capsh(1)

libc.7
    Michael Kerrisk
        Add musl libc


==================== Changes in man-pages-3.66 ====================

Released: 2014-05-08, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alan Curry <rlwinm@sdf.org>
Carsten Andrich <carsten.andrich@tu-ilmenau.de>
Daniel Borkmann <dborkman@redhat.com>
David Prévot <taffit@debian.org>
Eric Siegerman <pub08-knl@davor.org>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Jan Kara <jack@suse.cz>
Jan Moskyto Matejka <mq@suse.cz>
John Marshall <jm18@sanger.ac.uk>
Lukáš Czerner <lczerner@redhat.com>
Manfred Spraul <manfred@colorfullife.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Miklos Szeredi <miklos@szeredi.hu>
Neil Horman <nhorman@tuxdriver.com>
Peng Haitao <penght@cn.fujitsu.com>
Peter Schiffer <pschiffe@redhat.com>
Randy Dunlap <rdunlap@infradead.org>
Silvan Jegen <s.jegen@gmail.com>
Simon Paillard <spaillard@debian.org>
Stefan Puiu <stefan.puiu@gmail.com>
Steven Stewart-Gallus <sstewartgallus00@mylangara.bc.ca>
Stijn Hinterding <contact@stijnhinterding.nl>
Willem de Bruijn <willemb@google.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

fanotify_init.2
    Heinrich Schuchardt, Michael Kerrisk
        New page documenting fanotify_init(2)

fanotify_mark.2
    Heinrich Schuchardt, Michael Kerrisk
        New page documenting fanotify_mark(2)

sched_setscheduler.2
    Michael Kerrisk
        Page rewritten
            Stripped out the general scheduling material, which
            moved to sched(7), and rewrote much of the remainder.
            Changed copyright and license since pretty much all
            of the content was or is written by mtk.

fanotify.7
    Heinrich Schuchardt, Michael Kerrisk
        New page providing overview of the fanotify API

sched.7
    Michael Kerrisk
        New page providing an overview of the scheduling APIs
            Most of this content derives from sched_setscheduler(2). In
            preparation for adding a sched_setattr(2) page, it makes
            sense to isolate out this general content to a separate
            page that is referred to by the other scheduling pages.


Newly documented interfaces in existing pages
---------------------------------------------

fallocate.2
    Lukas Czerner [Michael Kerrisk]
        Document FALLOC_FL_ZERO_RANGE
            FALLOC_FL_ZERO_RANGE was added in Linux 3.14,
            for zeroing ranges in the allocated space in a file.

rename.2
    Miklos Szeredi [Michael Kerrisk]
        Document renameat2() system call added in Linux 3.15

shmop.2
    Michael Kerrisk
        Document SHM_EXEC


Changes to individual pages
---------------------------

flock.2
    Michael Kerrisk
        Employ term "open file description" in DESCRIPTION
            And include reference to open(2) for an explanation of the term.

getpriority.2
    Michael Kerrisk
        SEE ALSO: add sched(7)

getsockopt.2
    Carsten Andrich
        SEE ALSO: add packet(7)

link.2
    Michael Kerrisk  [Steven Stewart-Gallus]
        Document ENOENT error for linkat()
            See https://bugzilla.kernel.org/show_bug.cgi?id=73301

msgget.2
    Michael Kerrisk
        Reword EEXIST error

msgop.2
    Michael Kerrisk
        Note capability required to raise MQ size beyond MSGMNB

msync.2
    Michael Kerrisk  [Heinrich Schuchardt]
        s/flushes... back to disk/flushes... back to filesystem/

nice.2
    Michael Kerrisk
        SEE ALSO: add sched(7)

open.2
    Peter Schiffer
        Update note on alignment of user buffer and file offset for O_DIRECT
            The sentence in open(2) man page in notes for O_DIRECT flag:

                "Under Linux 2.6, alignment to 512-byte boundaries suffices."

            is not universally correct. The alignment is a property of the
            storage, for example, 4k-sector drives with no 512 byte sector
            emulation will be unable to perform 512-byte direct I/O.
    Michael Kerrisk
        Note some of the various synonyms for "open file description"
    Michael Kerrisk
        Remove repetitious text on use of fcntl() to change file status flags

open_by_handle_at.2
    Michael Kerrisk
        Mention FreeBSD analogs

posix_fadvise.2
    Michael Kerrisk  [Eric Siegerman]
        Fix wording error under "Architecture-specific variants"
            See https://bugzilla.kernel.org/show_bug.cgi?id=75431

process_vm_readv.2
    Michael Kerrisk  [Stijn Hinterding]
        Add feature test macro requirements
            The _GNU_SOURCE FTM must be defined.

read.2
    Michael Kerrisk
        BUGS: detail nonatomicity bug with respect to file offset updates
            This bug was fixed in Linux 3.14, with commit
            9c225f2655e36a470c4f58dbbc99244c5fc7f2d4
            See also http://thread.gmane.org/gmane.linux.kernel/1649458

sched_get_priority_max.2
    Michael Kerrisk
        Small changes consistent with migration of content to sched(7)

sched_rr_get_interval.2
    Michael Kerrisk
        Small changes consistent with migration of content to sched(7)

sched_setaffinity.2
    Michael Kerrisk
        Small changes consistent with migration of content to sched(7)

sched_setparam.2
    Michael Kerrisk
        Small changes consistent with migration of content to sched(7)

sched_yield.2
    Michael Kerrisk
        Small changes consistent with migration of content to sched(7)

semget.2
    Michael Kerrisk
        Consolidate discussion on noninitialization of semaphores
            The fact that semget() does not initialize the semaphores
            in a new set was covered in two places (in DESCRIPTION
            and BUGS). Consolidate these into one place (in NOTES)
            and also point out that POSIX.1-2008 says that a future
            version of the standard may require an implementation to
            initialize the semaphores to 0.
    Michael Kerrisk
        Clarify SEMMNS versus SEMMSL*SEMMNI
    Michael Kerrisk
        Rework EINVAL text a little
    Michael Kerrisk
        Clarify wording for EEXIST error

shmget.2
    Manfred Spraul
        Clarify SHMALL
            The default for SHMALL is a limit of 8 GB, regardless of
            PAGE_SIZE. The current documentation does not mention that
            and is therefore more difficult to understand than necessary.
    Manfred Spraul
        Correct math error
            2097152 is 2^21, not 2^20.
    Michael Kerrisk
        Reword EEXIST error
    Michael Kerrisk
        Clarify one of the EINVAL cases
    Michael Kerrisk
        Note that SHM_NORESERVE is a Linux extension
    Michael Kerrisk  [Simon Paillard]
        Fix kernel version numbers in discussion of SHMALL
    Michael Kerrisk
        Rework EINVAL text
    Michael Kerrisk
        Move and rework discussion of mode bits
    Michael Kerrisk
        Reword description of O_EXCL

shmop.2
    Michael Kerrisk
        Move fork(2), execve(2), _exit(2) discussion to NOTES
    Michael Kerrisk
        Add subheads for shmat() and shmdt()
    Michael Kerrisk
        Rework discussion of SHM_RDONLY and SHM_REMAP into list format
    Michael Kerrisk
        Structure the attach cases as a list

sigaction.2
    Alan Curry
        Fix bad cross reference (times(2) not time(2))
            The system call that reports child CPU usage is times(2),
            not time(2).

symlink.2
    Michael Kerrisk  [Steven Stewart-Gallus]
        Document ENOENT error for symlinkat()
            See https://bugzilla.kernel.org/show_bug.cgi?id=73301

syscalls.2
    Michael Kerrisk
        Add renameat2()
            And bump kernel version.

write.2
    Michael Kerrisk
        BUGS: detail nonatomicity bug with respect to file offset updates
            This bug was fixed in Linux 3.14, with commit
            9c225f2655e36a470c4f58dbbc99244c5fc7f2d4
            See also http://thread.gmane.org/gmane.linux.kernel/1649458

pthread_attr_setinheritsched.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setinheritsched() and
            pthread_attr_getinheritsched() are thread safe.

pthread_attr_setschedparam.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setschedparam() and
            pthread_attr_getschedparam() are thread safe.

pthread_attr_setschedpolicy.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setschedpolicy() and
            pthread_attr_getschedpolicy() are thread safe.

pthread_attr_setscope.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setscope() and pthread_attr_getscope()
            are thread safe.

pthread_attr_setstack.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setstack() and pthread_attr_getstack()
            are thread safe.

sched_getcpu.3
    Michael Kerrisk
        SEE ALSO: add sched(7)

termios.3
    Michael Kerrisk  [Yuri Kozlov]
        Rework intro text for 'c_oflag'
    Michael Kerrisk
        OFDEL is in POSIX.1-2001, so remove "(Not in POSIX)" text

proc.5
    Jan Moskyto Matejka  [Randy Dunlap]
        Improve description of /proc/stat 'intr' field
            The sum at the beginning of line "intr" includes also
            unnumbered interrupts.

packet.7
    Carsten Andrich  [Neil Horman]
        Improve sockopt documentation for packet sockets
    Carsten Andrich  [Willem de Bruijn]
        PACKET_LOSS has inverse meaning
    Stefan Puiu  [Daniel Borkmann, Carsten Andrich]
        Status in PACKET_RX_RING is actually a bit mask
    Michael Kerrisk  [Carsten Andrich]
        SEE ALSO: add /tools/testing/selftests/net/psock_tpacket.c


==================== Changes in man-pages-3.67 ====================

Released: 2014-05-21, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andy Lutomirski <luto@amacapital.net>
Aurelien Jarno <aurelien@aurel32.net>
Bill Allombert <ballombe@debian.org>
Christoph Hellwig <hch@infradead.org>
Davidlohr Bueso <davidlohr@hp.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Ingo Schwarze <schwarze@usta.de>
Jan Kara <jack@suse.cz>
Jon Grant <jg@jguk.org>
Juri Lelli <juri.lelli@gmail.com>
Lucas De Marchi <lucas.demarchi@profusion.mobi>
Michael Kerrisk <mtk.manpages@gmail.com>
Peng Haitao <penght@cn.fujitsu.com>
Peter Zijlstra <peterz@infradead.org>
Rasmus Villemoes <rv@rasmusvillemoes.dk>
Sam Varshavchik <mrsam@courier-mta.com>
Simon Paillard <spaillard@debian.org>
Steven Stewart-Gallus <sstewartgallus00@mylangara.bc.ca>
Török Edwin <edwin@etorok.net>
William Morriss <wjmelements@gmail.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

sched_setattr.2
    Michael Kerrisk, Peter Zijlstra [Juri Lelli]
        New page describing sched_setattr(2) and sched_getattr(2)

system.3
    Michael Kerrisk
        Rewrote large parts of the page and added a number of details


Newly documented interfaces in existing pages
---------------------------------------------

sched.7
    Peter Zijlstra, Michael Kerrisk  [Juri Lelli]
        Document SCHED_DEADLINE

New and changed links
---------------------

renameat2.2
    Michael Kerrisk
        New link to rename.2

sched_getattr.2
    Michael Kerrisk
        New link to new sched_setattr


Changes to individual pages
---------------------------

bind.2
    Michael Kerrisk
        ERRORS: Add EADDRINUSE for ephemeral port range exhaustion

chown.2
    Michael Kerrisk
        NOTES: Add some subheadings

connect.2
    Michael Kerrisk  [William Morriss]
        ERRORS: Add EADDRNOTAVAIL for ephemeral port range exhaustion
            Verified from testing and the kernel source.
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=745775
    Michael Kerrisk
        Remove mention of ip_local_port_range under EAGAIN error

create_module.2
delete_module.2
init_module.2
query_module.2
    Michael Kerrisk  [Lucas De Marchi]
        Clarify glibc header file declaration/ABI wrapper details
            create_module(), delete_module(), init_module(), and
            query_module() are not declared in header files, but
            through an accident of history glibc provides an ABI
            for them that it continues to maintain, for
            compatibility reasons.

execve.2
    Michael Kerrisk  [Steven Stewart-Gallus]
        Note SIGKILL case when execve() fails beyond the point of no return
    Michael Kerrisk
        NOTES: Add a subheading and reorder paragraphs

fanotify_init.2
    Heinrich Schuchardt [Michael Kerrisk]
        Document range of permitted flags for event_f_flags
            With a new patch included in the mm tree, event_f_flags is
            checked for allowable values.

fcntl.2
    Michael Kerrisk
        Add "file locking" subheading under NOTES

fork.2
    Michael Kerrisk
        ERRORS: SCHED_DEADLINE tasks can fail with EAGAIN
            SCHED_DEADLINE tasks can fail with EAGAIN unless the
            reset-on-fork flag is set.

futex.2
    Michael Kerrisk
        Note that there is no glibc wrapper

getpriority.2
    Rasmus Villemoes
        Fix prototypes for getpriority() and setpriority()
            The who argument has type id_t (which happens to be u32 on linux).

get_robust_list.2
    Rasmus Villemoes
        Add <sys/types.h> to synopsis of get_robust_list()
            If one were to implement wrappers for [gs]et_robust_list() using the
            given prototypes, one would also have to include sys/types.h to get
            a definition of size_t.

getrusage.2
    Michael Kerrisk  [Bill Allombert]
        _GNU_SOURCE must be defined to obtain RUSAGE_THREAD definition
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=746569

link.2
open.2
    Andy Lutomirski [Michael Kerrisk]
        Update AT_EMPTY_PATH and O_PATH documentation

listen.2
    Michael Kerrisk
        ERRORS: Add EADDRINUSE for ephemeral port range exhaustion

mbind.2
    Rasmus Villemoes
        Fix prototype for mbind(2)
            The nmask argument is const. The return type in numaif.h is long.
            (Well, at least <numaif.h> says nmask is const. The current kernel
            does not define it as a const argument, but sys_mbind() only
            passes it to get_nodes(), which does treat it as const.)

msgop.2
    Davidlohr Bueso [Michael Kerrisk]
        Enhance description of "full queue" criteria

poll.2
    Rasmus Villemoes
        Add <signal.h> to synopsis for ppoll()
            One needs to #include <signal.h> to get the definition of the
            type (sigset_t) of the mask argument to ppoll().

readlink.2
    Rasmus Villemoes
        Fix return type of readlinkat()

recv.2
    Michael Kerrisk
        Clarify details of msg_name and msg_namelen fields

recvmmsg.2
    Michael Kerrisk
        Describe timeout bug
            See https://bugzilla.kernel.org/show_bug.cgi?id=75371
            and http://thread.gmane.org/gmane.linux.man/5677

remap_file_pages.2
    Andy Lutomirski [Christoph Hellwig, Andy Lutomirski]
        remap_file_pages() has no benefit for real files
            Linux commit 3ee6dafc677a68e461a7ddafc94a580ebab80735 caused
            remap_file_pages to be emulated when used on real file.

sched_get_priority_max.2
    Michael Kerrisk
        'policy' can also be SCHED_DEADLINE

sched_setaffinity.2
    Rasmus Villemoes
        Fix prototype for sched_setaffinity()
            The mask argument is const.

sched_setparam.2
    Michael Kerrisk
        ERRORS: mark errors that apply just for sched_setparam()
    Michael Kerrisk
        ERRORS: Add EINVAL for invalid arguments
    Michael Kerrisk
        SEE ALSO: add sched_setattr(2)

sched_setscheduler.2
    Michael Kerrisk
        ERRORS: mark errors that apply just to sched_setscheduler()
    Michael Kerrisk
        ERRORS: add EINVAL case for pid < 0
    Michael Kerrisk
        ERRORS: separate out EINVAL cases

semget.2
    Michael Kerrisk
        NOTES: Add subheadings and reorder paragraphs

semop.2
    Rasmus Villemoes
        Fix prototypes for semop() and semtimedop()
            The nsops arguments have type size_t, not unsigned, and the
            timeout argument of semtimedop() is const.
    Michael Kerrisk
        NOTES: Add a subheading

send.2
    Michael Kerrisk
        Add details on various 'msghdr' fields
    Michael Kerrisk
        ERRORS: Add EAGAIN for ephemeral port range exhaustion
    Michael Kerrisk
        Add some subheadings under DESCRIPTION

shmget.2
    Michael Kerrisk
        NOTES: Add a subheading

stat.2
    Michael Kerrisk  [Aurelien Jarno]
        Describe feature test macro requirements for file type test macros
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=728240
    Michael Kerrisk
        Update FTM requirements for lstat()
    Michael Kerrisk
        Split discussion of 'st_mode' fields into type and permissions
    Michael Kerrisk
        Move text on S_I*() macros to follow text on S_I* macros
            That ordering is more logical

stime.2
    Rasmus Villemoes
        Fix prototype for stime()
            The argument is const, both according to the actual header files and
            according to <http://www.sco.com/developers/devspecs/vol1a.pdf>.

syscall.2
    Rasmus Villemoes
        Fix prototype for syscall()
            The first argument and the return value of syscall() has type long,
            not int.

getopt.3
    Michael Kerrisk
        EXAMPLE: Add subheadings to distinguish the two example programs

malloc.3
    Michael Kerrisk
        Reword text referring to mallopt(3)
            Linux libc is no longer "recent"; drop mention of it.

pthread_attr_setinheritsched.3
pthread_attr_setschedparam.3
pthread_attr_setschedpolicy.3
pthread_setaffinity_np.3
pthread_setschedparam.3
pthread_setschedprio.3
pthread_yield.3
pthreads.7
    Michael Kerrisk
        Change references to "sched_setscheduler(2)" to "sched(7)"
            Change consistent with the fact that the scheduling overview
            page is now sched(7) not sched_setscheduler(2).

pthread_attr_setstackaddr.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setstackaddr() and
            pthread_attr_getstackaddr() are thread safe.

pthread_attr_setstacksize.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_attr_setstacksize() and
            pthread_attr_getstacksize() are thread safe.

pthread_kill.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_kill() is thread safe.

pthread_kill_other_threads_np.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_kill_other_threads_np() is thread safe.

pthread_self.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_self() is thread safe.

pthread_setcancelstate.3
    Michael Kerrisk
        Add paragraph breaks to "Asynchronous cancelability" subsection

pthread_setcancelstate.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_setcancelstate() and
            pthread_setcanceltype() are thread safe.
    Michael Kerrisk
        NOTES: Add some subheadings

pthread_setschedparam.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_setschedparam() and pthread_getschedparam()
            are thread safe.

pthread_setschedprio.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_setschedprio() is thread safe.

pthread_sigmask.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_sigmask() is thread safe.

pthread_sigqueue.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_sigqueue() is thread safe.

pthread_testcancel.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_testcancel() is thread safe.

pthread_yield.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_yield() is thread safe.

remquo.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions remquo(), remquof() and remquol() are thread safe.

rtime.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function rtime() is thread safe.

sched_getcpu.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function sched_getcpu() is thread safe.

stpcpy.3
    Ingo Schwarze
        Note some history of stpcpy()
            Quoting Ingo:
            I just noticed that the stpcpy(3) manual contains a speculation
            that appears to be untrue on closer investigation:  That function
            did not originate in MS DOS, but in Lattice C on AmigaDOS.

            Here is a patch against the git master HEAD to fix that, and add
            some more historical information.  To provide some background and
            allow you to more easily verify the correctness of the patch, i'm
            appending my mail to <misc@openbsd.org>, where i'm giving some
            more details about the history and pointing to some primary
            sources.  That mail also contains the (similar, but shorter)
            patch i just committed to the OpenBSD manual page.

strcasecmp.3
    Michael Kerrisk  [Aurelien Jarno, Török Edwin]
        Explain why strcasecmp()+strncasecmp() are also declared in <string.h>
            See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=729436

strcpy.3
    Michael Kerrisk
        NOTES: Add a subheading

fd.4
    Michael Kerrisk  [Sam Varshavchik]
        Fix floppy disk device names
            The naming convention shown in the page was ancient.
            Now, the page is consistent with Documentation/devices.txt
            (where it is noted that "The use of the capital letters
            D, H and E for the 3.5" models have been deprecated, since
            the drive type is insignificant for these devices"

proc.5
    Michael Kerrisk
        Document /proc/timer_stats
    Michael Kerrisk
        (Briefly) document /proc/timer_list
    Michael Kerrisk
        Add /proc/sys/kernel/{sched_rt_period_us,sched_rt_runtime_us}
            Reference sched(7) for an explanation of these two files

capabilities.7
    Michael Kerrisk
        Mention sched_setattr(2) under CAP_SYS_NICE

cpuset.7
    Michael Kerrisk
        SEE ALSO: add sched(7)

credentials.7
    Michael Kerrisk
        Mention sched_getattr() as a place where credentials are checked

fanotify.7
    Heinrich Schuchardt  [Jan Kara]
        BUGS: error events can be lost when reading from fanotify FD
    Michael Kerrisk  [Heinrich Schuchardt]
        Fix description of FAN_EVENT_NEXT()
            FAN_EVENT_NEXT() does not update 'meta'; rather, it returns a
            pointer to the next metadata structure. In addition, generally
            rework the description to be a bit clearer and more detailed.
    Heinrich Schuchardt
        Document FAN_EVENT_METADATA_LEN

ip.7
    Michael Kerrisk
        Note cases where an ephemeral port is used
    Michael Kerrisk
        Remove BUGS text on glibc failing to declare in_pktinfo
    Michael Kerrisk
        Clarify 'ip_local_port_range' and mention the term "ephemeral ports"
    Michael Kerrisk
        Note some more details about assignment of ephemeral ports
    Michael Kerrisk
        BUGS: ephemeral port range exhaustion is diagnosed inconsistently
            Different system calls use different 'errno' values to diagnose
            exhaustion of the ephemeral port range.

sched.7
    Michael Kerrisk
        Document sched_rt_period_us and sched_rt_runtime_us /proc files
            And rework and relocate the text on dealing with runaway
            real-time processes.
    Michael Kerrisk
        Mention sched_setattr(2) in list of APIs that can change policies
    Michael Kerrisk
        sched_setattr(2) can also be used to set 'nice' value
    Michael Kerrisk
        Remove mention of sched_setscheduler() when talking about sched_priority
            There are nowadays multiple ways to set sched_priority (and
            in fact there always were, since we also had sched_setparam(2)).
    Michael Kerrisk
        SEE ALSO: Add Documentation/scheduler/sched-design-CFS.txt
    Michael Kerrisk
        Don't mention sched_setscheduler(2) in discussions of setting policies
            In a couple of places, sched_setscheduler(2) is mentioned as the
            way of setting policies. But now there is sched_setattr(2) as
            well, rewrite the text in a more generic way.
    Michael Kerrisk
        Rework summary text describing sched_setattr(2) and sched_getattr(2)
            Note that these APIs are a superset of sched_setscheduler(2)
            and sched_getscheduler(2).
    Michael Kerrisk
        Remove crufty text relating to sched_setscheduler()
            All of the removed text is in sched_setscheduler(2) and
            should have been trimmed from this page.
    Michael Kerrisk
        SEE ALSO: Mention more files in Documentation/scheduler/ directory


==================== Changes in man-pages-3.68 ====================

Released: 2014-05-28, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alastair McKinstry <mckinstry@computer.org>
Carsten Grohmann <carstengrohmann@gmx.de>
Colin Williams <colinwilliams1968@gmail.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Lars Wirzenius <liw@iki.fi>
Marko Myllynen <myllynen@redhat.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Peng Haitao <penght@cn.fujitsu.com>
Rasmus Villemoes <rv@rasmusvillemoes.dk>
Richard Braakman <richard.braakman@jollamobile.com>
Simon Paillard <spaillard@debian.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

localedef.1
    Marko Myllynen, Richard Braakman, Alastair McKinstry, Lars Wirzenius
        New page for localedef(1)
            Add new page based on Debian localedef(1) page.


New and changed links
---------------------

procfs.5
    New link to proc.5
        Since the term "procfs" is widely used, it seems reasonable to have
        a link from that name to proc(5).


Changes to individual pages
---------------------------

locale.1
    Marko Myllynen
        Provide a step-by-step example of how to use a custom locale
    Marko Myllynen
        Use LC_TELEPHONE instead of LC_MESSAGES in the example
            yesstr/nostr in LC_MESSAGES are planned to be changed at some
            point [1], so it's better to provide an example which won't
            be obsoleted by that change.

            [1] https://sourceware.org/bugzilla/show_bug.cgi?id=16975

adjtimex.2
    Michael Kerrisk
        Add feature test macro requirements

clone.2
    Michael Kerrisk
        ERRORS: add cross-reference to fork(2) for explanation of EAGAIN

fork.2
    Michael Kerrisk
        ERRORS: add pid_max and threads-max to EAGAIN
            And rewrite text to be the same as pthread_create(3).

getrlimit.2
    Michael Kerrisk
        RLIMIT_NPROC is not enforced if CAP_SYS_ADMIN or CAP_SYS_RESOURCE

remap_file_pages.2
    Rasmus Villemoes
        Fix prototype
            The pgoff argument has type size_t, not ssize_t (and in the
            kernel it is unsigned long).

set_mempolicy.2
    Rasmus Villemoes
        Fix prototype for set_mempolicy(2)
            The nodemask argument is const. The return type in numaif.h is long.

swapon.2
    Rasmus Villemoes
        Remove header from synopsis
            The <asm/page.h> header is not readily available, and the comment
            seems to indicate that it is for getting PAGE_SIZE. But it is
            never mentioned why one would need to know that, and it is in any
            case better obtained using sysconf(), provided by <unistd.h>.

a64l.3
    Rasmus Villemoes
        Fix prototype for a64l()
            The argument is const, both according to POSIX and the
            glibc headers.

adjtime.3
    Rasmus Villemoes
        Add required header
            The prototype for adjtime(3) is declared in <sys/time.h>.

argz_add.3
    Rasmus Villemoes
        Fix prototypes
            Update the prototypes of argz_{delete,extract,next} to agree with
            glibc headers and manual.

bstring.3
    Rasmus Villemoes
        Fix prototypes
            The length parameter n has type size_t in bcmp(), bcopy() and
            bzero().

envz_add.3
    Rasmus Villemoes
        Fix prototypes
            The envz_len parameters for envz_entry() and envz_get() are not
            passed by reference.

fpathconf.3
    Rasmus Villemoes
        Fix prototype
            The path argument to pathconf() is const.

fseek.3
    Rasmus Villemoes
        Fix prototype
            The pos argument to fsetpos() is const.

gcvt.3
    Rasmus Villemoes
        Fix prototype
            The ndigit parameter to gcvt() has type int.

getaddrinfo_a.3
    Rasmus Villemoes
        Fix prototype
            The pointer arguments to gai_suspend() are const.

getauxval.3
    Rasmus Villemoes
        Fix permissions
            There doesn't seem to be any reason for getauxval.3 to be
            executable...

getnameinfo.3
    Rasmus Villemoes
        Fix prototype
            The hostlen and servlen parameters have type socklen_t.
            (The types changed in glibc 2.2)
    Michael Kerrisk
        Note types of 'hostlen'; and 'servlen' in glibc < 2.2

getrpcent.3
    Rasmus Villemoes
        Fix prototype
            The argument to getrpcbyname() is const.

getrpcport.3
    Rasmus Villemoes
        Add #include and fix prototype
            The prototype for getrpcport() is obtained by #include'ing
            <rpc/rpc.h>. Also, update its prototype.

getspnam.3
    Rasmus Villemoes
        Fix prototype
            The struct spwd argument to putspent() is const.

getutent.3
    Rasmus Villemoes
        Fix prototypes
            The arguments to getutid(), getutline(), and pututline()
            are const.

inet.3
    Rasmus Villemoes
        Fix prototype
            The parameters to inet_makeaddr have type in_addr_t.

inet_net_pton.3
    Rasmus Villemoes
        srcfix, cfix
            Use a consistent style throughout the man-pages.

key_setsecret.3
    Rasmus Villemoes
        Fix prototypes
            Remove const qualifiers from arguments to key_decryptsession,
            key_encryptsession, and key_setsecret.

makecontext.3
    Rasmus Villemoes
        Fix prototype
            The second argument to swapcontext() is const.

makedev.3
    Rasmus Villemoes
        Fix prototype
            gnu_dev_makedev, and hence its trivial macro wrapper makedev, takes
            two unsigned int parameters; this is consistent with it being the
            inverse of (gnu_dev_)major/minor, which return unsigned int.

malloc_trim.3
    Rasmus Villemoes
        Fix prototype
            As mentioned further down, malloc_trim returns an integer.

mq_getattr.3
    Rasmus Villemoes
        Fix prototype
            The newattr parameter to mq_setattr is const.

newlocale.3
    Marko Myllynen
        List all available category masks
    Michael Kerrisk
        Add LC_ALL_MASK description

nl_langinfo.3
    Marko Myllynen
        Expand the example code a bit
            Better illustrate querying elements from different categories.

perror.3
    Rasmus Villemoes
        Fix declaration
            The elements of the array sys_errlist are also const.

pthread_attr_setaffinity_np.3
pthread_attr_setdetachstate.3
pthread_attr_setguardsize.3
pthread_attr_setinheritsched.3
pthread_attr_setschedparam.3
pthread_attr_setschedpolicy.3
pthread_attr_setscope.3
pthread_attr_setstack.3
pthread_attr_setstackaddr.3
pthread_attr_setstacksize.3
    Rasmus Villemoes
        Constify parameters
            Each of the pthread_attr_get* functions extract some piece of
            information from a pthread_attr_t, which is passed by const
            reference. Add the const keyword to the prototypes of these
            functions.

pthread_cleanup_push_defer_np.3
    Michael Kerrisk  [Rasmus Villemoes]
        Add feature test macro requirements

pthread_create.3
    Michael Kerrisk  [Carsten Grohmann]
        Add pid_max limit to EAGAIN error cases

pthread_equal.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_equal() is thread safe.

pthread_exit.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_exit() is thread safe.

pthread_getcpuclockid.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function pthread_getcpuclockid() is thread safe.

pthread_setaffinity_np.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_setaffinity_np() and
            pthread_getaffinity_np() are thread safe.

pthread_setconcurrency.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions pthread_setconcurrency() and
            pthread_getconcurrency() are thread safe.

pthread_setname_np.3
    Rasmus Villemoes
        Fix prototype
            The name parameter of pthread_getname_np is an output parameter and
            hence not const.

pthread_setschedparam.3
    Rasmus Villemoes
        Fix prototypes
            Add return type for pthread_{s,g}etschedparam.

pthread_setschedprio.3
    Rasmus Villemoes
        Fix prototype
            Add return type for pthread_setschedprio.

pthread_sigqueue.3
    Rasmus Villemoes
        Add missing #include <signal.h>

rcmd.3
    Rasmus Villemoes
        Fix prototypes
            Unlike the BSDs, the second argument of rcmd() and rcmd_af() has
            type unsigned short.
            The first argument of iruserok_af() has type const void*.

re_comp.3
    Rasmus Villemoes
        Fix prototypes
            re_comp and re_exec take const char* arguments.

resolver.3
    Rasmus Villemoes
        Fix prototypes and extern-declaration
            Fix const- and signedness of various char* parameters.

            Also, there is no "struct state", but _res is a struct
            __res_state. (Actually, _res is errno-like in that it is really a
            macro expanding to (*__res_state()).)

rexec.3
    Rasmus Villemoes
        Fix prototypes
            The user, passwd and cmd arguments to rexec and rexec_af are all
            const.

rtime.3
    Rasmus Villemoes
        Replace header
            The header <rpc/des_crypt.h> does not provide rtime();
            <rpc/auth_des.h> does, as is also implied in both the NOTES and
            EXAMPLE sections.

scandir.3
    Rasmus Villemoes
        Fix prototypes
            The alphasort and versionsort functions take arguments of type
            const struct dirent **, not const void *.

setlocale.3
    Michael Kerrisk  [Marko Myllynen]
        Simplify locale category listing and add GNU-specific locale categories
            Some information that was here will move to locale(7).
    Marko Myllynen
        Remove now obsolete NOTES section

setnetgrent.3
    Rasmus Villemoes
        Fix prototype
            The buflen argument to getnetgrent_r has type size_t.

sigvec.3
    Rasmus Villemoes
        Fix prototype
            The vec argument to sigvec is const.

tsearch.3
    Rasmus Villemoes
        Fix prototype
            The rootp argument to tfind is "void * const *",
            not "const void **".

core.5
    Michael Kerrisk
        Core dump files are nowadays core.pid by default

locale.5
    Marko Myllynen
        Document mon_grouping and grouping properly
    Michael Kerrisk
        Note default value for 'first_workday'
    Michael Kerrisk  [Marko Myllynen]
        Add brief descriptions of collating-element and collating-symbol
    Marko Myllynen
        t_fmt_ampm is needed only for locales that employ AM/PM convention
    Michael Kerrisk  [Marko Myllynen]
        Remove crufty reference to /usr/lib/nls/src
            That file is nowhere to be found
    Marko Myllynen
        Clarify LC_TIME/am_pm and LC_NAME keywords usage
            am_pm should be defined only if AM/PM convention is used to signal
            applications they should not try to print them when using them in
            unwanted.

            Same for all LC_NAME keywords expect for name_fmt which should be
            always defined.
    Marko Myllynen
        Clarify lang_term / lang_lib
            As noted by Keld Simonsen in the lib-locales@sourceware mailing
            list:

                https://sourceware.org/ml/libc-locales/2014-q2/msg00008.html
                From: Keld Simonsen <keld at rap dot rap dot dk>
                To: Marko Myllynen <myllynen at redhat dot com>
                Date: Tue, 29 Apr 2014 17:02:09 +0200

                lang_term reflects ISO 639-2/T (terminology) codes, while
                lang_lib reflects ISO 639-2/B (bibliographic) codes.
                lang_term is preferred over lang_lib codes for locale names.
                There are 20 specific ISO 639-2/B codes.
    Marko Myllynen
        Correct the FILES section

proc.5
    Michael Kerrisk
        'pid_max' is a system-wide limit on number of threads and processes
            Since PIDs > /proc/sys/kernel/pid_max are not allocated, this
            file thus also imposes a system-wide limit on the number of
            threads and processes.

capabilities.7
    Michael Kerrisk
        CAP_SYS_ADMIN allows overriding RLIMIT_NPROC
    Michael Kerrisk
        CAP_SYS_PTRACE allows process_vm_readv(2) and process_vm_writev(2)

charsets.7
    Michael Kerrisk  [Marko Myllynen]
        Remove crufty statement that Romanian may be switching to ISO 8859-16
    Michael Kerrisk
        Remove ancient paragraph on charsets supported in glibc 2.3.2
            That test is rather ancient, and probably of little use.

fanotify.7
    Heinrich Schuchardt
        Fix to example program: fanotify read() should use aligned buffer

inotify.7
    Heinrich Schuchardt
        Add example program
            This example of the usage of the inotify API shows the
            usage of inotify_init1(2) and inotify_add_watch(2) as well
            as polling and reading from the inotify file descriptor.
    Heinrich Schuchardt
        munmap() does not generate inotify events

locale.7
    Marko Myllynen [Michael Kerrisk]
        Document the LOCPATH environment variable
    Michael Kerrisk
        Add further details on various categories



==================== Changes in man-pages-3.69 ====================

Released: 2014-06-14, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Cyril Hrubis <chrubis@suse.cz>
Jan Chaloupka <jchaloup@redhat.com>
Jeff Layton <jlayton@poochiereds.net>
Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Marko Myllynen <myllynen@redhat.com>
Michael Kerrisk <mtk.manpages@gmail.com>
NeilBrown <neilb@suse.de>
Peng Haitao <penght@cn.fujitsu.com>
Petr Gajdos <pgajdos@suse.cz>
Qian Lei <qianl.fnst@cn.fujitsu.com>
Rasmus Villemoes <rv@rasmusvillemoes.dk>
Vasiliy Kulikov <segoon@openwall.com>
Walter Harms <wharms@bfs.de>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

iconv.1
    Marko Myllynen  [Michael Kerrisk]
        New page for the iconv(1) command

iconvconfig.8
    Marko Myllynen
        New page for iconvconfig(8)


Newly documented interfaces in existing pages
---------------------------------------------

fcntl.2
    Jeff Layton, Michael Kerrisk
        Document open file description locks
            As provided by the fcntl() operations F_OFD_SETLK,
            F_OFD_SETLKW, and F_OFD_GETLK


Changes to individual pages
---------------------------

locale.1
    Marko Myllynen
        Add FILES section, add charmap(5) reference
    Marko Myllynen
        Align with recent charmap(5) / repertoiremap(5) changes

execve.2
    Michael Kerrisk  [NeilBrown]
        Before kernel 2.6.0, RLIMIT_NPROC had no effect for set*uid()
    Michael Kerrisk  [Vasiliy Kulikov]
        RLIMIT_NPROC is checked only if preceded by set*uid()
    Michael Kerrisk  [Vasiliy Kulikov, NeilBrown, KOSAKI Motohiro]
        Document EAGAIN error
            See also https://bugzilla.kernel.org/show_bug.cgi?id=42704

fcntl.2
    Michael Kerrisk
        Detail the limitations of traditional (process-associated) locks
    Michael Kerrisk  [Jeff Layton]
        Describe how to check whether the kernel supports a particular command
    Michael Kerrisk
        ERRORS: add EINVAL for invalid 'cmd'
    Michael Kerrisk
        Add para introducing advisory locks and noting existence of OFD locks
    Michael Kerrisk  [Jeff Layton]
        Add notes on F_SETLKW deadlock detection and its limitations
    Michael Kerrisk
        Add an explicit note that mandatory locking is not in POSIX
    Michael Kerrisk
        Rewrite introductory paragraphs on mandatory locking
            Make the structure more logical, and also explicitly mention
            OFD locks.
    Michael Kerrisk  [Jeff Layton]
        Reword discussion of mandatory lock bug a little
            Jeff Layton confirmed that the bug remains even in modern kernels.
    Michael Kerrisk
        Explain POSIX background to EACCES/EAGAIN error for F_GETLK
    Michael Kerrisk
        Add NOTES subhead for record locking and NFS
    Michael Kerrisk  [NeilBrown]
        Note treatment of locks when an NFS client loses contact with the server
    Michael Kerrisk  [Jeff Layton]
        nfsv4leasetime controls the "contact lost" interval for NFSv4

flock.2
    Michael Kerrisk
        In some modern BSDs, fcntl() and flock() locks do interact
            So, reword and extend the discussion of this topic in NOTES.
    Michael Kerrisk
        Move NOTES text describing implementation of flock()
    Michael Kerrisk  [NeilBrown]
        Add more details on NFS, including Linux 2.6.37 changes
            Also: move NOTES text describing interaction of fcntl()
            and flock() locks.

fork.2
    Michael Kerrisk
        Add notes on inheritance of flock() and OFD locks across fork()

lseek.2
    Michael Kerrisk
        Add reference to open(2) for discussion of file descriptors and OFDs

open.2
    Michael Kerrisk
        Rework and extend the discussion of open file descriptions

open_by_handle_at.2
    Rasmus Villemoes
        Add reference to feature_test_macros(7)

recvmmsg.2
    Rasmus Villemoes
        Add reference to feature_test_macros(7)

remap_file_pages.2
    Michael Kerrisk  [Kirill A. Shutemov]
        Note that remap_file_pages() is deprecated

sendmmsg.2
    Rasmus Villemoes
        Add reference to feature_test_macros(7)

seteuid.2
    Michael Kerrisk
        seteuid() and setegid() are implemented as library functions
    Michael Kerrisk
        Error checking should always be performed, even when caller is UID 0

setresuid.2
    Michael Kerrisk
        Document EAGAIN error that can occur after kernel alloc_uid() failure
    Michael Kerrisk
        Since Linux 3.1, the EAGAIN case for RLIMIT_NPROC no longer occurs
    Michael Kerrisk
        Correct the description of the EAGAIN error
    Michael Kerrisk
        Error checking should always be performed, even when caller is UID 0

setreuid.2
    Michael Kerrisk
        Document EAGAIN error that can occur after kernel alloc_uid() failure
    Michael Kerrisk
        Error checking should always be performed, even when caller is UID 0
    Michael Kerrisk
        Add EAGAIN error for hitting RLIMIT_NPROC limit
    Michael Kerrisk
        Since Linux 3.1, the EAGAIN case for RLIMIT_NPROC no longer occurs

setuid.2
    Michael Kerrisk
        Document EAGAIN error that can occur after kernel alloc_uid() failure
    Michael Kerrisk
        Correct the description of the EAGAIN error
    Michael Kerrisk
        Error checking should always be performed, even when caller is UID 0
    Michael Kerrisk
        Since Linux 3.1, the EAGAIN case for RLIMIT_NPROC no longer occurs

statfs.2
    Cyril Hrubis
        Update MAGIC constants
            Most of the updates are taken from /usr/include/linux/magic.h,
            some were found by grepping the Linux source code.
    Cyril Hrubis  [Michael Kerrisk]
        fstatfs(2) was broken on file descriptors from pipe(2)

syscalls.2
    Michael Kerrisk
        Note that remap_file_pages() is deprecated

basename.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions basename() and dirname() are thread safe.

catgets.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function catgets() is thread safe.

getdate.3
    Rasmus Villemoes
        Use blank definition of _GNU_SOURCE in example program

getdirentries.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function getdirentries() is thread safe.

getdtablesize.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function getdtablesize() is thread safe.

iconv.3
    Qian Lei  [Peng Haitao]
        ATTRIBUTES: Note function that is thread-safe
            The function iconv() is thread safe.
    Michael Kerrisk
        SEE ALSO: add iconvconfig(8)

lockf.3
    Qian Lei  [Peng Haitao]
        ATTRIBUTES: Note function that is thread-safe
            The function lockf() is thread safe.

malloc_get_state.3
    Rasmus Villemoes
        SYNOPSIS: use correct header
            The nonstandard functions malloc_set_state() and
            malloc_get_state() are provided by <malloc.h> not <stdlib.h>.

malloc_usable_size.3
    Qian Lei
        ATTRIBUTES: Note function that is thread-safe
            The function malloc_usable_size() is thread safe.

matherr.3
    Qian Lei  [Peng Haitao]
        ATTRIBUTES: Note function that is thread-safe
            The function matherr() is thread safe.

mkdtemp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function mkdtemp() is thread safe.

mkstemp.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions mkstemp(), mkostemp(), mkstemps() and mkostemps()
            are thread safe.

mq_close.3
    Qian Lei
        ATTRIBUTES: Note function that is thread-safe
            The function mq_close() is thread safe.

mq_getattr.3
    Qian Lei
        ATTRIBUTES: Note function that is thread-safe
            The functions mq_getattr() and mq_setattr() are thread safe.

mq_open.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function mq_open() is thread safe.

mq_receive.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions mq_receive() and mq_timedreceive() are thread safe.

mq_send.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions mq_send() and mq_timedsend() are thread safe.

mq_unlink.3
    Qian Lei
        ATTRIBUTES: Note function that is thread-safe
            The function mq_unlink() is thread safe.

posix_fallocate.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function posix_fallocate() is thread safe.

posix_openpt.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function posix_openpt() is thread safe.

siginterrupt.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function siginterrupt() is not thread safe.

system.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function system() is thread safe.

charmap.5
    Marko Myllynen
        Update to match current glibc
            charmap(5) was outdated, bring it to closer to reality by fixing
            syntax descriptions to match current glibc code and practices,
            adding missing options, removing obsolete comments and references,
            and removing now incorrect examples.

locale.5
    Marko Myllynen
        Clarify AM/PM settings a bit
            localedef(1) complains if really undefined, should be empty instead.
            Also: add some SEE ALSO references.
    Marko Myllynen
        Document glibc conventions regarding days and week
            Based on existing practice and glibc community wiki page at
            https://sourceware.org/glibc/wiki/Locales

proc.5
    Michael Kerrisk  [Jan Chaloupka, Walter Harms]
        Add a brief description of /proc/fs

repertoiremap.5
    Marko Myllynen
        New page for repertoiremap(5)
            Rather obsolete feature but localedef(1) refers to repertoiremaps.

bootparam.7
    Petr Gajdos
        Describe 'rootflags' and 'rootdelay' kernel parameters
            Patch based on text from Documentation/kernel-parameters.txt

charsets.7
    Marko Myllynen
        Update to reflect past developments
            Rewrite the introduction to make Unicode's prominence more obvious.
            Reformulate parts of the text to reflect current Unicode world.
            Minor clarification for ASCII/ISO sections, some other minor fixes.
    Marko Myllynen
        List CJK encodings in the order of C, J, K

environ.7
    Michael Kerrisk
        SEE ALSO: add env(1), printenv(1), ld.so(8)

locale.7
    Marko Myllynen
        Add some SEE ALSO references

man-pages.7
    Michael Kerrisk
        Note that .TH 'date' field is nowadays automatically updated by scripts

signal.7
    Michael Kerrisk
        Describe EINTR semantics for recvmmsg(2)
    Michael Kerrisk
        Clarify text describing EINTR semantics for socket interfaces

unicode.7
    Marko Myllynen
        Update to reflect past developments
            The unicode(7) page will look more modern with few small changes:

            - drop old BUGS section, editors cope with UTF-8 ok these days,
              and perhaps the state-of-the-art is better described elsewhere
              anyway than in a man page
            - drop old suggestion about avoiding combined characters
            - refer to LANANA for Linux zone, add registry file reference
            - drop a reference to an inactive/dead mailing list
            - update some reference URLs

utf-8.7
    Marko Myllynen
        Drop an old comment about UTF-8 replacing ISO 8859
            And add locale(1) under SEE ALSO.


==================== Changes in man-pages-3.70 ====================

Released: 2014-07-08, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Carlos O'Donell <carlos@redhat.com>
Elie De Brauwer <eliedebrauwer@gmail.com>
Florian Weimer <fweimer@redhat.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Marko Myllynen <myllynen@redhat.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Nadav Har'El <nyh@math.technion.ac.il>
NeilBrown <neilb@suse.de>
Rich Felker <dalias@libc.org>
Robert P. J. Day <rpjday@crashcourse.ca>
Simon Paillard <spaillard@debian.org>
Tomi Salminen <tlsalmin@gmail.com>
Walter Harms <wharms@bfs.de>
Yuri Kozlov <yuray@komyakino.ru>
Кирилл <kirillnow@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

sprof.1
    Michael Kerrisk [Marko Myllynen]
        New page for the glibc sprof(1) command


Newly documented interfaces in existing pages
---------------------------------------------

epoll_ctl.2
    NeilBrown
        Document EPOLLWAKEUP

epoll.7
    NeilBrown
        Document EPOLLWAKEUP


Changes to individual pages
---------------------------

iconv.1
iconvconfig.8
    Marko Myllynen
        Clarify gconv file terminology a bit

ldd.1
    Michael Kerrisk
        SEE ALSO: add sprof(1)

connect.2
    Michael Kerrisk
        ERRORS: add EPROTOTYPE
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=708394

dup.2
    Michael Kerrisk  [Rich Felker]
        Fix erroneous discussion regarding closing 'newfd' before calling dup2()
            And propose a workaround if the caller cares about catching
            close() time errors.

            See http://stackoverflow.com/questions/23440216/race-condition-when-using-dup2#comment36888604_23444465
            and http://austingroupbugs.net/view.php?id=411
    Michael Kerrisk
        Rework and enhance discussion of dup2()
            In particular, note that dup2() performs the steps of closing
            and reusing 'newfd' atomically.
    Michael Kerrisk
        Add subhead for dup3()

epoll_ctl.2
    Michael Kerrisk
        BUGS: EPOLLWAKEUP is silently ignored without CAP_BLOCK_SUSPEND
            If the caller does not have CAP_BLOCK_SUSPEND, then EPOLLWAKEUP
            is silently ignored.

fcntl.2
    Michael Kerrisk  [Tomi Salminen]
        The return value for F_SETPIPE_SZ is the pipe capacity
    Michael Kerrisk
        ERRORS: Document ENOTDIR error for F_NOTIFY
    Michael Kerrisk
        Use proper page cross-references in F_NOTIFY discussion
    Michael Kerrisk
        Suggest the use of real-time signals with F_NOTIFY

getitimer.2
    Michael Kerrisk
        Rewrite a few pieces to clarify some details

inotify_add_watch.2
    Michael Kerrisk
        Clarify that the target of a watch is an i-node
            The target of a watch is an i-node, not a pathname. Clarify
            the text to prevent the reader possibly misunderstanding
            that establishing watches by two different links to the same
            file might create different watch descriptors.

open.2
    Michael Kerrisk  [Кирилл]
        O_CLOEXEC is also one the flags not ignored when O_PATH is specified

pipe.2
    Elie De Brauwer
        PIPE_BUF is defined in limits.h
            To make use of PIPE_BUF in an application one should include
            <limits.h>.  Adding a reference to this inclusion.

poll.2
    Michael Kerrisk  [Nadav Har'El]
        The negate-fd-to-ignore technique does not work for file descriptor 0
            See https://bugzilla.kernel.org/show_bug.cgi?id=79411

set_tid_address.2
    Michael Kerrisk  [Rich Felker]
        Use "thread" rather than "process" in DESCRIPTION
    Michael Kerrisk
        SEE ALSO: add gettid(2)

shmop.2
    Michael Kerrisk
        Explain SHMLBA in much more detail

splice.2
    Michael Kerrisk
        Document EAGAIN error
            See https://bugzilla.kernel.org/show_bug.cgi?id=48641

syscalls.2
    Carlos O'Donell
        Add prlimit64(2)
            While trying to reconcile the new features in glibc with the
            documented entries in the linux kernel man pages I noticed that
            glibc exports prlimit64 for use by 32-bit applications (as does
            the linux kernel), but that prlimit64 was not defined in the
            syscalls list or in the prlimit-related page.

            This is not the complete fix for this, but I don't have the time
            to explain why and when prlimit64 should be used (or how it should
            be used safely). Therefore I'm just patching the syscalls.2 list
            to show that prlimit64 exists and was added in 2.6.36 (verified
            with git by checking out the tags before and after).

syslog.2
    Michael Kerrisk
        Rework introductory paragraph
    Michael Kerrisk  [Robert P. J. Day]
        Rework text describing loglevels
            The kernel header file mentioned in the discussion of the KERN_*
            constants has morphed and is no longer exported inside glibc.
            And the definitions of the constants themselves changed subtly
            with kernel commit 04d2c8c83d0e3ac5f78aeede51babb3236200112.
            So, rewrite the description of the constants to be a bit more
            abstract.
    Michael Kerrisk
        Rewrite parts of the page, and import /proc/sys/kernel/printk
            * Move /proc/sys/kernel/printk from proc(5) to this page,
              and correct various details in the discussion of that file.
            * Rewrite and correct various other details on the page.
            * Clean out some crufty text.
            * Miscellaneous minor fixes.
    Michael Kerrisk
        Update SYSLOG_ACTION_CONSOLE_OFF + SYSLOG_ACTION_CONSOLE_ON description
            Details changed in Linux 2.6.32

tee.2
    Michael Kerrisk
        Document EAGAIN error
            See https://bugzilla.kernel.org/show_bug.cgi?id=48641

vmsplice.2
    Michael Kerrisk
        Document EAGAIN error
            See https://bugzilla.kernel.org/show_bug.cgi?id=48641

ether_aton.3
    Michael Kerrisk
        Make description of ether_line() bug a little more informative

mallopt.3
    Michael Kerrisk  [Florian Weimer]
        MALLOC_MMAP_THRESHOLD_ and MALLOC_MMAP_MAX_ *do* work in setgid programs
            My testing on this point was bogus, overlooking details of
            strace(1)'s behavior with setuid programs.

            See https://sourceware.org/bugzilla/show_bug.cgi?id=12155

printf.3
    Michael Kerrisk  [Rich Felker]
        Remove libc4 and libc5 details
            Rich Felker noted that "scare text" in the man page warned about
            the use of snprintf() on libc, and that some people had cited
            this as a reason not to use snprintf().  Linux libc is now
            ancient history, so there is no real need to keep that text.
            But, while we're at it, we may as well clear out all of the
            other ancient libc4 and libc5 pieces in the page. They are
            nowadays more clutter than help.
    Michael Kerrisk
        SUSv3 and later agree with C99 for the snprintf() return value
            Determined by inspection of the SUSv3 and SUSv4 specifications.
    Michael Kerrisk
        Remove some old text about glibc 2.0 changes
            We probably don't now need such ancient info.
    Michael Kerrisk
        Update references to standards for C and S conversion specifiers

profil.3
    Michael Kerrisk
        SEE ALSO: add sprof(1)

charmap.5
    Marko Myllynen
        Various minor updates and improvements
            - more precise title
            - extend description a bit
            - document previously omitted WIDTH_DEFAULT
    Marko Myllynen
        Remove accidental ISO C compliance reference
            glibc refers in locale/programs/charmap.c to ISO C 99 section
            7.17.(2) and ISO C 99 section 5.2.1.(3) that if a character map
            is not ASCII compatible then the locale using it is not ISO C
            compliant. This does not state anything about the character set
            itself.

proc.5
    Michael Kerrisk
        Replace /proc/sys/kernel/printk discussion with reference to syslog(2)
            It makes more sense to have the /proc/sys/kernel/printk with
            the related material in syslog(2).
    Michael Kerrisk
        Rewrite /proc/sys/kernel/printk description

inotify.7
    Michael Kerrisk
        Clarify which events are generated for watched directories
            Really, with respect to watched directories, events fall into
            three classes (not two, as was shown):

            * Events that can be generated only for the watched directory.
            * Events that can be generated only for objects that are inside
              the watched directory.
            * Events that can be generated both for the watched directory
              and for objects inside the directory.

            So, mark these three classes more clearly in the list of inotify
            events.
    Heinrich Schuchardt  [Michael Kerrisk]
        BUGS: Note possible bug triggered by watch descriptor reuse
            Watch descriptor IDs are returned by inotify_add_watch().
            When calling inotify_rm_watch() an IN_IGNORED is placed on the
            inotify queue pointing to the ID of the removed watch.

            inotify_add_watch() should not return a watch descriptor ID for
            which events are still on the queue but should return an
            unused ID.

            Unfortunately, the existing Kernel code does not provide such a
            guarantee.

            Actually, in rare cases watch descriptor IDs are returned by
            inotify_add_watch() for which events are still on the inotify
            queue.

            See https://bugzilla.kernel.org/show_bug.cgi?id=77111
    Michael Kerrisk
        Add further detail to the watch descriptor reuse bug
            As well as inotify_rm_watch(), file deletion and unmounting a
            filesystem can also cause a watch descriptor to be deleted.
    Michael Kerrisk
        The watch descriptor reuse bug may be hard to hit in practice
            Explain the circumstances in detail, indicating that the
            bug may be very unlikely to occur in practice.
    Michael Kerrisk
        Clarify description of IN_EXCL_UNLINK
            Clarify the text a little, in particular making it clearer
            that the target of a watch is an i-node (not a pathname).
    Michael Kerrisk
        Clarify IN_ONESHOT explanation
            Make it clearer that the target of monitoring is an i-node,
            not a pathname.
    Michael Kerrisk
        Make comment on 'mask' field more accurate

libc.7
    Michael Kerrisk
        Clarify man-pages policy on documenting C libraries other than glibc
    Michael Kerrisk
        Use absolute dates in discussion of libc vs glibc

pipe.7
    Elie De Brauwer
        Add reference that the pipe capacity can be changed
            In fcntl(2) F_SETPIPE_SZ, F_GETPIPE_SZ and
            /proc/sys/fs/pipe-max-size are defined, however
            pipe(7) still defines the pipe capacity as being
            a static entity. Adding a reference to fcntl(2).
    Michael Kerrisk  [Walter Harms]
        Clarify that since 2.6.35, 65535 bytes is the default pipe capacity

ld.so.8
    Michael Kerrisk
        Clarify that LD_PROFILE can specify just a single shared object
    Michael Kerrisk
        Clarify that LD_PROFILE output is appended to target file
            The LD_PROFILE output is appended to any existing
            contents of the target file.
    Michael Kerrisk
        SEE ALSO: add sprof(1)


==================== Changes in man-pages-3.71 ====================

Released: 2014-08-17, Chicago


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Adrian Bunk <bunk@kernel.org>
Damir Nedzibovic <d.nedzibovic@anoxtech.com>
David Prévot <taffit@debian.org>
D. Barbier <bouzim@gmail.com>
Jakub Wilk <jwilk@debian.org>
Jan Chaloupka <jchaloup@redhat.com>
Marko Myllynen <myllynen@redhat.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
NeilBrown <neilb@suse.de>
Paul Jackson <pj@usa.net>
Peng Haitao <penght@cn.fujitsu.com>
Rahul Bedarkar <rahulbedarkar89@gmail.com>
Rob Landley <rob@landley.net>
Ryan Hammonds <rhammonds@unicoi.com>
Simon Paillard <spaillard@debian.org>
Ville Ylenius <ville@ylenius.net>
Vince Weaver <vincent.weaver@maine.edu>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

group_member.3
    Michael Kerrisk
        New page documenting group_member(3)

isfdtype.3
    Michael Kerrisk
        New page documenting isfdtype(3)


Newly documented interfaces in existing pages
---------------------------------------------

perf_event_open.2
    Vince Weaver
        Document new comm_exec flag
            Linux 3.16 (more specifically, commit 82b897782d10fcc4 )
            added support for differentiating between process renames
            caused by exec versus those caused by other methods.
    Vince Weaver
        Document new mmap2 record type
            Linux 3.16 (more specifically, commit a5a5ba72843dd05f9 )
            enabled the enhanced mmap2 record support.
            The interface was added in Linux 3.12 but disabled until
            Linux 3.16.
    Vince Weaver
        Document PERF_SAMPLE_BRANCH_COND
            Linux 3.16 (more specifically, commit bac52139f0b7ab31330 )
            adds support for gathering PERF_SAMPLE_BRANCH_COND
            conditional branch values when doing PERF_SAMPLE_BRANCH_STACK
            sampling.

proc.5
    Michael Kerrisk
        Document /proc/PID/comm
    Michael Kerrisk
        Document /proc/PID/pagemap
    Michael Kerrisk
        Document /proc/PID/personality
    Michael Kerrisk
        Document /proc/PID/syscall
    Michael Kerrisk
        Document /proc/kpagecount
    Michael Kerrisk
        Document /proc/kpageflags
    Michael Kerrisk
        Document /proc/sys/vm/overcommit_kbytes

capabilities.7
    Michael Kerrisk
        Add CAP_AUDIT_READ
            CAP_AUDIT_READ is new in Linux 3.16.


Global changes
--------------

ldd.1
clone.2
execve.2
getpagesize.2
ioperm.2
msgop.2
readv.2
recv.2
select.2
send.2
seteuid.2
shmop.2
signal.2
sync.2
sysinfo.2
utime.2
abs.3
atoi.3
catopen.3
clearenv.3
ctime.3
des_crypt.3
ecvt.3
flockfile.3
fseeko.3
ftime.3
ftok.3
ftw.3
getcwd.3
getdtablesize.3
getline.3
getpass.3
getpass.3
getutent.3
glob.3
insque.3
lseek64.3
memmem.3
mkstemp.3
mktemp.3
on_exit.3
openpty.3
putenv.3
putenv.3
qecvt.3
realpath.3
realpath.3
remove.3
setbuf.3
sigpause.3
strftime.3
strptime.3
tzset.3
xcrypt.3
utmp.5
environ.7
ipv6.7
packet.7
    Michael Kerrisk
        Remove ancient Linux libc details

access.2
brk.2
chmod.2
eventfd.2
gethostname.2
getpriority.2
mmap.2
poll.2
ptrace.2
readv.2
sched_setaffinity.2
select.2
seteuid.2
signalfd.2
sync_file_range.2
timer_create.2
uname.2
wait.2
    Michael Kerrisk
        NOTES: add "C library/kernel ABI differences" subheading


Changes to individual pages
---------------------------

access.2
    Michael Kerrisk
        Glibc falls back to using access() on kernels that lack faccessat()

bdflush.2
fsync.2
sync.2
proc.5
    Adrian Bunk
        Change "sync(1)" to "sync(8)"

bind.2
    Michael Kerrisk  [Ryan Hammonds]
        Correct EINVAL error description
            As pointed out by Ryan:

                My application is trying to bind an IPv4 UDP socket to an
                address. I've found that passing an invalid address length
                to bind() causes bind to return EINVAL. According to the
                bind(2) manpage, this should only occur when using unix
                domain sockets (which I am not).

chmod.2
    Michael Kerrisk
        Glibc falls back to chmod() on kernels that don't support fchmodat()
    Michael Kerrisk
        Glibc falls back to chown()/lchown() on kernels that lack fchownat()

epoll_wait.2
    Michael Kerrisk
        NOTES: describe raw epoll_pwait() system call differences

getgroups.2
    Michael Kerrisk
        SEE ALSO: add group_member(3)

getpriority.2
    Michael Kerrisk
        Enhance discussion of kernel nice range versus user-space nice range
    Michael Kerrisk
        Move text describing nice range on other systems

getrlimit.2
    Michael Kerrisk
        Add cross reference to core(5) in discussion of RLIMIT_CORE
    Michael Kerrisk
        Describe the "large" resource limit bug on 32-bit platforms
            See https://bugzilla.kernel.org/show_bug.cgi?id=5042.
    Michael Kerrisk
        Glibc's setrlimit() and getrlimit() are implemented using prlimit()

kexec_load.2
    Michael Kerrisk
        Note limit of 16 for 'nr_segments'
    Michael Kerrisk
        Clarify the 'flags' bits that contain the architecture
    Michael Kerrisk
        Add KEXEC_ARCH_68K to list of architectures for 'flags'
    Michael Kerrisk
        Reword description of 'flags' a little

link.2
    Michael Kerrisk
        Glibc falls back to link() on kernels that lack linkat()
            Unless 'flags' contains AT_SYMLINK_FOLLOW.

mkdir.2
    Michael Kerrisk
        Glibc falls back to mkdir() on kernels that don't support mkdirat()

perf_event_open.2
    Vince Weaver
        Clarify PERF_SAMPLE_STACK_USER usage
            This clarifies the PERF_SAMPLE_STACK_USER section.
            I found these issue while implementing some code that uses
            the option.  The important change is fixing the name of the
            sample_stack_user parameter, the rest is just some wording
            fixes and minor clarifications.
    Vince Weaver
        Clarify PERF_SAMPLE_DATA_SRC usage
            When checking the fields in the PERF_SAMPLE_DATA_SRC type samples
            you need to shift the masks before doing the compare.

            Although the value you are checking (perf_mem_data_src) is
            specified as a bitfield so this might all fall apart if trying
            to access the field in a cross-endian way.  The Power people
            were working on this issue, not sure if they resolved it.

poll.2
    Michael Kerrisk
        Describe fifth argument (sigsetsize) of raw ppoll() system call

process_vm_readv.2
    Michael Kerrisk  [Ville Ylenius]
        Fix typo in example program

readlink.2
    Michael Kerrisk
        Glibc falls back to readlink() on kernels that lack readlinkat()

recv.2
    Michael Kerrisk
        'addrlen' should be NULL (not 0) if we don't need sender address

rename.2
    Michael Kerrisk
        Glibc falls back to rename() when the kernel doesn't have renameat()

sigwaitinfo.2
    Michael Kerrisk
        The raw sigtimedwait() system call has a fifth argument

symlink.2
    Michael Kerrisk
        Glibc falls back to symlink() on kernels that lack symlinkat()

sysinfo.2
    Michael Kerrisk
        Add VERSIONS section

unlink.2
    Michael Kerrisk
        Glibc falls back to unlink() or rmdir() on kernels that lack unlinkat()

atoi.3
    Michael Kerrisk
        Downgrade discussion of atoq()
            Remove most references to atoq() in this page, since this function
            was present only in Linux libc (not glibc).

cerf.3
cexp2.3
clog2.3
    Michael Kerrisk
        Update version number on "Not yet in glibc" sentence

fgetgrent.3
getgrent.3
getgrent_r.3
getgrnam.3
    Michael Kerrisk  [Rob Landley]
        Clarify that 'gr_mem' is a NULL-terminated array of pointers

fseeko.3
    Michael Kerrisk
        Add VERSIONS section

ftw.3
    Michael Kerrisk
        Add VERSIONS section

getauxval.3
    Michael Kerrisk
        Document ENOENT error
            And add an entry to BUGS explaining the ambiguity that was
            present before the addition of this error.

getgrouplist.3
    Michael Kerrisk
        SEE ALSO: add group_member(3)

getline.3
    Rahul Bedarkar
        Close opened file at end of example program

memmem.3
    Michael Kerrisk
        Rewrite text of glibc 2.0 bug

printf.3
    Michael Kerrisk  [Jakub Wilk]
        Clarify details of the %n conversion specifier
            See http://bugs.debian.org/756602
    Michael Kerrisk  [Jakub Wilk]
        Note use of 'j', 'z', and 't' length modifiers for '%n'
            See http://bugs.debian.org/756602
    Michael Kerrisk
        Update with some SUSv3 details

setbuf.3
    Michael Kerrisk
        Remove ancient Linux libc and 4.x BSD details

strstr.3
    Michael Kerrisk
        Remove discussion of Linux libc bugs
            Linux libc is old enough that we needn't care any longer.

strtod.3
    Michael Kerrisk
        Explain NAN(n-char-sequence)

strtod.3
    Michael Kerrisk
        SEE ALSO: add nan(3), nanf(3), NANL(3)

updwtmp.3
    Michael Kerrisk
        Replace AVAILABILITY section with note to link logwtmp() using -lutil
            Linux libc details are no longer needed these days.

core.5
    Rahul Bedarkar
        Close opened file in example program

proc.5
    Michael Kerrisk
        Fix kernel version numbers for /proc/PID/stat fields

proc.5
    Jan Chaloupka
        Add missing proc stats fields
            Adding missing proc stats fields from
            https://www.kernel.org/doc/Documentation/filesystems/proc.txt
    Michael Kerrisk  [Simon Paillard]
        Remove crufty text under 'timer_stats'
    Michael Kerrisk
        Update /proc/PID/stat 'state' field documentation
    Michael Kerrisk
        Improve description of /proc/PID/stat fields added in Linux 3.3 and 3.5
    Michael Kerrisk
        Refer to getauxval(3) in discussion of /proc/PID/auxv
    Michael Kerrisk
        Rework formatting of /proc/PID/stat list
            Make the field numbers more prominent.
    Michael Kerrisk
        Note that /proc/PID/cmdline is read-only
    Michael Kerrisk
        Rework discussion of CommitLimit and /proc/sys/vm/overcommit_memory
    Michael Kerrisk
        Improve discussion of /proc/sys/vm/overcommit_ratio

charsets.7
    David Prévot  [Marko Myllynen]
        Tidy up list
            Remove German from main list, to be consistent with earlier
            removal of Dutch and French (in commit a8ed5f7430e0d1).

inotify.7
    Michael Kerrisk
        Note that IN_ONLY_DIR can be used to avoid races
    Michael Kerrisk
        Note that insertion of IN_MOVED_FROM+IN_MOVED_TO pair is not atomic
    Michael Kerrisk
        Mention use of timeout when reading IN_MOVED_TO after IN_MOVED_FROM

man-pages.7
    Michael Kerrisk
        Add description of "C library/kernel ABI differences" subsection
    Michael Kerrisk
        Rework text describing sections (stylistic improvements)

vdso.7
    Mike Frysinger
        Add new i386 vdso symbols in Linux 3.15
    Michael Kerrisk
        Note kernel version that exports new i386 symbols (Linux 3.15)


==================== Changes in man-pages-3.72 ====================

Released: 2014-09-07, Mountain View


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Christian von Roques <roques@mti.ag>
Holger Hans Peter Freyther <holger@moiji-mobile.com>
Michael Haardt <michael@moria.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Peter Schiffer <pschiffe@redhat.com>
Rusty Russell <rusty@rustcorp.com.au>
Sorin Dumitru <sdumitru@ixiacom.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

memusage.1
    Peter Schiffer, Michael Kerrisk  [Jan Chaloupka]
        New page for glibc memusage(1) command

memusagestat.1
    Peter Schiffer  [Jan Chaloupka, Michael Kerrisk]
        New page for glibc memusagestat(1) command

mtrace.1
    Peter Schiffer  [Jan Chaloupka]
        New page describing the glibc mtrace(1) command


Changes to individual pages
---------------------------

connect.2
    Michael Haardt
        Note that a new socket should be used if connect() fails

fcntl.2
    Michael Kerrisk
        One must define _GNU_SOURCE to get the F_OFD_* definitions

poll.2, select.2
    Rusty Russell
        Fix erroneous description of "available for write".
            POSIX says: "POLLOUT Normal data may be written without
            blocking.".  This "may" is misleading, see the POSIX
            write page:

                Write requests to a pipe or FIFO shall be handled in the
                same way as a regular file with the following exceptions:
                ...
                If the O_NONBLOCK flag is clear, a write request may cause
                the thread to block, but on normal completion it shall
                return nbyte.
                ...
                When attempting to write to a file descriptor (other than a
                pipe or FIFO) that supports non-blocking writes and cannot
                accept the data immediately:

                If the O_NONBLOCK flag is clear, write() shall block the
                calling thread until the data can be accepted.

                If the O_NONBLOCK flag is set, write() shall not block the
                thread. If some data can be written without blocking the
                thread, write() shall write what it can and return the
                number of bytes written. Otherwise, it shall return -1 and
                set errno to [EAGAIN].

            The net result is that write() of more than 1 byte on a
            socket, pipe or FIFO which is "ready" may block: write()
            (unlike read!) will attempt to write the entire buffer and
            only return a short write under exceptional circumstances.

            Indeed, this is the behaviour we see in Linux:

            https://github.com/rustyrussell/ccan/commit/897626152d12d7fd13a8feb36989eb5c8c1f3485
            https://plus.google.com/103188246877163594460/posts/BkTGTMHDFgZ

errno.3
    Michael Kerrisk
        SEE ALSO: add errno(1)

rtnetlink.3
    Holger Hans Peter Freyther
        Fix parameters for the send() call in the example

inotify.7
    Michael Kerrisk
        IN_OPEN and IN_CLOSE_NOWRITE can also occur for directories
    Michael Kerrisk
        IN_CLOSE_WRITE occurs only for files (not monitored directory)
    Michael Kerrisk
        IN_MODIFY is generated for files only (not monitored directories)
    Michael Kerrisk
        IN_ACCESS occurs only for files inside directories
            IN_ACCESS does not occur for monitored directory.

packet.7
    Sorin Dumitru
        Fix include file
            It looks like most of the socket options from this man pages
            are not defined in <netpacket/packet.h>. They are defined in
            <linux/if_packet.h> so we should include that one.


==================== Changes in man-pages-3.73 ====================

Released: 2014-09-21, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

David Prévot <taffit@debian.org>
Eric W. Biederman <ebiederm@xmission.com>
J. Bruce Fields <bfields@fieldses.org>
Justin Cormack <justin@street-vision.com>
Lorenzo Beretta <lory.fulgi@infinito.it>
Michael Kerrisk <mtk.manpages@gmail.com>
Rob Landley <rob@landley.net>
Serge E. Hallyn <serge@hallyn.com>
Serge Hallyn <serge.hallyn@ubuntu.com>
Vasily Kulikov <segoon@openwall.com>
Vincent Lefevre <vincent@vinc17.net>
Vitaly Rybnikov <frodox@zoho.com>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

namespaces.7
    Michael Kerrisk  [Eric W. Biederman]
        New page providing overview of Linux namespaces

pid_namespaces.7
    Michael Kerrisk  [Eric W. Biederman, Vasily Kulikov, Rob Landley,
                      Serge Hallyn]
        New page describing PID namespaces

user_namespaces.7
    Michael Kerrisk  [Eric W. Biederman, Andy Lutomirski, Serge Hallyn]
        New page describing user namespaces.


Newly documented interfaces in existing pages
---------------------------------------------

clone.2
    Eric W. Biederman  [Michael Kerrisk]
        Document CLONE_NEWUSER for creating a new user namespace

setns.2
    Eric W. Biederman, Michael Kerrisk
        Document the PID, user, and mount namespace support
            Document CLONE_NEWPID, CLONE_NEWUSER, and CLONE_NEWNS flags.

unshare.2
    Michael Kerrisk  [Eric W. Biederman]
        Document CLONE_NEWPID
    Michael Kerrisk  [Eric W. Biederman]
        Document CLONE_NEWUSER
    Michael Kerrisk
        Document CLONE_THREAD, CLONE_SIGHAND, and CLONE_VM


Changes to individual pages
---------------------------

clone.2
    Michael Kerrisk
        Move some CLONE_NEWNET text to namespaces.7
    Michael Kerrisk
        Move some CLONE_NEWUTS text 2 to namespaces.7
    Michael Kerrisk
        Move some CLONE_NEWIPC text to namespaces.7
    Michael Kerrisk
        Reword discussion of CLONE_NEWNS, removing text also in namespaces(7)
    Michael Kerrisk
        Standardize text on CLONE_NEW* flags and CAP_SYS_ADMIN
    Michael Kerrisk
        EINVAL if (CLONE_NEWUSER|CLONE_NEWPID) && (CLONE_THREAD|CLONE_PARENT)
    Michael Kerrisk
        Add more detail on the meaning of CLONE_SYSVSEM

flock.2
    Michael Kerrisk  [J. Bruce Fields]
        Don't mention "classical BSD" in discussion of fcntl()/flock interaction
            The noninteraction of flock(2) and fcntl(2) locks does
            not seem to be classical BSD semantics (at least, checking
            the 4.4BSD sources suggest that the lock types do interact,
            although there have been other systems also where fcntl()
            and flock() locks do not interact). So, fix the text
            discussing "classical BSD" lock semantics.

getunwind.2
    Michael Kerrisk  [Yuri Kozlov]
        Fix description of return value
            s/size of unwind table/size of the unwind data/

mount.2
    Eric W. Biederman
        Clarify use of 'mountflags' and 'data' for MS_REMOUNT

reboot.2
    Michael Kerrisk  [Justin Cormack, Eric W. Biederman]
        Document effect of reboot() inside PID namespaces

semop.2
    Michael Kerrisk
        Refer to clone(2) for semantics of CLONE_SYSVSEM and semadj lists

seteuid.2
setgid.2
setresuid.2
setreuid.2
setuid.2
    Michael Kerrisk
        EINVAL can occur if UID/GID is not valid in caller's user namespace

setns.2
    Michael Kerrisk  [Eric W. Biederman]
        Clarify capabilities required for reassociating with a mount namespace
    Michael Kerrisk
        Specify kernel version on each CLONE_NEW* flag
            And remove text on flags from VERSIONS.

unshare.2
    Michael Kerrisk
        Add an example program
    Michael Kerrisk
        Clarify semantics of CLONE_SYSVSEM
    Michael Kerrisk
        CLONE_SYSVSEM does not require CAP_SYS_ADMIN
    Michael Kerrisk
        Note flags implied by CLONE_THREAD and CLONE_VM

clock.3
    Michael Kerrisk  [Vincent Lefevre]
        The implementation uses clock_gettime() was to improve *accuracy*
            (The man page text mistakenly used the word "precision".)

drand48.3
    Michael Kerrisk  [Lorenzo Beretta]
        Remove crufty text about SVID 3 marking drand48() obsolete
            See http://bugs.debian.org/758293

proc.5
    Michael Kerrisk
        Move /proc/[pid]/mounts text to namespaces.7
    Michael Kerrisk
        Move /proc/[pid]/mountstats text to namespaces.7

capabilities.7
    Michael Kerrisk
        Refer reader to user_namespaces(7) for a discussion of capabilities
    Michael Kerrisk
        Document CAP_SETUID and CAP_SETGID for user namespace mappings
    Michael Kerrisk
        setns() needs CAP_SYS_ADMIN in the *target* namespace
    Michael Kerrisk
        Since Linux 3.8, user namespaces no longer require CAP_SYS_ADMIN

mq_overview.7
    Michael Kerrisk
        Refer to namespaces(7) for info on POSIX MQs and IPC namespaces

svipc.7
    Michael Kerrisk
        Refer to namespaces(7) for info on System V IPC and IPC namespaces


==================== Changes in man-pages-3.74 ====================

Released: 2014-10-03, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Arto Bendiken <arto@bendiken.net>
Ben Hutchings <ben@decadent.org.uk>
Benjamin Herr <ben@0x539.de>
C. Alex North-Keys <erlkonig@talisman.org>
Carlos O'Donell <carlos@redhat.com>
Cyril Hrubis <chrubis@suse.cz>
Davidlohr Bueso <dave@stgolabs.net>
Doug Ledford <dledford@redhat.com>
Elie De Brauwer <eliedebrauwer@gmail.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Jonny Grant <jg@jguk.org>
Lanchon <lanchon@gmail.com>
Manfred Spraul <manfred@colorfullife.com>
Marko Myllynen <myllynen@redhat.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Shriramana Sharma <samjnaa@gmail.com>
Thomas Mack <mack@ifis.cs.tu-bs.de>
Wieland Hoffmann <themineo@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

pldd.1
    Michael Kerrisk
        New page for pldd(1) command added to glibc in version 2.15

cp1252.7
    Marko Myllynen
        New page documenting CP 1252
            CP 1252 is probably one of the most used Windows Code Pages so
            let's add a page for it alongside with the already provided
            CP 1251 page.

            Table generated from /usr/share/i18n/charmaps/CP1252.


Newly documented interfaces in existing pages
---------------------------------------------

mq_overview.7
    Michael Kerrisk
        Document /proc/sys/fs/mqueue/msgsize_default
    Michael Kerrisk
        Document /proc/sys/fs/mqueue/msg_default


Changes to individual pages
---------------------------

ldd.1
    Michael Kerrisk
        SEE ALSO: add pldd(1)

execve.2
    Michael Kerrisk  [C. Alex North-Keys]
        Remove unneeded ".sh" extension in interpreter script example
            See https://bugzilla.kernel.org/show_bug.cgi?id=84701

fanotify_init.2
    Heinrich Schuchardt
        BUGS: O_CLOEXEC is ignored
    Michael Kerrisk  [Heinrich Schuchardt]
        The 'event_f_flags' failure to check invalid flags was fixed in 3.15

fanotify_mark.2
    Michael Kerrisk
        Note that various bugs were fixed in Linux 3.16

getrlimit.2
    Michael Kerrisk  [Doug Ledford]
        Since Linux 3.5, the accounting formula for RLIMIT_MSGQUEUE has changed

open.2
    Michael Kerrisk  [Shriramana Sharma]
        Fix number and formula in description of EOVERFLOW error

readlink.2
    Michael Kerrisk  [Ben Hutchings]
        Fix description of readlinkat() with empty 'pathname'
    Michael Kerrisk
        SEE ALSO: add realpath(3)

sched_setattr.2
sched_setscheduler.2
    Michael Kerrisk
        SEE ALSO: add chrt(1)

shmget.2
    Manfred Spraul  [Michael Kerrisk, Davidlohr Bueso]
        Update for increase of SHMALL and SHMMAX
            The default values of SHMALL and SHMMAX have been increased.

syscalls.2
    Michael Kerrisk
        Add 3 new system calls added in Linux 3.17

vmsplice.2
    Cyril Hrubis
        vmsplice() does not fail when nr_segs==0
            This nr_segs==0 case is no-op; the call succeeds and no
            EINVAL error is returned.

dlopen.3
    Michael Kerrisk
        SEE ALSO: add pldd(1)

fseeko.3
    Michael Kerrisk  [Thomas Mack]
        _FILE_OFFSET_BITS must be defined before including any header file

getgrent.3
    Carlos O'Donell
        Add ENOENT and EAGAIN to error list

mq_getattr.3
    Michael Kerrisk
        Add an example program
            The example program can be used to discover the default
            'mq_maxmsg' and 'mq_msgsize' values used to create a queue with
            a mq_open(3) call in which 'attr' is NULL.

mq_open.3
    Michael Kerrisk
        Two /proc files control the defaults for the attrp==NULL case
            Refer the reader to the discussion in mq_overview(7) for a
            discussion of these files, which exist since Linux 3.5.

realpath.3
    Michael Kerrisk
        SEE ALSO: add realpath(1)

proc.5
    Elie De Brauwer
        Document /proc/buddyinfo
            This patch adds a short description about the contents of
            /proc/buddyinfo and how this file can be used to assist
            in checking for memory fragmentation issues.
    Michael Kerrisk
        Mention pmap(1) in discussion of /proc/PID/smaps

armscii-8.7
    Marko Myllynen
        Charset pages unification, minor cleanups

ascii.7
    Marko Myllynen
        Charset pages unification, minor cleanups
            This and [the related *.7] patches will provide unification of
            charset pages, minor cleanups, and some unifying cosmetic
            changes. References are adjusted so that all pages include
            a reference to charsets(7), which contains a description of
            these sets, stray comments are removed, some obsolete
            statements (like ISO 8859-1 being the de-facto ASCII
            replacement) are removed, and some minor reformatting
            to minimize diff's between the pages are done.

            The actual substance, the character tables, remain unchanged.

            This series changes the following pages (under man7): ascii,
            armscii, cp1251, koi8-r, koi8-u, and all of iso_8859-*.

cp1251.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-10.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-11.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-13.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-14.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-15.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-16.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-1.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-2.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-3.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-4.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-5.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-6.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-7.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-8.7
    Marko Myllynen
        Charset pages unification, minor cleanups

iso_8859-9.7
    Marko Myllynen
        Charset pages unification, minor cleanups

koi8-r.7
    Marko Myllynen
        Charset pages unification, minor cleanups
            - remove stray comments, streamline description
              (charsets(7) and Wikipedia provide more detailed
               and up-to-date description)
            - list differences between koi8-r.7 vs koi8-u.7

koi8-u.7
    Marko Myllynen
        Charset pages unification, minor cleanups
            - remove stray comments, streamline description
              (charsets(7) and Wikipedia provide more detailed
               and up-to-date description)
            - list differences between koi8-r.7 vs koi8-u.7

mq_overview.7
    Michael Kerrisk
        Update queues_max details for Linux 3.14
            And in general rework the text a little.
    Michael Kerrisk
        Update discussion of HARD_MSGMAX
            The limit has changed in 2.6.33 and then again in 3.5.
    Michael Kerrisk  [Arto Bendiken]
        Update details for 'queues_max' limit
            Things changed in Linux 3.5.
            See https://bugs.launchpad.net/bugs/1155695
    Michael Kerrisk
        Update details on defaults and ceiling for 'msgsize_max' limit
    Michael Kerrisk
        Rework discussion of HARD_MSGMAX
    Michael Kerrisk  [Davidlohr Bueso]
        Various fixes after review from Davidlohr Bueso

sched.7
    Michael Kerrisk
        SEE ALSO: add taskset(1)

ld.so.8
    Michael Kerrisk
        SEE ALSO: add pldd(1)
    Michael Kerrisk
        SEE ALSO: add dlopen(3)
    Michael Kerrisk
        SEE ALSO: add ld(1)



==================== Changes in man-pages-3.75 ====================

Released: 2014-10-15, Düsseldorf


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Jonny Grant <jg@jguk.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Robert Schweikert <rjschwei@suse.com>
Tetsuo Handa <penguin-kernel@i-love.sakura.ne.jp>
Walter Harms <wharms@bfs.de>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

pthread_rwlockattr_setkind_np.3
    Robert Schweikert  [Michael Kerrisk]
        New page documenting pthread_rwlockattr_[sg]etkind_np(3)
            Documents pthread_rwlockattr_setkind_np(3) and
            pthread_rwlockattr_getkind_np(3).


New and changed links
---------------------

pthread_rwlockattr_getkind_np.3
    Robert Schweikert
        New link to pthread_rwlockattr_setkind_np(3)


Changes to individual pages
---------------------------

readlink.2
    Michael Kerrisk  [Jonny Grant]
        Add free() call to example program

readv.2
    Michael Kerrisk
        The raw preadv() and pwritev() syscalls split 'offset' into 2 arguments

signal.7
    Michael Kerrisk
        pthread_mutex_lock() and pthread_cond_wait() are restartable
            pthread_mutex_lock(, pthread_cond_wait(), and related APIs are
            automatically restarted if interrupted by a signal handler.

unix.7
    Michael Kerrisk  [Carlos O'Donell, David Miller, Tetsuo Handa]
        Various additions and rewordings
            Notable changes:
            * Clarify some details for pathname sockets.
            * Add some advice on portably coding with pathname sockets.
            * Note the "buggy" behavior for pathname sockets when
              the supplied pathname is 108 bytes (after a report by
              Tetsuo Handa).


==================== Changes in man-pages-3.76 ====================

Released: 2014-12-31, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Adam Jiang <jiang.adam@gmail.com>
Andrea Balboni <andrea.balboni@unimore.it>
Andreas Schwab <schwab@suse.de>
Bernhard Walle <bernhard@bwalle.de>
Carlos O'Donell <carlos@redhat.com>
David Wragg <david@wragg.org>
Florian Westphal <fw@strlen.de>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Huxiaoxiang <huxiaoxiang@huawei.com>
Jan Chaloupka <jchaloup@redhat.com>
Jonathan Wakely <jwakely@redhat.com>
Jonny Grant <jg@jguk.org>
Josh Triplett <josh@joshtriplett.org>
Kamezawa Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Laurent Georget <laurent.georget@supelec.fr>
Manuel López-Ibáñez <lopezibanez@gmail.com>
Marko Myllynen <myllynen@redhat.com>
Ma Shimiao <mashimiao.fnst@cn.fujitsu.com>
Mel Gorman <mgorman@suse.de>
Michael Gehring <mg@ebfe.org>
Michael Haardt <michael@moria.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Rasmus Villemoes <rv@rasmusvillemoes.dk>
Richard Weinberger <richard@nod.at>
Rich Felker <dalias@libc.org>
Scott Harvey <scott.harvey@stonybrook.edu>
Siddhesh Poyarekar <siddhesh.poyarekar@gmail.com>
Simon Newton <nomis52@gmail.com>
Simon Paillard <spaillard@debian.org>
Sven Hoexter <sven@stormbind.net>
Tobias Werth <werth@cs.fau.de>
Weijie Yang <weijie.yang.kh@gmail.com>
Will Newton <will.newton@linaro.org>
Yuri Kozlov <yuray@komyakino.ru>
刘湃 <liupai_work@163.com>
尹杰 <writalnaie@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

adjtimex.2
    Laurent Georget
        Add fields in struct timex description
            This patch updates the man page with the new fields added in
            struct timex since last edition of the man page.
    Laurent Georget [Michael Kerrisk]
        Document ADJ_TAI
    Michael Kerrisk
        Improve description of ADJ_OFFSET_SINGLESHOT
    Michael Kerrisk
        Add brief documentation of ADJ_MICRO and ADJ_NANO
    Michael Kerrisk
        Reformat return value list
            And remove numeric values, since they're not needed
    Michael Kerrisk
        Other 'modes' bits are ignored on ADJ_OFFSET_*
            Other bits in 'modes' are ignored if modes contains
            ADJ_OFFSET_SINGLESHOT or ADJ_OFFSET_SS_READ.
    Michael Kerrisk
        Add nanosecond details
            Fixes https://bugzilla.kernel.org/show_bug.cgi?id=61171.
    Michael Kerrisk
        Document ADJ_OFFSET_SS_READ
    Michael Kerrisk
        Reformat 'times' flags as list
            And remove numeric values, since they're not needed.
    Michael Kerrisk
        Note effect of ADJ_NANO for ADJ_SETOFFSET
    Michael Kerrisk
        Add comment noting that timex structure contains padding bytes
    Michael Kerrisk
        Add more details to description of 'tai' field
    Michael Kerrisk
        Note meaning of "PLL" abbreviation
    Michael Kerrisk
        Clarify which 'timex' field is used by each 'modes' bit
    Michael Kerrisk
        Document timex 'status' bits
    Michael Kerrisk
        Clarify treatment of other 'modes' bits for ADJ_OFFSET_*
    Michael Kerrisk
        Update RFC number: RFC 5905 obsoletes RFC 1305
    Michael Kerrisk
        Briefly document ADJ_SETOFFSET
    Michael Kerrisk
        Note PPS (pulse per second) fields in timex structure

sigreturn.2
    Michael Kerrisk
        Add (a lot) more detail on the signal trampoline
            And rewrite much of the page.


Newly documented interfaces in existing pages
---------------------------------------------

proc.5
    Bernhard Walle
        Document /proc/thread-self
            /proc/thread-self has been introduced in Linux 3.17 with
            commit 0097875bd41528922fb3bb5f348c53f17e00e2fd.
    Sven Hoexter [Michael Kerrisk, Kamezawa Hiroyuki]
        Document "VmSwap" field of /proc/[pid]/status
    Florian Westphal
        Document /proc/net/netfilter/nfnetlink_queue


Changes to individual pages
---------------------------

localedef.1
    Marko Myllynen
        Mention default path for compiled files

clock_nanosleep.2
    Michael Kerrisk
        Note that 'clock_id' can also be a CPU clock ID

epoll_ctl.2
    Michael Kerrisk
        Regular files and directories can't be monitored with epoll_ctl()

ioctl.2
    Heinrich Schuchardt
        Rename 'd' argument to 'fd' in text
            In most other manpages file descriptors are called 'fd'.
            This patches renames attribute 'd' to 'fd'.

madvise.2
    Michael Kerrisk
        VERSIONS: Support for madvise() is now configurable
            Support for this system call now depends on the
            CONFIG_ADVISE_SYSCALLS configuration option.

open.2
    Michael Kerrisk
        Enhance rationale discussion for openat() and friends

posix_fadvise.2
    Mel Gorman
        Document the behavior of partial page discard requests
            It is not obvious from the interface that "partial page discard"
            requests are ignored. It should be spelled out.
    Michael Kerrisk  [Weijie Yang]
        ERRORS: Since 2.6.16, the kernel correctly deals with the ESPIPE case
    Michael Kerrisk
        Support for fadvise64() is now configurable
            Support for this system call now depends on the
            CONFIG_ADVISE_SYSCALLS configuration option.

prctl.2
    Andreas Schwab
        Correct description of null-termination in PR_GET_NAME and PR_SET_NAME
            The size of the process name has always been at most 16 byte
            _including_ the null terminator.  This also means that the
            name returned by PR_GET_NAME is always null-terminated.
    Michael Kerrisk
        PR_SET_NAME silently truncates strings that exceed 16 bytes

restart_syscall.2
    Michael Kerrisk
        Add some text explaining why restart_syscall() exists

sched_setaffinity.2
    Michael Kerrisk
        NOTES: Add paragraph on how to discover set of CPUs available on system
    Michael Kerrisk
        SEE ALSO: add nproc(1) and lscpu(1)

select.2
    Michael Kerrisk
        SEE ALSO: add restart_syscall(2)

semop.2
    Michael Kerrisk
        Add note that interrupted semtimedop() returns 'timeout' unchanged
    Michael Kerrisk
        Remove information about semtimedop() EAGAIN that is repeated elsewhere
    Michael Kerrisk
        Add subsection head for semtimedop()

setsid.2
    Michael Kerrisk
        Rewrite some pieces and add some details
            Among other changes, add an explanation of why setsid() can't
            be called from a process group leader

sgetmask.2
    Michael Kerrisk
        Since 3.16, support for these system calls is configurable
            Support for these calls is now dependent on the setting of the
            CONFIG_SGETMASK_SYSCALL option.

sigaction.2
    Michael Kerrisk
        Document SA_RESTORER
    Michael Kerrisk
        Add some detail on the sa_restorer field
    Michael Kerrisk
        SEE ALSO: add sigreturn(2)

splice.2
    Michael Kerrisk
        Reformat description of 'fd_in' and 'off_in' to improve readability

syscall.2
    Michael Kerrisk
        SEE ALSO: add errno(3)

syscalls.2
    Michael Kerrisk
        SEE ALSO: add errno(3)
    Michael Kerrisk
        3.19 adds execveat()
    Michael Kerrisk
        Add bpf(2) to list

tee.2
    Michael Kerrisk
        Add shell session demonstrating use of the example program

tkill.2
    Michael Kerrisk  [Rich Felker]
        Remove bogus text saying tgid==-1 makes tgkill() equivalent to tkill()

abort.3
    Michael Kerrisk
        Note that SIGABRT is raised as though raise(3) is called
            Also note that abort() is POSIX.1-2008 compliant.

cmsg.3
    David Wragg
        Ensure buf is suitably aligned in sending example
            Inspection of the definition of CMSG_FIRSTHDR (both in glibc and
            the suggested definition in RFC3542) shows that it yields the
            msg_control field.  So when sending, the pointer placed in
            msg_control should be suitably aligned as a struct cmsghdr.
            In the sending example, buf was declared as a bare char array,
            and so is not necessarily suitably aligned.

            The solution here involves placing buf inside a union, and is
            based on the sockets/scm_rights_send.c sample from The Linux
            Programming Interface "dist" source code collection.

exp10.3
    Michael Kerrisk
        Before glibc 2.19, exp() did not give ERANGE error on underflow
            http://sources.redhat.com/bugzilla/show_bug.cgi?id=6787

ftw.3
    Michael Kerrisk
        FTW_CHDIR has no effect on the 'fpath' argument passed to fn()

getopt.3
    Michael Kerrisk  [Jonny Grant]
        Ensure that 'nsecs' is used

ilogb.3
    Michael Kerrisk  [Will Newton]
        Since glibc 2.16, ilogb() does correctly diagnose domain errors

memcmp.3
    Michael Haardt
        Document return value for n==0 case
    Michael Haardt
        Warn against use of memcmp() for comparing security-critical data

mq_open.3
    Michael Kerrisk
        Document the O_CLOEXEC flag
    Michael Kerrisk
        Place 'flags' constants in alphabetical order

pow.3
    Manuel López-Ibáñez
        Add note on performance characteristics of pow()

pthread_setschedparam.3
    Simon Newton
        Fix logic error in example program
            The example program will crash if -A is used, since 'attr'
            is uninitialized.

                $ ./a.out  -A
                *** Error in `./a.out': free(): invalid pointer: 0xb779c3c4 ***
                Aborted (core dumped)
    刘湃
        Small fixes to example program

sigvec.3
    Michael Kerrisk
        Starting with version 2.21, glibc no longer exports sigvec()

sysconf.3
    Josh Triplett
        Document _SC_NGROUPS_MAX
            Already documented in getgroups(2), but not in sysconf(3).

termios.3
    Michael Kerrisk
        SEE ALSO: add tset(1)

tgamma.3
    Michael Kerrisk
        Since glibc 2.18, errno is correctly set to EDOM when (x == -infinity))

wordexp.3
    Carlos O'Donell
        Make it clear that WRDE_NOCMD prevents command substitution
            The use of WRDE_NOCMD prevents command substitution. If the flag
            WRDE_NOCMD is set then no command substitution shall occur and
            the error WRDE_CMDSUB will be returned if such substitution is
            requested when processing the words.

            The manual page as-is makes it seem like the command substitution
            occurs, and an error is returned *after* the substitution.
            This patch clarifies that.

locale.5
    Marko Myllynen
        Describe the formats of values
            locale(5) describes what a locale should define but doesn't
            spell out how (in what format). The patch attempts to address
            this, it also has few trivial additional enhancements.

            * Reference to locale(7) for category descriptions.
            * Clarify first_workday in NOTES a bit.
            * Add upstream BZ reference for two missing LC_ADDRESS fields.
    Marko Myllynen
        Fix miscoded character

resolv.conf.5
    Jan Chaloupka
        Add missing no-tld-query option
            Based on commit [1], the no-tld-query option exists for
            resolv.conf configuration file.  Description of this option
            is provided in [2]. This patch just copies this option
            into resolv.conf.5 man page. Plus changes 'a' member
            into 'an' before 'unqualified name as if it ...'
            on the third line of [2]. Based on [3], this option
            was added in glibc 2.14 as solving [4] bug.

            [1] https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=f87dfb1f11c01f2ccdc40d81e134cd06b32e28e8
            [2] http://www.daemon-systems.org/man/resolv.conf.5.html man page.
            [3] https://sourceware.org/git/?p=glibc.git;a=blob;f=NEWS;h=952f32af17e7fb49c4c1a305de673a13075bfaf5;hb=f87dfb1f11c01f2ccdc40d81e134cd06b32e28e8
            [4] https://sourceware.org/bugzilla/show_bug.cgi?id=12734

credentials.7
    Josh Triplett
        Cross-reference getgroups(2)
            Since credentials.7 discusses supplementary GIDs, it should
            reference getgroups(2).

fanotify.7
    Heinrich Schuchardt
        Allow relative paths in example
            The current example code requires passing an absolute
            path to the mount to be watched.

            By passing AT_FDCWD to fanotify_mark it can use both
            absolute and relative paths.
    Heinrich Schuchardt
        fallocate(2) creates no events
            fallocate(2) should create FAN_MODIFY events but does not.
    Heinrich Schuchardt [Michael Kerrisk]
        fanotify notifies only events generated on the same mount
            Unfortunately, fanotify does not inform listeners for all paths
            under which a touched filesystem object is visible, but only the
            listener using the same path as the process touching the
            filesystem object.
    Heinrich Schuchardt
        Update BUGS to note bugs still not fixed in 3.17
            I bumped the Linux version number in the BUGS section to 3.17.

inotify.7
    Heinrich Schuchardt
        fallocate(2) does not trigger inotify events
            Calling fallocate(2) does not result in inotify events.

locale.7
    Marko Myllynen
        Improve LOCPATH description
            LOCPATH is ignored by privileged programs.

            Add locale archive references.

            Add FILES section.

man-pages.7
    Michael Kerrisk  [Laurent Georget]
        Clarify that SEE ALSO entries may refer to pages from other projects

signal.7
    Michael Kerrisk
        Mention other "slow devices"
            Reads from eventfd(2), signalfd(2), timerfd(2), inotify(7),
            and fanotify(7) file descriptors are also slow operations
            that are restartable.
    Michael Kerrisk
        Fix SO_RECVTIMEO/ SO_SENDTIMEO confusion in text
    Michael Kerrisk
        Since Linux 3.8, reads on inotify(7) file descriptors are restartable
    Michael Kerrisk
        inotify(7) reads no longer show the odd EINTR error after SIGCONT
            Since kernel 3.7, reads from inotify(7) file descriptors no longer
            show the (Linux oddity) behavior of failing with EINTR when the
            process resumes after a stop signal + SIGCONT.
    Michael Kerrisk
        SEE ALSO: add sigreturn(2)

unix.7
    Michael Kerrisk  [Scott Harvey]
        Fix buglet in code snippet in BUGS section

ld.so.8
    Carlos O'Donell
        Add --inhibit-cache option
            The dynamic loader has 6 options, only 5 are documented.
            This patch documents the sixth option i.e. `--inhibit-cache`.
    Jonathan Wakely  [Siddhesh Poyarekar]
        Correct documentation of $ORIGIN
            As noted by Siddhesh:

                The ld.so man page says:

                    $ORIGIN (or equivalently ${ORIGIN})
                        This expands to the directory containing the
                        application executable.  Thus, an application located
                        in somedir/app could be compiled with

                This is incorrect since it expands to the directory containing
                the DSO and not the application executable.  This seems like
                deliberate behaviour in dl-object.c, so it needs to be fixed in
                the man page.

            See http://stackoverflow.com/questions/26280738/what-is-the-equivalent-of-loader-path-for-rpath-specification-on-linux/26281226#26281226



==================== Changes in man-pages-3.77 ====================

Released: 2015-01-10, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Akihiro Motoki <amotoki@gmail.com>
Alexandre Bique <bique.alexandre@gmail.com>
Andre Majorel <aym-xunil@teaser.fr>
Andy Lutomirski <luto@amacapital.net>
Daniel Borkmann <dborkman@redhat.com>
Dave Hansen <dave.hansen@intel.com>
Elie De Brauwer <eliedebrauwer@gmail.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Ignat Loskutov <ignat.loskutov@gmail.com>
Jeff Epler <jepler@unpythonic.net>
Jérôme Pouiller <jezz@sysmic.org>
Kees Cook <keescook@chromium.org>
Laurent Georget <laurent.georget@supelec.fr>
Masanari Iida <standby24x7@gmail.com>
Michael Haardt <michael@moria.de>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Richard Cochran <richardcochran@gmail.com>
Stephan Mueller <stephan.mueller@atsec.com>
Troy Davis <troy@yort.com>
Vince Weaver <vincent.weaver@maine.edu>
Will Drewry <wad@chromium.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

seccomp.2
    Kees Cook, Michael Kerrisk, Will Drewry  [Andy Lutomirski]
        New page documenting seccomp(2)
            Combines documentation from prctl, in-kernel seccomp_filter.txt
            and dropper.c, along with details specific to the new system call.


Newly documented interfaces in existing pages
---------------------------------------------

netlink.7
    Stephan Mueller  [Michael Kerrisk]
        Add NETLINK_CRYPTO


Changes to individual pages
---------------------------

adjtimex.2
    Laurent Georget  [Richard Cochran, Jeff Epler]
        Clarify the 'ppm scaling' used in struct timex
            This patch makes explicit and clarifies the unit used for
            the fields "freq", "ppsfreq" and "stabil" in struct timex.
    Michael Kerrisk  [Masanari Iida]
        Note that TIME_ERROR is the modern synonym for TIME_BAD

perf_event_open.2
    Vince Weaver
        Clarify the PERF_FLAG_FD_* flags
            This change clarifies the behavior of the PERF_FLAG_FD_OUTPUT and
            PERF_FLAG_FD_NO_GROUP flags to perf_event_open(), and removes
            the related FIXME comments.

            While writing tests to validate the behavior of these flags I
            discovered that PERF_FLAG_FD_OUTPUT has been broken since the
            2.6.35 kernel release.

prctl.2
    Dave Hansen [Michael Kerrisk]
        Add description of Intel MPX calls
            The 3.19 kernel will have support for Intel MPX, including
            a pair of new prctl() calls (PR_MPX_ENABLE_MANAGEMENT and
            PR_MPX_DISABLE_MANAGEMENT) for enabling and disabling the
            kernel's management of the "bounds tables".  Add a
            descriptions of the interface.
    Michael Kerrisk
        Add mention of seccomp(2) under PR_SET_SECCOMP
    Michael Kerrisk
        Suggest /proc/PID/status "Seccomp" as alternative to PR_GET_SECCOMP
    Michael Kerrisk
        SIGKILL can also occur PR_GET_SECCOMP in SECCOMP_MODE_FILTER mode
    Kees Cook  [Andy Lutomirski]
        Document SECCOMP_MODE_FILTER vs EFAULT
            This notes the distinction made between EINVAL and EFAULT when
            attempting to use SECCOMP_MODE_FILTER with PR_SET_SECCOMP.

setns.2
pid_namespaces.7
    Mike Frysinger
        Elaborate discussion of the PID namespace descendant limitation
            The setns(2) man page already mentions that CLONE_NEWPID may only
            be used with descendant namespaces, but this nuance could be
            listed in a few more places so it is not missed.

shmget.2
    Michael Kerrisk  [Akihiro Motoki]
        Make wording of SHMALL description a little clearer

sigaction.2
    Michael Kerrisk
        Add siginfo_t fields for SECCOMP_RET_TRAP

memchr.3
strstr.3
    Alexandre Bique
        Reference memmem(3) in SEE ALSO section

memcmp.3
    Michael Kerrisk  [Michael Haardt]
        NOTES: add some detail on avoiding memcmp() of cryptographic data
            Wording largely based on comments from Michael Haardt.

pthread_tryjoin_np.3
    Jérôme Pouiller  [Michael Kerrisk]
        Document EINVAL error for pthread_timedjoin_np()

mem.4
    Elie De Brauwer
        /dev/kmem depends on CONFIG_DEVKMEM
    Elie De Brauwer
        Correct /dev/port group in example
            mem.4 mentions that group for /dev/port should be set to 'mem'
            However, all other files (/dev/mem and /dev/kmem) use the kmem
            group in their examples and on my system /dev/port belongs to
            kmem. Hence the 'mem' group was probably a typo:
    Elie De Brauwer
        Add CONFIG_STRICT_DEVMEM
            Since 2.6.26 the CONFIG_NONPROMISC_DEVMEM options limits the
            physical addresses which can be accessed through /dev/mem.

random.4
    Heinrich Schuchardt
        Describe handling of O_NONBLOCK
            /dev/random and /dev/urandom treat O_NONBLOCK differently.
            This should be described in the manpage.
    Heinrich Schuchardt
        Mention PRNG used by urandom
            /dev/urandom uses a pseudo-random number generator to replace
            missing entropy.

proc.5
    Michael Kerrisk
        Document "Seccomp" field of /proc/PID/status

epoll.7
    Michael Kerrisk  [Ignat Loskutov]
        Use epoll_create1() rather than epoll_create() in the code example
            epoll_create1() is more or less the preferred API for new
            applications, since it allows for some flags and avoids the
            misdesigned epoll_create() argument, and so it seems sensible
            to use that in the example, rather than epoll_create().

tcp.7
    Troy Davis
        Clarify tcp_tw_recycle on Internet-facing hosts
            Clarify that tcp_tw_recycle will break communication with many
            general-purpose remote Internet hosts (namely, remote NAT devices)
            even when the Linux device itself is not behind NAT.


==================== Changes in man-pages-3.78 ====================

Released: 2015-01-22, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Akihiro Motoki <amotoki@gmail.com>
Alexey Ishchuk <aishchuk@linux.vnet.ibm.com>
Carlos O'Donell <carlos@redhat.com>
Christian Seiler <christian@iwakd.de>
Daniel J Blueman <daniel@quora.org>
David Drysdale <drysdale@google.com>
David Herrmann <dh.herrmann@gmail.com>
Elie De Brauwer <eliedebrauwer@gmail.com>
Elliot Hughes <enh@google.com>
Jessica McKellar <jessica.mckellar@gmail.com>
Kees Cook <keescook@chromium.org>
Michael Hayes <mike@aiinc.ca>
Michael Kerrisk <mtk.manpages@gmail.com>
Rich Felker <dalias@aerifal.cx>
Vince Weaver <vincent.weaver@maine.edu>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

execveat.2
    David Drysdale, Michael Kerrisk  [Rich Felker]
        New page for execveat(2)

memfd_create.2
    Michael Kerrisk, David Herrmann
        New page for memfd_create() system call
             Including notes about file sealing

s390_pci_mmio_write.2
    Alexey Ishchuk
        New page for s390 s390_pci_mmio_write() and s390_pci_mmio_read()
            New manual page for the new PCI MMIO memory access system
            calls, s390_pci_mmio_write() and s390_pci_mmio_read(),
            added for the s390 platform.


Newly documented interfaces in existing pages
---------------------------------------------

fcntl.2
    David Herrmann  [Michael Kerrisk]
        Document F_ADD_SEALS and F_GET_SEALS commands

proc.5
    Elie De Brauwer
        Document /proc/sys/vm/compact_memory
    Michael Kerrisk
        Document /proc/sys/fs/nr_open


New and changed links
---------------------

s390_pci_mmio_read.2
    Michael Kerrisk
        New link to new s390_pci_mmio_write(2) page


Changes to individual pages
---------------------------

dup.2
    Michael Kerrisk
        Add reference to RLIMIT_NOFILE for EMFILE error
    Michael Kerrisk
        Add reference to RLIMIT_NOFILE for EBADF error on 'newfd'.

execve.2
fexecve.3
    Michael Kerrisk
        SEE ALSO: add execveat(2)

fallocate.2
mmap.2
open.2
truncate.2
write.2
    Michael Kerrisk
        ERRORS: add EPERM for operation denied by file seal

fcntl.2
    Michael Kerrisk
        ERRORS: add EBUSY case for F_SETPIPE_SZ
    Michael Kerrisk
        Add reference to RLIMIT_NOFILE for F_DUPFD EINVAL error on 'arg'.
    Michael Kerrisk
        ERRORS: add open file description lock error cases

getrlimit.2
    Michael Kerrisk
        Update text on RLIMIT_NOFILE ceiling to refer to /proc/sys/fs/file-max

mbind.2
    Michael Kerrisk  [Daniel J Blueman]
        Clarify EFAULT text

mmap.2
shmget.2
shm_open.3
    Michael Kerrisk
        SEE ALSO: add memfd_create(2)

open.2
    Michael Kerrisk
        Refer to RLIMIT_NOFILE for explanation of EMFILE error
    Michael Kerrisk
        Add execveat(2) in system call list under "Rationale for openat()"

perf_event_open.2
    Vince Weaver
        Clarify description of overflow events
            Update the perf_event_open manpage to be more consistent when
            discussing overflow events.  It merges the discussion of
            poll-type notifications with those generated by SIGIO
            signal handlers.
            This addresses the remaining FIXMEs is the document.
    Vince Weaver
        Remove inaccurate paragraph describing attr.config
            Remove an inaccurate paragraph about values in the attr.config
            field.  This information was never true in any released kernel;
            it somehow snuck into the manpage because it is still described
            this way in tools/perf/design.txt in the kernel source tree.
    Michael Kerrisk
        Correct the kernel version number for PERF_COUNT_HW_CACHE_NODE
    Michael Kerrisk
        Add some kernel version numbers to various fields and constants

ptrace.2
sigaction.2
seccomp.2
    Kees Cook
        Ptrace and siginfo details
            While writing some additional seccomp tests, I realized
            PTRACE_EVENT_SECCOMP wasn't documented yet. Fixed this, and added
            additional notes related to ptrace events SIGTRAP details.

readv.2
    Michael Kerrisk
        Update details on glibc readv()/writev() wrapper behavior
            And add a historical detail about Linux 2.0.

select.2
    Michael Kerrisk
        Mention RLIMIT_NOFILE as a possible cause of EINVAL error

syscall.2
    Kees Cook
        Add arm64 and mips
            Add mips and arm64 to tables, along with some further
            details on these architectures,

syscalls.2
    Michael Kerrisk
        Add s390_pci_mmio_read(2) and s390_pci_mmio_write(2)
    Michael Kerrisk
        Note kernel() version that introduced get_kernel_syms()
        Note kernel version that introduced ppc_rtas()
        Note kernel version that introduced create_module()
        Note kernel version that added setup()
    Michael Kerrisk
        Remove some details for sync_file_range2()
            Make the table a bit simpler. The details can anyway be
            found in the system call man page.

utimensat.2
    Michael Kerrisk  [Elliot Hughes]
        If both tv_sec fields are UTIME_OMIT, the file need not exist
            As noted by Elliot, if both tv_sec fields are UTIME_OMIT,
            utimensat() will return success even if the file does not exist.

errno.3
    Michael Kerrisk
        The RLIMIT_NOFILE resource limit is a common cause of EMFILE

exec.3
    Michael Kerrisk
        SEE ALSO: add execveat(2)

fclose.3
    Carlos O'Donell
        Consistency fix: use "stream" as name for "FILE *" argument
            Harmonize all the manual pages to use "stream" for FILE*
            instead of randomly using "fp" or "stream." Choosing something
            and being consistent helps users scan the man pages quickly
            and understand what they are looking at.

fexecve.3
    Michael Kerrisk
        Rewrite the script+close-on-exec problem as a BUG
            Also, add one or two details about this scenario.
    Michael Kerrisk
        The natural idiom when using fexecve() is to use the close-on-exec flag

fmemopen.3
    Michael Kerrisk
        Consistency fix: use "stream" as name for "FILE *" argument

fopencookie.3
    Michael Kerrisk
        Consistency fix: use "stream" as name for "FILE *" argument

getgrent_r.3
    Carlos O'Donell
        Consistency fix: use "stream" as name for "FILE *" argument

getline.3
    Michael Kerrisk
        Consistency fix: use "stream" as name for "FILE *" argument

getmntent.3
    Carlos O'Donell
        Consistency fix: use "stream" as name for "FILE *" argument

getpw.3
    Michael Kerrisk  [Carlos O'Donell]
        Describe return value when 'uid' is not found

getpwent_r.3
    Carlos O'Donell
        Consistency fix: use "stream" as name for "FILE *" argument

getspnam.3
    Carlos O'Donell
        Consistency fix: use "stream" as name for "FILE *" argument

malloc_info.3
    Carlos O'Donell
        Consistency fix: use "stream" as name for "FILE *" argument

posix_fallocate.3
    Michael Kerrisk
        Note that posix_fallocate() is implemented using fallocate(2)

putgrent.3
    Carlos O'Donell
        Consistency fix: use "stream" as name for "FILE *" argument
            Harmonize all the manual pages to use "stream" for FILE*
            instead of randomly using "fp" or "stream." Choosing something
            and being consistent helps users scan the man pages quickly
            and understand what they are looking at.

locale.5
    Akihiro Motoki
        Correct variable name

proc.5
    Michael Kerrisk
        Remove bogus statement about NR_OPEN being a ceiling for file-max


==================== Changes in man-pages-3.79 ====================

Released: 2015-02-01, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Akihiro Motoki <amotoki@gmail.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
J William Piggott <elseifthen@gmx.com>
Masanari Iida <standby24x7@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Scot Doyle <lkml14@scotdoyle.com>
Sergey V. Zubkov <cubbi@cubbi.com>
Stephan Mueller <stephan.mueller@atsec.com>
Vince Weaver <vincent.weaver@maine.edu>
Vivek Goyal <vgoyal@redhat.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

getrandom.2
    Heinrich Schuchardt, Theodore T'so, Michael Kerrisk
        New page documenting getrandom(2)
            Kernel 3.17 introduces a new system call getrandom(2).

kexec_load.2
    Vivek Goyal, Michael Kerrisk
        Add documentation of kexec_file_load(2)
    Michael Kerrisk, Vivek Goyal
        Rewrite and extend documentation of kexec_load().


New and changed links
---------------------

kexec_file_load.2
    Michael Kerrisk
        New link to kexec_load.2

Changes to individual pages
---------------------------

personality.2
    Michael Kerrisk
        SEE ALSO: add setarch(8)

prctl.2
    Michael Kerrisk
        Unused arguments of PR_MPX_(EN,DIS}ABLE_MANAGEMENT must be zero

reboot.2
    Michael Kerrisk
        SEE ALSO: add kexec_load(2)

socket.2
    Stephan Mueller
        document AF_ALG
            Add a reference to the AF_ALG protocol accessible via socket(2).

fflush.3
    Michael Kerrisk  [Sergey V. Zubkov]
        Clarify that flushing of input streams occurs only for seekable files
            See https://bugzilla.kernel.org/show_bug.cgi?id=91931
    Michael Kerrisk  [Sergey V. Zubkov]
        POSIX.1-2008 specifies the behavior when flushing input streams
            POSIX.1-2001 did not have a specification for input streams,
            but POSIX.1-2008 added one.

getopt.3
    Michael Kerrisk
        SEE ALSO: add getopt(1)

random.3
    Heinrich Schuchardt
        SEE ALSO: add getrandom(2)

termios.3
    Michael Kerrisk
        SEE ALSO: add reset(1), setterm(1), tput(1)

tzset.3
    J William Piggott
        Document behavior when TZ filespec omits the colon
            If the TZ filespec omits the leading colon, glibc will parse
            it for any valid format, i.e., it will still work.
    J William Piggott
        Add description for posixrules file
    J William Piggott
        Correct system timezone file path
    J William Piggott
        There are only two TZ formats
            tzset(3) currently states that there are three TZ formats. The
            first two it lists are actually variations of the POSIX-style
            TZ format, of which there are at least five variations.

            This patch corrects this to match the POSIX specification of
            TZ having only two formats.
    J William Piggott
        Filespec omitted incorrect
            Paragraph three of the DESCRIPTION section says
            that when TZ is set, but empty, then UTC is used.

            Later it says if the TZ filespec is omitted then the file
            /usr/share/zoneinfo/localtime is used.  This is incorrect,
            it will use UTC in that case as well.
    J William Piggott
        Fix incorrect TZ string representation
            The TZ string representation indicates that the start/end
            rules are required; this is incorrect.
    J William Piggott
        Add ENVIRONMENT section + other rearrangements
            FILES section was overly verbose and included
            environment variables.  Added ENVIRONMENT section,
            removing ENV VARS from the FILES section.

random.4
    Heinrich Schuchardt
        SEE ALSO: add getrandom(2)

passwd.5
    Michael Kerrisk
        SEE ALSO: add chfn(1), chsh(1)

capabilities.7
    Michael Kerrisk
        SEE ALSO: add setpriv(1)

signal.7
    Michael Kerrisk
        Add getrandom(2) to list of restartable system calls
    Michael Kerrisk
        Add F_OFD_SETLKW to list of restartable operations



==================== Changes in man-pages-3.80 ====================

Released: 2015-02-21, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Akihiro Motoki <amotoki@gmail.com>
Andy Lutomirski <luto@amacapital.net>
Bill McConnaughey <mcconnau@biochem.wustl.edu>
Chris Mayo <aklhfex@gmail.com>
Christophe Blaess <Christophe@blaess.fr>
David Wilson <dw@botanicus.net>
Denys Vlasenko <dvlasenk@redhat.com>
Doug Goldstein <cardoe@gentoo.org>
Eric Wong <normalperson@yhbt.net>
Heinrich Schuchardt <xypron.glpk@gmx.de>
J William Piggott <elseifthen@gmx.com>
James Hunt <james.hunt@ubuntu.com>
Jan Chaloupka <jchaloup@redhat.com>
Jan Stancek <jstancek@redhat.com>
Jeff Layton <jlayton@poochiereds.net>
Jens Thoms Toerring <jt@toerring.de>
Kevin Easton <kevin@guarana.org>
Luke Faraone <lfaraone@debian.org>
Mark Seaborn <mseaborn@chromium.org>
Mathieu Malaterre <malat@debian.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Michal Hocko <mhocko@suse.cz>
Minchan Kim <minchan@kernel.org>
Patrick Horgan <phorgan1@gmail.com>
Peng Haitao <penght@cn.fujitsu.com>
Ralf Baechle <ralf@linux-mips.org>
Rob Somers <uberkermit@gmail.com>
Simon Paillard <spaillard@debian.org>
Stephen Smalley <sds@tycho.nsa.gov>
Tao Ma <tao.ma@oracle.com>
Tobias Herzke <tobias.linuxpatches.2014@gi2.herzkes.de>
Vince Weaver <vincent.weaver@maine.edu>
Vlastimil Babka <vbabka@suse.cz>
Zbigniew Brzeziński <zbigniew.brzezinski@student.put.poznan.pl>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

ioctl_fat.2
    Heinrich Schuchardt  [Michael Kerrisk]
        New man page for the ioctl(2) FAT API
            The ioctl(2) system call may be used to retrieve information about
            the FAT file system and to set file attributes.

madvise.2
    Michael Kerrisk
         Summary: this page has been significantly reorganised and rewritten
    Michael Kerrisk
        Recast discussion of 'advice' into two groups of values
            madvise() is one of those system calls that has congealed over
            time, as has the man page. It's helpful to split the discussion
            of 'advice' into those flags into two groups:

            * Those flags that are (1) widespread across implementations;
              (2) have counterparts in posix_madvise(3); and (3) were present
              in the initial Linux madvise implementation.
            * The rest, which are values that (1) may not have counterparts
              in other implementations; (2) have no counterparts in
              posix_madvise(3); and (3) were added to Linux in more recent
              times.
    Michael Kerrisk
        Explicitly list the five flags provided by posix_fadvise()
            Over time, bit rot has afflicted this page. Since the original
            text was written many new Linux-specific flags have been added.
            So, now it's better to explicitly list the flags that
            correspond to the POSIX analog of madvise().
    Jan Chaloupka  [Hugh Dickins, Michael Kerrisk]
        Starting with Linux 3.5, more file systems support MADV_REMOVE
    Michael Kerrisk
        Split EINVAL error into separate cases
    Michael Kerrisk
        Explain MADV_REMOVE in terms of file hole punching
    Michael Kerrisk
        MADV_REMOVE can be applied only to shared writable mappings
    Michael Kerrisk
        MADV_REMOVE cannot be applied to locked or Huge TLB pages
    Michael Kerrisk  [Vlastimil Babka]
        Clarify that MADV_DONTNEED has effect on pages only if it succeeds
    Michael Kerrisk  [Vlastimil Babka]
        Clarifications for MADV_DONTNEED
    Michael Kerrisk  [Michal Hocko]
        Improve MADV_DONTNEED description
    Michael Kerrisk
        MADV_DONTNEED cannot be applied to Huge TLB or locked pages
    Michael Kerrisk  [Vlastimil Babka]
        Remove mention of "shared pages" as a cause of EINVAL for MADV_DONTNEED
    Michael Kerrisk  [Vlastimil Babka]
        Note Huge TLB as a cause of EINVAL for MADV_DONTNEED
    Michael Kerrisk  [Minchan Kim]
        Add mention of VM_PFNMAP in discussion of MADV_DONTNEED and MADV_REMOVE
    Michael Kerrisk
        Drop sentence saying that kernel may ignore 'advice'
            The sentence creates misunderstandings, and does not really
            add information.
    Michael Kerrisk
        Note that some Linux-specific 'advice' change memory-access semantics
    Michael Kerrisk
        NOTES: Remove crufty text about "command" versus "advice"
            The point made in this fairly ancient text is more or less evident
            from the DESCRIPTION, and it's not clear what "standard" is being
            referred to.
    Michael Kerrisk
        Mention POSIX.1-2008 addition of POSIX_MADV_NOREUSE
    Michael Kerrisk
        Remove "POSIX.1b" from CONFORMING TO
    Michael Kerrisk
        Move mention of posix_fadvise() from CONFORMING TO to SEE ALSO
    Michael Kerrisk
        ERRORS: add EPERM error case for MADV_HWPOISON
    Michael Kerrisk
        Note that madvise() is nonstandard, but widespread


Newly documented interfaces in existing pages
---------------------------------------------

proc.5
    Michael Kerrisk
        (Briefly) document /proc/PID/attr/socketcreate
    Michael Kerrisk
        (Briefly) document /proc/PID/attr/keycreate
    Michael Kerrisk  [Stephen Smalley]
        Document /proc/PID/attr/{current,exec,fscreate,prev}
            Heavily based on Stephen Smalley's text in
                https://lwn.net/Articles/28222/
                From:    Stephen Smalley <sds@epoch.ncsc.mil>
                To:      LKML and others
                Subject: [RFC][PATCH] Process Attribute API for Security Modules
                Date:    08 Apr 2003 16:17:52 -0400
    Michael Kerrisk
        Document /proc/sys/kernel/auto_msgmni

socket.7
    David Wilson  [Michael Kerrisk]
        Document SO_REUSEPORT socket option


New and changed links
---------------------

get_thread_area.2
    Andy Lutomirski
        Make get_thread_area.2 a link to rewritten set_thread_area.2 page


Changes to individual pages
---------------------------

time.1
    Michael Kerrisk
        Make option argument formatting consistent with other pages

access.2
    Denys Vlasenko
        Explain how access() check treats capabilities
            We have users who are terribly confused why their binaries
            with CAP_DAC_OVERRIDE capability see EACCESS from access() calls,
            but are able to read the file.

            The reason is access() isn't the "can I read/write/execute this
            file?" question, it is the "(assuming that I'm a setuid binary,)
            can *the user who invoked me* read/write/execute this file?"
            question.

            That's why it uses real UIDs as documented, and why it ignores
            capabilities when capability-endorsed binaries are run by non-root
            (this patch adds this information).

            To make users more likely to notice this less-known detail,
            the patch expands the explanation with rationale for this logic
            into a separate paragraph.

arch_prctl.2
set_thread_area.2
get_thread_area.2
    Andy Lutomirski
        Improve TLS documentation
            The documentation for set_thread_area was very vague.  This
            improves it, accounts for recent kernel changes, and merges
            it with get_thread_area.2.

            get_thread_area.2 now becomes a link.

            While I'm at it, clarify the related arch_prctl.2 man page.

cacheflush.2
    Ralf Baechle
        Update some portability details and bugs
    Michael Kerrisk
        Refer reader to BUGS in discussion of EINVAL error

capget.2
    Michael Kerrisk
        Document V3 capabilities constants
    Michael Kerrisk
        Rewrite discussion of kernel versions that support file capabilities
            File capabilities ceased to be optional in Linux 2.6.33.

clone.2
    Peng Haitao
        Fix description of CLONE_PARENT_SETTID
            CLONE_PARENT_SETTID only stores child thread ID in parent memory.

clone.2
execve.2
    Kevin Easton
        Document interaction of execve(2) with CLONE_FILES
            This patch the fact that a successful execve(2) in a process that
            is sharing a file descriptor table results in unsharing the table.

            I discovered this through testing and verified it by source
            inspection - there is a call to unshare_files() early in
            do_execve_common().

fcntl.2
    Michael Kerrisk  [Jeff Layton]
        Clarify cases of conflict between traditional record and OFD locks
            Verified by experiment on Linux 3.15 and 3.19rc4.

fork.2
    Michal Hocko
        EAGAIN is not reported when task allocation fails
            I am not sure why we have:

               "EAGAIN fork() cannot allocate sufficient memory to copy
                the parent's page tables and allocate a task structure
                or the child."

            The text seems to be there from the time when man-pages
            were moved to git so there is no history for it.

            And it doesn't reflect reality: the kernel reports both
            dup_task_struct and dup_mm failures as ENOMEM to the
            userspace. This seems to be the case from early 2.x times
            so let's simply remove this part.
    Heinrich Schuchardt
        Child and parent run in separate memory spaces
            fork.2 should clearly point out that child and parent
            process run in separate memory spaces.
    Michael Kerrisk
        NOTES: add "C library/kernel ABI differences" subheading

getpid.2
    Michael Kerrisk
        NOTES: add "C library/kernel ABI differences" subheading

getxattr.2
    Michael Kerrisk
        Various rewordings plus one or two details clarified
    Michael Kerrisk
        Add pointer to example in listxattr(2)

killpg.2
    Michael Kerrisk
        NOTES: add "C library/kernel ABI differences" subheading

listxattr.2
    Heinrich Schuchardt
        Provide example program
    Michael Kerrisk
        Reword discussion of size==0 case
    Michael Kerrisk
        Add note on handling increases in sizes of keys or values
    Michael Kerrisk
        Remove mention of which filesystems implement ACLs
            Such a list will only become outdated (as it already was).

migrate_pages.2
    Jan Stancek
        Document EFAULT and EINVAL errors
            I encountered these errors while writing testcase for migrate_pages
            syscall for LTP (Linux test project).

            I checked stable kernel tree 3.5 to see which paths return these.
            Both can be returned from get_nodes(), which is called from:
            SYSCALL_DEFINE4(migrate_pages, pid_t, pid, unsigned long, maxnode,
                            const unsigned long __user *, old_nodes,
                            const unsigned long __user *, new_nodes)

            The testcase does following:
            EFAULT
            a) old_nodes/new_nodes is area mmaped with PROT_NONE
            b) old_nodes/new_nodes is area not mmapped in process address
               space, -1 or area that has been just munmmaped

            EINVAL
            a) maxnodes overflows kernel limit
            b) new_nodes contain node, which has no memory or does not exist
               or is not returned for get_mempolicy(MPOL_F_MEMS_ALLOWED).

modify_ldt.2
    Andy Lutomirski
        Overhaul the documentation
            This clarifies the behavior and documents all four functions.
    Andy Lutomirski
        Clarify the lm bit's behavior
            The lm bit should never have existed in the first place.  Sigh.

mprotect.2
    Mark Seaborn
        Mention effect of READ_IMPLIES_EXEC personality flag
            I puzzled over mprotect()'s effect on /proc/*/maps for a while
            yesterday -- it was setting "x" without PROT_EXEC being specified.
            Here is a patch to add some explanation.

msgget.2
    Michael Kerrisk
        Add details of MSGMNI default value

msgop.2
    Michael Kerrisk
        Clarify wording of MSGMAX and MSGMNB limits

perf_event_open.2
    Vince Weaver
        Clarify PERF_EVENT_IOC_REFRESH behavior
            Currently the PERF_EVENT_IOC_REFRESH ioctl, when applied to a group
            leader, will refresh all children.  Also if a refresh value of 0
            is chosen then the refresh becomes infinite (never runs out).
            Back in 2011 PAPI was relying on these behaviors but I was told
            that both were unsupported and subject to being removed at any time.
            (See https://lkml.org/lkml/2011/5/24/337 )
            However the behavior has not been changed.

            This patch updates the manpage to still list the behavior as
            unsupported, but removes the inaccurate description of it
            only being a problem with 2.6 kernels.

prctl.2
    Michael Kerrisk  [Bill McConnaughey]
        Mention file capabilities in discussion of PR_SET_DUMPABLE
    Michael Kerrisk
        Greatly expand discussion of "dumpable" flag
            In particular, detail the interactions with
            /proc/sys/fs/suid_dumpable.
    Michael Kerrisk
        Reorder paragraphs describing PR_SET_DUMPABLE
    Michael Kerrisk
        Mention SUID_DUMP_DISABLE and SUID_DUMP_USER under PR_SET_DUMPABLE
    Michael Kerrisk
        Executing a file with capabilities also resets the parent death signal

ptrace.2
    James Hunt
        Explain behaviour should ptrace tracer call execve(2)
            This behaviour was verified by reading the kernel source and
            confirming the behaviour using a test program.
    Denys Vlasenko
        Add information on PTRACE_SEIZE versus PTRACE_ATTACH differences
            Extend description of PTRACE_SEIZE with the short summary of its
            differences from PTRACE_ATTACH.

            The following paragraph:

            PTRACE_EVENT_STOP
                   Stop induced by PTRACE_INTERRUPT command, or group-stop, or ini-
                   tial  ptrace-stop when a new child is attached (only if attached
                   using PTRACE_SEIZE), or PTRACE_EVENT_STOP if PTRACE_SEIZE was used.

            has an editing error (the part after last comma makes no sense).
            Removing it.

            Mention that legacy post-execve SIGTRAP is disabled by PTRACE_SEIZE.

sched_setattr.2
    Michael Kerrisk  [Christophe Blaess]
        SYNOPSIS: remove 'const' from 'attr' sched_getattr() argument

semget.2
    Michael Kerrisk
        Note default value for SEMMNI and SEMMSL

semop.2
    Michael Kerrisk
        Note defaults for SEMOPM and warn against increasing > 1000

sendfile.2
    Eric Wong
        Caution against modifying sent pages

setxattr.2
    Michael Kerrisk
        ERRORS: add ENOTSUP for invalid namespace prefix
    Michael Kerrisk
        Remove redundant text under ENOTSUP error
    Michael Kerrisk
        Note that zero-length attribute values are permitted
    Michael Kerrisk
        Rework text describing 'flags' argument

stat.2
    Michael Kerrisk
        NOTES: add "C library/kernel ABI differences" subheading

statfs.2
    Michael Kerrisk  [Jan Chaloupka]
        Document the 'f_flags' field added in Linux 2.6.36
    Michael Kerrisk
        Clarify that 'statfs' structure has some padding bytes
            The number of padding bytes has changed over time, as some
            bytes are used, so describe this aspect of the structure
            less explicitly.
    Tao Ma
        Add OCFS2_SUPER_MAGIC
    Michael Kerrisk
        Use __fsword_t in statfs structure definition
            This more closely matches modern glibc reality.
    Michael Kerrisk
        Add a note on the __fsword_t type
    Michael Kerrisk
        Document 'f_spare' more vaguely

wait.2
    Michael Kerrisk
        Note that waitpid() is a wrapper for wait4()
    Michael Kerrisk
        Note that wait() is a library function implemented via wait4()

wait4.2
    Michael Kerrisk
        NOTES: add "C library/kernel ABI differences" subheading

encrypt.3
    Rob Somers
        Improve code example
            I (and some others) found that the original example code
            did not seem to work as advertised.  The new code (used by
            permission of the original author, Jens Thoms Toerring)
            was found on comp.os.linux.development.

mktemp.3
    Luke Faraone
        DESCRIPTION reference to BUGS corrected
            mktemp(3)'s DESCRIPTION referenced NOTES, but no such
            section exists. Corrected to refer to BUGS.

pthread_attr_setschedparam.3
    Tobias Herzke
        Describe EINVAL in ERRORS

resolver.3
host.conf.5
    Simon Paillard
        host.conf 'order' option deprecated, replaced by nsswitch.conf(5)
            http://www.sourceware.org/bugzilla/show_bug.cgi?id=2389
            http://repo.or.cz/w/glibc.git/commit/b9c65d0902e5890c4f025b574725154032f8120a

            Reported at http://bugs.debian.org/270368,
            http://bugs.debian.org/396633, and http://bugs.debian.org/344233.

statvfs.3
    Michael Kerrisk
        Document missing 'f_flag' bit values
            And reorganize information relating to which flags are in
            POSIX.1.
    Michael Kerrisk  [Jan Chaloupka]
        statvfs() now populates 'f_flag' from  statfs()'s f_flag field
            These changes came with glibc 2.13, and the kernel's addition of
            a 'f_flags' field in Linux 2.6.36.

syslog.3
    Michael Kerrisk  [Doug Goldstein]
        Remove unneeded <stdarg.h>
            vsyslog() does not need this.

tzset.3
    J William Piggott
        Add offset format
            tzset.3 does not illustrate the POSIX offset format.
            Specifically, there is no indication in the manual
            what the optional components of it are.

random.4
    Michael Kerrisk
        Note maximum number of bytes returned by read(2) on /dev/random
    Michael Kerrisk  [Mathieu Malaterre]
        Since Linux 3.16, reads from /dev/urandom return at most 32 MB
            See https://bugs.debian.org/775328 and
            https://bugzilla.kernel.org/show_bug.cgi?id=80981#c9

core.5
    Michael Kerrisk  [Bill McConnaughey]
        Executing a file that has capabilities also prevents core dumps
    Michael Kerrisk
        Document "%i" and "%I" core_pattern specifiers

intro.5
    Michael Kerrisk
        Remove words "and protocols"
            There are no protocol descriptions in Section 5. Protocols are
            in Section 7.

proc.5
    Michael Kerrisk
        Add reference to prctl(2) in discussion of /proc/sys/fs/suid_dumpable
            And note that /proc/sys/fs/suid_dumpable defines the
            value assigned to the process "dumpable" flag in certain
            circumstances.
    Michael Kerrisk
        Note that CAP_SYS_ADMIN is required to list /proc/PID/map_files
            This might however change in the future; see the Jan 2015 LKML thread:

                    Re: [RFC][PATCH v2] procfs: Always expose /proc/<pid>/map_files/
                                        and make it readable

resolv.conf.5
    Michael Kerrisk
        SEE ALSO: add nsswitch.conf(5)

capabilities.7
    Michael Kerrisk
        Mention SECBIT_KEEP_CAPS as an alternative to prctl() PR_SET_KEEPCAPS
    Chris Mayo
        NOTES: add last kernel versions for obsolete options
            The CONFIG_SECURITY_CAPABILITIES option was removed by
            commit 5915eb53861c5776cfec33ca4fcc1fd20d66dd27

            The CONFIG_SECURITY_FILE_CAPABILITIES option removed in
            Linux 2.6.33 as already mentioned in DESCRIPTION.

pthreads.7
    Michael Kerrisk
        SEE ALSO: add fork(2)

unix.7
    Jan Chaloupka
        Mention SOCK_STREAM socket for ioctl_type of ioctl()
            from https://bugzilla.redhat.com/show_bug.cgi?id=1110401.

            unix.7 is not clear about socket type of ioctl_type argument of
            ioctl() function. The description of SIOCINQ is applicable only
            for SOCK_STREAM socket. For SOCK_DGRAM, udp(7) man page gives
            correct description of SIOCINQ

ldconfig.8
    Michael Kerrisk
        Place options in alphabetical order
    Michael Kerrisk
        Note glibc version number for '-l' option
    Michael Kerrisk
        Document -c/--format option
    Michael Kerrisk
        Add long form of some options
    Michael Kerrisk  [Patrick Horgan]
        ld.so.conf uses only newlines as delimiters
            mtk: confirmed by reading source of parse_conf() in
            elf/ldconfig.c.
    Michael Kerrisk
        Document -V/--version option
    Michael Kerrisk
        Document -i/--ignore-aux-cache option

ld.so.8
    Michael Kerrisk
        Relocate "Hardware capabilities" to be a subsection under notes
            This is more consistent with standard man-pages headings
            and layout.
    Michael Kerrisk
        (Briefly) document LD_TRACE_PRELINKING
    Michael Kerrisk
        Remove duplicate description of LD_BIND_NOT


==================== Changes in man-pages-3.81 ====================

Released: 2015-03-02, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alexandre Oliva <aoliva@redhat.com>
Carlos O'Donell <carlos@redhat.com>
Ma Shimiao <mashimiao.fnst@cn.fujitsu.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Peng Haitao <penght@cn.fujitsu.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

attributes.7
    Alexandre Oliva, Michael Kerrisk  [Carlos O'Donell]
        New page describing POSIX safety concepts


Global changes
--------------

Many pages
    Peng Haitao, Michael Kerrisk
        Reformat existing thread-safety information to use a
        tabular format, rather than plain text.


Changes to individual pages
---------------------------

mmap.2
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function mmap() and munmap() are thread safe.

a64l.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

acos.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function acos(), acosf() and acosl() are thread safe.

acosh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function acosh(), acoshf() and acoshl() are thread safe.

addseverity.3
    Ma Shimiao
        ATTRIBUTES: Note function is thread-safe
            The function addseverity() is thread safe.

aio_cancel.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function aio_cancel() is thread safe.

aio_fsync.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function aio_fsync() is thread safe.

aio_read.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function aio_read() is thread safe.

aio_suspend.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function aio_suspend() is thread safe.

aio_write.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function aio_write() is thread safe.

argz_add.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe

asin.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function asin(), asinf() and asinl() are thread safe.

assert.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            Its marking matches glibc marking.

assert_perror.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            Its marking matches glibc marking.

atan2.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function atan2(), atan2f() and atan2l() are thread safe.

atanh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function atanh(), atanhf() and atanhl() are thread safe.

backtrace.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The markings match glibc markings.

btowc.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function btowc() in glibc is thread safe.
            Its marking matches glibc marking.

cabs.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function cabs(), cabsf() and cabsl() are thread safe.

cacos.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function cacos(), cacosf() and cacosl() are thread safe.

cacosh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions cacosh(), cacoshf() and cacoshl() in glibc are
            thread safe.  Its markings match glibc markings.

canonicalize_file_name.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The functions canonicalize_file_name() in glibc is thread safe.
            Its marking matches glibc marking.

carg.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function carg(), cargf() and cargl() are thread safe.

casin.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions casin(), casinf() and casinl() are thread safe.
            Their markings match glibc markings.

casinh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions casinh(), casinhf() and casinhl() in glibc are
            thread safe.  Its markings match glibc markings.

catan.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions catan(), catanf() and catanl() are thread safe.
            Their markings match glibc markings.

catanh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions catanh(), catanhf() and catanhl() in glibc are
            thread safe.  Its markings match glibc markings.

catopen.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions catopen() and catclose() are thread safe.

cfree.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function cfree() in glibc is thread safe.
            Its marking matches glibc marking.

clog10.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions clog10(), clog10f() and clog10l() in glibc are
            thread safe.  Its markings match glibc markings.

clog.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function clog(), clogf() and clogl() are thread safe.

closedir.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function closedir() in glibc is thread safe.
            Its marking matches glibc marking.

confstr.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function confstr() is thread safe.

cosh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions cosh(), coshf() and coshl() in glibc are thread safe.
            Its markings match glibc markings.

cpow.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions cpow(), cpowf() and cpowl() in glibc are thread safe.
            Its markings match glibc markings.

crypt.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

ctermid.3
    Ma Shimiao
        Modify thread-safety information
            According to the change of source code, ctermid's level has been
            changed from MT-Unsafe to MT-Safe.  After modifying, the marking
            matches the glibc marking.

drand48.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

drand48_r.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

ecvt.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be same as glibc manual.

ecvt_r.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The markings match glibc markings.

encrypt.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

envz_add.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

exec.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions execl(), execlp(), execle(), execv(), execvp() and
            execvpe() are thread safe.

exit.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

exp10.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe

exp2.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function exp2(), exp2f() and exp2l() are thread safe.

exp.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function exp(), expf() and expl() are thread safe.

fclose.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The function fclose() is thread safe.
            Its marking matches glibc marking.

fcloseall.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

fgetc.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

fgetwc.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

fgetws.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

fmod.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function fmod(), fmodf() and fmodl() are thread safe.

fnmatch.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function fnmatch() is thread safe with exceptions.

fopen.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The markings match glibc markings.

fopencookie.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

fread.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions fread() and fwrite() are thread safe.

gamma.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions gamma(), gammaf() and gammal() are not thread safe.
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getcontext.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getcwd.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions getcwd(), getwd() and get_current_dir_name() are
            thread safe.

getdate.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getenv.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions getenv() and secure_getenv() are thread safe.

getfsent.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions setfsent(), getfsent(), endfsent(), getfsspec()
            and getfsfile() are not thread safe.
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getgrent.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            Its marking matches glibc marking.
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getgrnam.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getgrouplist.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function getgrouplist() is thread safe with exceptions.

getlogin.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getopt.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions getopt(), getopt_long() and getopt_long_only() are
            not thread safe.
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getpass.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getpwent.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

getpwnam.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

gets.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            Its marking matches glibc marking.

getw.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions getw() and putw() are thread safe.

gnu_get_libc_version.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions gnu_get_libc_version() and gnu_get_libc_release()
            are thread safe.

hsearch.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

iconv.3
    Peng Haitao
        Modify thread-safety information

inet.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions inet_aton() and inet_addr() are thread safe with
            exceptions.
            The functions inet_network(), inet_ntoa(), inet_makeaddr(),
            inet_lnaof() and inet_netof() are thread safe.
        Modify thread-safety information
            After researching and talking, we think inet_network() and
            inet_ntoa() should be marked with locale.
            After changing, the markings match glbc markings.

inet_pton.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function inet_pton() is thread safe with exceptions.

iswdigit.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswdigit() is thread safe with exceptions.

iswgraph.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswgraph() is thread safe with exceptions.

iswlower.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswlower() is thread safe with exceptions.

iswprint.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswprint() is thread safe with exceptions.

iswpunct.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswpunct() is thread safe with exceptions.

iswspace.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswspace() is thread safe with exceptions.

iswupper.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswupper() is thread safe with exceptions.

iswxdigit.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function iswxdigit() is thread safe with exceptions.

j0.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function j0(), j1f() jnl() and so on are thread safe.

lio_listio.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            Its marking matches glibc marking.

log10.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function log10(), log10f() and log10l() are thread safe.

log2.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function log2(), log2f() and log2l() are thread safe.

log.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function log(), logf() and logl() are thread safe.

makecontext.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

makedev.3
    Peng Haitao
        ATTRIBUTES: Note macros that are thread-safe
            The macros makedev(), major() and minor() are thread safe.

malloc.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function malloc(), free(), calloc() and realloc() are
            thread safe.

mblen.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

mbstowcs.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

mbtowc.3
    Peng Haitao
        ATTRIBUTES: Note function that is not thread-safe
            The function mbtowc() is not thread safe.
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

mktemp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function mktemp() is thread safe.

mtrace.3
    Peng Haitao
        ATTRIBUTES: Note functions that are not thread-safe
            The functions mtrace() and muntrace() are not thread safe.

nan.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

nl_langinfo.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function nl_langinfo() is thread safe with exceptions.

opendir.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The markings match glibc markings.

pow10.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function pow10(), pow10f() and pow10l() are thread safe.

pow.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function pow(), powf() and powl() are thread safe.

pthread_setcancelstate.3
    Michael Kerrisk
        Add async-signal-safety information

ptsname.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

putenv.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-unsafe
            The function putenv() is thread unsafe.

puts.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread-safe
            The functions fputc(), fputs(), putc(), putchar() and puts() are
            thread safe.

putwchar.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

qecvt.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be same as glibc manual.

rand.3
    Peng Haitao
        ATTRIBUTES: Note macros that are thread-safe
            The functions rand(), rand_r() and srand() are thread safe.

random_r.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

readdir.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be same as glibc manual.

realpath.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

regex.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions regcomp() and regexec() are thread safe with
            exceptions.
            The functions regerror() and regfree() are thread safe.

remainder.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The markings match glibc markings.

scalb.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function scalb(), scalbf() and scalbl() are thread safe.

setenv.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-unsafe
            The function setenv() and unsetenv() are thread unsafe.

siginterrupt.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

sigset.3
    Peng Haitao
        ATTRIBUTES: Note macros that are thread-safe
            The functions sigset(), sighold(), sigrelse() and sigignore()
            are thread safe.

sinh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function sinh(), sinhf() and sinhl() are thread safe.

sqrt.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function sqrt(), sqrtf() and sqrtl() are thread safe.

stdarg.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

stdio_ext.3
    Ma Shimiao
        Modify thread-safety information
            Change the thread safety information to be the same as glibc.

strcasecmp.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions strcasecmp() and strncasecmp() are thread safe
            with exceptions.

strerror.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

strfmon.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            Its marking matches glibc marking.

strfry.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function strfry() is thread safe.

strftime.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function strftime() is thread safe with exceptions.

strptime.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function strptime() is thread safe with exceptions.

strtok.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

strverscmp.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function strverscmp() is thread safe.

strxfrm.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

syslog.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions openlog() and closelog() are thread safe.
            The functions syslog() and vsyslog() are thread safe with
            exceptions.

tempnam.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread-safe
            The function tempnam() is thread safe.

termios.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.
    Ma Shimiao
        Modify thread-safety information
            As this is man page for Linux, we don't need thread safety
            information for bsd

tgamma.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions tgamma(), tgammaf() and tgammal() in glibc are
            thread safe.  Its markings match glibc markings.

timegm.3
    Peng Haitao
        ATTRIBUTES: Note functions that are thread safe with exceptions
            The functions timelocal() and timegm() are thread safe with
            exceptions.

tmpfile.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            Its markings match glibc markings.

tmpnam.3
    Peng Haitao
        Modify thread-safety information
            When the argument s is NULL, tmpnam() should be MT-Unsafe.

toupper.3
    Ma Shimiao
        Modify thread-safety information
            After researching and talking, we think toupper() and tolower()
            should not be marked with locale.
            After changing, the markings match glbc markings.

tsearch.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The functions' markings match glibc markings.

ttyname.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be same as glibc manual.

tzset.3
    Peng Haitao
        ATTRIBUTES: Note function that is thread safe with exceptions
            The function tzset() is thread safe with exceptions.

wcsdup.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            Its marking matches glibc marking.

wctomb.3
    Ma Shimiao
        Modify thread-safety information
            As annotation in glibc manual is more detailed, change the
            thread-safety information to be the same as glibc manual.

y0.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The function y0(), y1f() ynl() and so on are thread safe.

man-pages.7
    Michael Kerrisk
        Refer reader to attributes(7) for details of ATTRIBUTES section
    Michael Kerrisk
        SEE ALSO: add attributes(7)

pthreads.7
    Michael Kerrisk
        SEE ALSO: add attributes(7)

standards.7
    Michael Kerrisk
        SEE ALSO: add attributes(7)



==================== Changes in man-pages-3.82 ====================

Released: 2015-03-29, Paris

Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alban Crequy <alban.crequy@gmail.com>
Andy Lutomirski <luto@amacapital.net>
Bert Wesarg <bert.wesarg@googlemail.com>
Bill Pemberton <wfp5p@worldbroken.com>
Chris Delozier <c.s.delozier@gmail.com>
David Madore <david.madore@ens.fr>
Dmitry Deshevoy <mityada@gmail.com>
Eric W. Biederman <ebiederm@xmission.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Jakub Wilk <jwilk@debian.org>
Jann Horn <jann@thejh.net>
Jason Vas Dias <jason.vas.dias@gmail.com>
Josh Triplett <josh@joshtriplett.org>
J William Piggott <elseifthen@gmx.com>
Kees Cook <keescook@chromium.org>
Konstantin Shemyak <konstantin@shemyak.com>
Ma Shimiao <mashimiao.fnst@cn.fujitsu.com>
Matt Turner <mattst88@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Michael Witten <mfwitten@gmail.com>
Mikael Pettersson <mikpelinux@gmail.com>
Namhyung Kim <namhyung@gmail.com>
Nicolas FRANCOIS <nicolas.francois@centraliens.net>
Paul E Condon <pecondon@mesanetworks.net>
Peter Adkins <peter.adkins@kernelpicnic.net>
Scot Doyle <lkml14@scotdoyle.com>
Shawn Landden <shawn@churchofgit.com>
Stéphane Aulery <saulery@free.fr>
Stephen Smalley <sds@tycho.nsa.gov>
Taisuke Yamada <tai@rakugaki.org>
Torvald Riegel <triegel@redhat.com>
Vincent Lefevre <vincent@vinc17.net>
<ygrex@ygrex.ru>
Yuri Kozlov <yuray@komyakino.ru>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

nptl.7
    Michael Kerrisk
        New page with details of the NPTL POSIX threads implementation


Newly documented interfaces in existing pages
---------------------------------------------

user_namespaces.7
    Eric W. Biederman  [Michael Kerrisk]
        Document /proc/[pid]/setgroups


Changes to individual pages
---------------------------

intro.1
    Stéphane Aulery
        Prompt is not % but $
    Stéphane Aulery
        Various improvements
            - Add reference to other common shells dash(1), ksh(1)
            - Add a reference to stdout(3)
            - Separate cp and mv descriptions
            - Add examples of special cases of cd
            - Add su(1) and shutdown(8) references for section Logout
              and poweroff
            - Move Control-D to section Logout and poweroff
            - Fix some little formatting errors
    Stéphane Aulery
        Add cross references cited
    Stéphane Aulery
        Order SEE ALSO section

clone.2
    Josh Triplett
        Document that clone() silently ignores CLONE_PID and CLONE_STOPPED
            Normally, system calls return EINVAL for flags they don't support.
            Explicitly document that clone does *not* produce an error for
            these two obsolete flags.
    Michael Kerrisk
        Small rewording of explanation of clone() wrt threads
            Clone has so many effects that it's an oversimplification to say
            that the *main* use of clone is to create a thread.  (In fact,
            the use of clone() to create new processes may well be more
            common, since glibc's fork() is a wrapper that calls clone().)

getgroups.2
    Michael Kerrisk  [Shawn Landden]
        Add discussion of NPTL credential-changing mechanism
            At the kernel level, credentials (UIDs and GIDs) are a per-thread
            attribute. NPTL uses a signal-based mechanism to ensure that
            when one thread changes its credentials, all other threads change
            credentials to the same values. By this means, the NPTL
            implementation conforms to the POSIX requirement that the threads
            in a process share credentials.
    Michael Kerrisk
        ERRORS: add EPERM for the case where /proc/PID/setgroups is "deny"
    Michael Kerrisk
        Note capability associated with EPERM error for setgroups(2)
    Michael Kerrisk
        Refer reader to user_namespaces(7) for discussion of /proc/PID/setgroups
            The discussion of /proc/PID/setgroups has moved from
            proc(5) to user_namespaces(7).

getpid.2
    Michael Kerrisk
        Note that getppid() returns 0 if parent is in different PID namespace

getsockopt.2
    Konstantin Shemyak
        Note RETURN VALUE details when netfilter is involved

ioctl_list.2
    Heinrich Schuchardt
        SEE ALSO ioctl_fat.2
            Add FAT_IOCTL_GET_VOLUME_ID
            SEE ALSO ioctl_fat.2
    Heinrich Schuchardt
        include/linux/ext2_fs.h
            Include linux/ext2_fs.h does not contain any ioctl definitions
            anymore.

            Request codes EXT2_IOC* have been replaced by FS_IOC* in
            linux/fs.h.

            Some definitions of FS_IOC_* use long* but the actual code expects
            int* (see fs/ext2/ioctl.c).

msgop.2
    Bill Pemberton
        Remove EAGAIN as msgrcv() errno
            The list of errnos for msgrcv() lists both EAGAIN and ENOMSG as
            the errno for no message available with the IPC_NOWAIT flag.
            ENOMSG is the errno that will be set.
    Bill Pemberton
        Add an example program

open.2
    Michael Kerrisk  [Jason Vas Dias]
        Mention blocking semantics for FIFO opens
            See https://bugzilla.kernel.org/show_bug.cgi?id=95191

seccomp.2
    Jann Horn  [Kees Cook, Mikael Pettersson, Andy Lutomirski]
        Add note about alarm(2) not being sufficient to limit runtime
    Jann Horn
        Explain blacklisting problems, expand example
    Michael Kerrisk  [Kees Cook]
        Add mention of libseccomp

setgid.2
    Michael Kerrisk
        Clarify that setgid() changes all GIDs when caller has CAP_SETGID
    Michael Kerrisk  [Shawn Landden]
        Add discussion of NPTL credential-changing mechanism
            At the kernel level, credentials (UIDs and GIDs) are a per-thread
            attribute. NPTL uses a signal-based mechanism to ensure that
            when one thread changes its credentials, all other threads change
            credentials to the same values. By this means, the NPTL
            implementation conforms to the POSIX requirement that the threads
            in a process share credentials.

setresuid.2
    Michael Kerrisk  [Shawn Landden]
        Add discussion of NPTL credential-changing mechanism
            At the kernel level, credentials (UIDs and GIDs) are a per-thread
            attribute. NPTL uses a signal-based mechanism to ensure that
            when one thread changes its credentials, all other threads change
            credentials to the same values. By this means, the NPTL
            implementation conforms to the POSIX requirement that the threads
            in a process share credentials.

setreuid.2
    Michael Kerrisk  [Shawn Landden]
        Add discussion of NPTL credential-changing mechanism
            At the kernel level, credentials (UIDs and GIDs) are a per-thread
            attribute. NPTL uses a signal-based mechanism to ensure that
            when one thread changes its credentials, all other threads change
            credentials to the same values. By this means, the NPTL
            implementation conforms to the POSIX requirement that the threads
            in a process share credentials.
    Michael Kerrisk
        SEE ALSO: add credentials(7)

setuid.2
    Michael Kerrisk
        Clarify that setuid() changes all UIDs when caller has CAP_SETUID
    Michael Kerrisk  [Shawn Landden]
        Add discussion of NPTL credential-changing mechanism
            At the kernel level, credentials (UIDs and GIDs) are a per-thread
            attribute. NPTL uses a signal-based mechanism to ensure that
            when one thread changes its credentials, all other threads change
            credentials to the same values. By this means, the NPTL
            implementation conforms to the POSIX requirement that the threads
            in a process share credentials.

sigaction.2
    Michael Kerrisk
        Add discussion of rt_sigaction(2)
    Michael Kerrisk
        Note treatment of signals used internally by NPTL
            The glibc wrapper gives an EINVAL error on attempts to change the
            disposition of either of the two real-time signals used by NPTL.

sigpending.2
    Michael Kerrisk
        Add discussion of rt_sigpending(2)

sigprocmask.2
    Michael Kerrisk
        Add discussion of rt_sigprocmask(2)
    Michael Kerrisk
        Note treatment of signals used internally by NPTL
            The glibc wrapper silently ignores attempts to block the two
            real-time signals used by NPTL.

sigreturn.2
    Michael Kerrisk
        Add discussion of rt_sigreturn(2)

sigsuspend.2
    Michael Kerrisk
        Add discussion of rt_sigsuspend(2)

sigwaitinfo.2
    Michael Kerrisk
        Note treatment of signals used internally by NPTL
            The glibc wrappers silently ignore attempts to wait for
            signals used by NPTL.
    Michael Kerrisk
        Add discussion of rt_sigtimedwait(2)

socket.2
    Heinrich Schuchardt
        SEE ALSO close(2)
            The description mentions close(2). Hence it should also be
            referenced in the SEE ALSO section.

syscall.2
    Jann Horn
        Add x32 ABI

umount.2
    Eric W. Biederman
        Document the effect of shared subtrees on umount(2)
    Eric W. Biederman
        Correct the description of MNT_DETACH
            I recently realized that I had been reasoning improperly about
            what umount(MNT_DETACH) did based on an insufficient description
            in the umount.2 man page, that matched my intuition but not the
            implementation.

            When there are no submounts, MNT_DETACH is essentially harmless to
            applications.  Where there are submounts, MNT_DETACH changes what
            is visible to applications using the detach directories.
    Michael Kerrisk
        Move "shared mount + umount" text to a subsection in NOTES

aio_return.3
    Stéphane Aulery
        Document the return value on error
            Reported by Alexander Holler <holler@ahsoftware.de>

clock.3
    Stéphane Aulery
        CLOCKS_PER_SEC = 1000000 is required by XSI, not POSIX
            Debian Bug #728213 reported by Tanaka Akira <akr@fsij.org>

            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=728213

dlopen.3
    Michael Kerrisk
        Amend error in description of dlclose() behavior
            The current text says that unloading depends on whether
            the reference count falls to zero *and no other libraries
            are using symbols in this library*. That latter text has
            been there since man-pages-1.29, but it seems rather dubious.
            How could the implementation know whether other libraries
            are still using symbols in this library? Furthermore, no
            other implementation's man page mentions this point.
            Seems best to drop this point.
    Michael Kerrisk
        Add some details for RTLD_DEFAULT
    Michael Kerrisk
        Add some details on RTLD_NEXT and preloading
    Michael Kerrisk
        RTLD_NEXT works for symbols generally, not just functions
            The common use case is for functions, but RTLD_NEXT
            also applies to variable symbols.
    Michael Kerrisk
        dlclose() recursively closes dependent libraries
            Note that dlclose() recursively closes dependent libraries
            that were loaded by dlopen()
    Michael Kerrisk
        Rename second dlopen() argument from "flag" to "flags"
            This is more consistent with other such arguments
    Michael Kerrisk
        Reformat text on RTLD_DEFAULT and RTLD_NEXT

fmemopen.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

fpathconf.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The marking matches glibc marking.

fputwc.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The marking matches glibc marking.

fputws.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

fseek.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

fseeko.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

gcvt.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

getline.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The marking matches glibc marking.

getwchar.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

hypot.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

iconv_open.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

if_nameindex.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The markings match glibc markings.

initgroups.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The markings match glibc markings.

mq_open.3
    Torvald Riegel
        Add EINVAL error case for invalid name
            This behavior is implementation-defined by POSIX.  If the name
            doesn't start with a '/', glibc returns EINVAL without attempting
            the syscall.

popen.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The marking matches glibc marking.

pthread_kill.3
    Michael Kerrisk
        Note treatment of signals used internally by NPTL
            The glibc pthread_kill() function gives an error on attempts
            to send either of the real-time signals used by NPTL.

pthread_sigmask.3
    Michael Kerrisk
        Note treatment of signals used internally by NPTL
            The glibc implementation silently ignores attempts to block the two
            real-time signals used by NPTL.

pthread_sigqueue.3
    Michael Kerrisk
        Note treatment of signals used internally by NPTL
            The glibc pthread_sigqueue() function gives an error on attempts
            to send either of the real-time signals used by NPTL.

resolver.3
    Stéphane Aulery  [Jakub Wilk]
        Document missing options used by _res structure indicate defaults
            Missing options: RES_INSECURE1, RES_INSECURE2, RES_NOALIASES,
            USE_INET6, ROTATE, NOCHECKNAME, RES_KEEPTSIG, BLAST, USEBSTRING,
            NOIP6DOTINT, USE_EDNS0, SNGLKUP, SNGLKUPREOP, RES_USE_DNSSEC,
            NOTLDQUERY, DEFAULT

            Written from the glibc source and resolv.conf.5.

            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=527136
    Stéphane Aulery
        RES_IGNTC is implemented

rint.3
    Matt Turner
        Document that halfway cases are rounded to even
            Per IEEE-754 rounding rules.

            The round(3) page describes the behavior of rint and nearbyint
            in the halfway cases by saying:

                These functions round x to the nearest integer, but round
                halfway cases away from zero [...], instead of to the
                nearest even integer like rint(3)

sigqueue.3
    Michael Kerrisk
        NOTES: add "C library/kernel ABI differences" subheading
    Michael Kerrisk
        Clarify version info (mention rt_sigqueueinfo())

sigsetops.3
    Michael Kerrisk
        Note treatment of signals used internally by NPTL
            The glibc sigfillset() function excludes the two real-time
            signals used by NPTL.

sigwait.3
    Michael Kerrisk
        Note treatment of signals used internally by NPTL
            The glibc sigwait() silently ignore attempts to wait for
            signals used by NPTL.

strcoll.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The markings match glibc markings.

strdup.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
            The marking matches glibc marking.

tzset.3
    J William Piggott
        Add 'std' quoting information

ulimit.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

wcstombs.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

wctob.3
    Ma Shimiao
        ATTRIBUTES: Note function that is thread-safe
            The marking matches glibc marking.

xdr.3
    Taisuke Yamada
        Clarified incompatibility and correct usage of XDR API
            See http://bugs.debian.org/628099

console_codes.4
    Scot Doyle
        Add Console Private CSI sequence 15
            An undocumented escape sequence in drivers/tty/vt/vt.c brings the
            previously accessed virtual terminal to the foreground.
            mtk: Patch misattributed to Taisuke Yamada in Git commit
            because of a muck up on my part.
    Michael Kerrisk
        Add kernel version number for CSI sequence 15

random.4
    Michael Kerrisk
        Fix permissions shown for the devices
            These days, the devices are RW for everyone.

filesystems.5
    Michael Kerrisk
        Remove dubious claim about comparative performance of ext2
            Perhaps it was the best filesystem performance-wise in
            the 20th century, when that text was written. That probably
            ceased to be true quite a long time ago, though.
    Stéphane Aulery
        Add cross references for ext filesystems
    Stéphane Aulery
        Specifies the scope of this list and its limits.

host.conf.5
hosts.5
resolv.conf.5
    Stéphane Aulery  [Paul E Condon]
        Cross references of these pages.
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=298259

host.conf.5
    Stéphane Aulery
        Rework discussion of nospoof, spoofalert, spoof and RESOLV_SPOOF_CHECK
            The keywords and environment variables "nospoof", "spoofalert",
            "spoof" and RESOLV_SPOOF_CHECK were added to glibc 2.0.7 but
            never implemented

            Move descriptions to historical section and reorder it for clarity

            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=773443

hosts.5
    Stéphane Aulery  [Vincent Lefevre]
        Mention 127.0.1.1 for FQDN and IPv6 examples
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=562890

proc.5
    Taisuke Yamada
        Document /proc/PID/status VmPin field
            See https://bugs.launchpad.net/bugs/1071746
    Michael Kerrisk
        Document (the obsolete) /proc/PID/seccomp
    Michael Kerrisk
        Replace description of 'uid_map' with a reference to user_namespaces(7)
            All of the information in proc(5) was also present in
            user_namespaces(7), but the latter was more detailed
            and up to date.
    Taisuke Yamada
        Fix SELinux /proc/pid/attr/current example
            Since the /proc/pid/attr API was added to the kernel, there
            have been a couple of changes to the SELinux handling of
            /proc/pid/attr/current.  Fix the SELinux /proc/pid/attr/current
            example text to reflect these changes and note which kernel
            versions first included the changes.

securetty.5
    Stéphane Aulery  [Nicolas FRANCOIS]
        Note that the pam_securetty module also uses this file
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=528015

            This patch is a modified version of the one proposed without
            parts specific to Debian.

boot.7
    Michael Witten
        Copy edit
            While a lot of the changes are issues of presentation,
            there are also issues of grammar and punctuation.
    Michael Witten
        Mention `systemd(1)' and its related `bootup(7)'
            It's important that the reader receive contemporary information.

credentials.7
    Michael Kerrisk
        SEE ALSO: add pthreads(7)
    Michael Kerrisk
        Add reference to nptl(7)

feature_test_macros.7
    Michael Kerrisk
        Update discussion of _FORTIFY_SOURCE
            Since the initial implementation a lot more checks were added.
            Describe all the checks would be too verbose (and would soon
            fall out of date as more checks are added). So instead, describe
            the kinds of checks that are done more generally.
            Also a few other minor edits to the text.

hier.7
    Stéphane Aulery
        First patch of a series to achieve compliance with FHS 2.3
    Stéphane Aulery
        SGML and XML directories are separated in FHS 2.3
    Stéphane Aulery
        Add missing directories defined by FHS 2.3
    Stéphane Aulery
        Identify which directories are optional
    Stéphane Aulery
        Document /initrd, /lost+found and /sys
            Ubuntu Bug #70094 reported by Brian Beck
            https://bugs.launchpad.net/ubuntu/+source/manpages/+bug/70094
    Stéphane Aulery
        Explain YP, which is not obvious

ipv6.7
    Stéphane Aulery  [David Madore]
        SOL_IPV6 and other SOL_* options socket are not portable
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=472447

man-pages.7
    Michael Kerrisk  [Bill Pemberton]
        Add indent(1) command that produces desired formatting for example code
    Stéphane Aulery
        Improve description of sections in accordance with intro pages

packet.7
    Michael Kerrisk
        Rework description of fanout algorithms as list
    Michael Kerrisk
        Remove mention of needing UID 0 to create packet socket
            The existing text makes no sense. The check is based
            purely on a capability check. (Kernel function
            net/packet/af_packet.c::packet_create()
    Michael Kerrisk
        Remove text about ancient glibc not defining SOL_PACKET
            This was fixed in glibc 2.1.1, which is a long while ago.
            And in any case, there is nothing special about this case;
            it's just one of those times when glibc lags.
    Michael Kerrisk
        Rework description of 'sockaddr_ll' fields as a list
    Michael Kerrisk
        Various minor edits

pthreads.7
    Michael Kerrisk
        Add references to nptl(7)

raw.7
    Michael Kerrisk
        Rephrase "Linux 2.2" language to "Linux 2.2 or later"
            The man page was written in the LInux 2.2 timeframe, and
            some phrasing was not future-proof.

signal.7
    Michael Kerrisk
        Note when Linux added realtime signals
    Michael Kerrisk
        Correct the range of realtime signals
    Michael Kerrisk
        Summarize 2.2 system call changes that resulted from larger signal sets
    Michael Kerrisk
        SEE ALSO: add nptl(7)

tcp.7
    Peter Adkins
        Document removal of TCP_SYNQ_HSIZE
            Looking over the man page for 'tcp' I came across a reference to
            tuning the 'TCP_SYNQ_HSIZE' parameter when increasing
            'tcp_max_syn_backlog' above 1024. However, this static sizing was
            removed back in Linux 2.6.20 in favor of dynamic scaling - as
            part of commit 72a3effaf633bcae9034b7e176bdbd78d64a71db.

user_namespaces.7
    Eric W. Biederman
        Update the documentation to reflect the fixes for negative groups
            Files with access permissions such as rwx---rwx give fewer
            permissions to their group then they do to everyone else.  Which
            means dropping groups with setgroups(0, NULL) actually grants a
            process privileges.

            The unprivileged setting of gid_map turned out not to be safe
            after this change.  Privileged setting of gid_map can be
            interpreted as meaning yes it is ok to drop groups. [ Eric
            additionally noted: Setting of gid_map with privilege has been
            clarified to mean that dropping groups is ok.  This allows
            existing programs that set gid_map with privilege to work
            without changes.  That is, newgidmap(1) continues to work
            unchanged.]

            To prevent this problem and future problems, user namespaces were
            changed in such a way as to guarantee a user can not obtain
            credentials without privilege that they could not obtain without
            the help of user namespaces.

            This meant testing the effective user ID and not the filesystem
            user ID, as setresuid(2) and setregid(2) allow setting any process
            UID or GID (except the supplementary groups) to the effective ID.

            Furthermore, to preserve in some form the useful applications
            that have been setting gid_map without privilege, the file
            /proc/[pid]/setgroups was added to allow disabling setgroups(2).
            With setgroups(2) permanently disabled in a user namespace, it
            again becomes safe to allow writes to gid_map without privilege.
    Michael Kerrisk
        Rework some text describing permission rules for updating map files
            No (intentional) change to the facts, but this restructuring
            should make the meaning easier to grasp.
    Michael Kerrisk
        Update kernel version associated with 5-line limit for map files
            As at Linux 3.18, the limit is still five lines, so mention the
            more recent kernel version in the text.
    Michael Kerrisk  [Alban Crequy]
        Handle /proc/PID/setgroups in the example program
    Michael Kerrisk
        Rework text describing restrictions on updating /proc/PID/setgroups
            No (intentional) changes to factual description, but the
            restructured text is hopefully easier to grasp.
    Michael Kerrisk
        Explain why the /proc/PID/setgroups file was added

ldconfig.8
    Michael Kerrisk
        Note use of /lib64 and /usr/lib64 on some 64-bit architectures

ld.so.8
    Michael Kerrisk
        Note the use of /lib64 and /usr/lib64 on some 64-bit architectures



==================== Changes in man-pages-3.83 ====================

Released: 2015-04-19, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Andreas Baak <andreas.baak@gmail.com>
Andreas Dilger <adilger@dilger.ca>
cdlscpmv <cdlscpmv@gmail.com>
Cyrill Gorcunov <gorcunov@openvz.org>
Darrick J. Wong <darrick.wong@oracle.com>
David Rientjes <rientjes@google.com>
Dima Tisnek <dimaqq@gmail.com>
Eric Sandeen <sandeen@redhat.com>
Fabien Pichot <fpichot@bouledef.eu>
Felix Sedlmeier <sedlmeier@gmx.de>
Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Jann Horn <jann@thejh.net>
Jon Grant <jg@jguk.org>
Jonny Grant <jg@jguk.org>
Kees Cook <keescook@chromium.org>
Masanari Iida <standby24x7@gmail.com>
Ma Shimiao <mashimiao.fnst@cn.fujitsu.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Nikos Mavrogiannopoulos <nmav@gnutls.org>
Omar Sandoval <osandov@osandov.com>
Pierre Chifflier <pollux@debian.org>
Robin H. Johnson <robbat2@gentoo.org>
Rob Landley <rob@landley.net>
Theodore Ts'o <tytso@mit.edu>
Vlastimil Babka <vbabka@suse.cz>
Walter Harms <wharms@bfs.de>
William Woodruff <william@tuffbizz.com>
YOSHIFUJI Hideaki <hideaki.yoshifuji@miraclelinux.com>
Zeng Linggang <zenglg.jy@cn.fujitsu.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

posix_madvise.3
    Michael Kerrisk
        New page documenting posix_madvise(3)

ftw.3
    Michael Kerrisk
        Reorganize the page to give primacy to nftw()
            nftw() is the better API, and POSIX.1-2008 marks ftw() obsolete.

Newly documented interfaces in existing pages
---------------------------------------------

getdents.2
    Michael Kerrisk  [Dima Tisnek]
        Document getdents64()
            See https://bugzilla.kernel.org/show_bug.cgi?id=14795

mount.2
    Michael Kerrisk, Theodore Ts'o  [Eric Sandeen, Andreas Dilger,
    Omar Sandoval, Darrick J. Wong]
        Document MS_LAZYTIME

proc.5
    Michael Kerrisk
        Document /proc/sys/kernel/randomize_va_space
    Michael Kerrisk
        Document /proc/PID/fdinfo epoll format
    Michael Kerrisk
        Describe /proc/PID/fdinfo eventfd format
    Michael Kerrisk
        Document /proc/PID/fdinfo signalfd format


New and changed links
---------------------

newfstatat.2
    Michael Kerrisk
        New link to fstatat64.2

prlimit64.2
    Michael Kerrisk
        New link to getrlimit.2


Global changes
--------------

Various section 3 math pages
    Michael Kerrisk
        Note that these functions are also in POSIX.1-2001 and POSIX.1-2008


Changes to individual pages
---------------------------

getent.1
    Robin H. Johnson
        Document options
            The options to getent are now documented, after being around for
            nearly a decade without changes.
    Michael Kerrisk
        Document help and version options

fallocate.2
    Michael Kerrisk
        Fix kernel version number for FALLOC_FL_ZERO_RANGE
            FALLOC_FL_ZERO_RANGE was added in 3.15, not 3.14.
    Michael Kerrisk
        Note that SMB3 added FALLOC_FL_ZERO_RANGE support in Linux 3.17

getrlimit.2
    Michael Kerrisk
        Note that the underlying system call for prlimit() is prlimit64()
    Michael Kerrisk
        Remove "_FILE_OFFSET_BITS == 64" from prlimit() FTM requirements
            "_FILE_OFFSET_BITS == 64" is not needed to get the prlimit()
            declaration.

ioctl_list.2
    Nikos Mavrogiannopoulos
        SIOCADDRT accepts in6_rtmsg in INET6 protocol
    Heinrich Schuchardt
        TFD_IOC_SET_TICKS
            timerfd_create.2 mentions TFD_IOC_SET_TICKS. We should add it to
            ioctl_list.2, too.

llseek.2
    Michael Kerrisk
        Advise reader to use lseek(2) instead
    Michael Kerrisk
        llseek() exists on 32-bit platforms to support seeking to large offsets

madvise.2
    David Rientjes
        Specify MADV_REMOVE returns EINVAL for hugetlbfs
            madvise(2) actually returns with error EINVAL for MADV_REMOVE
            when used for hugetlb VMAs, not EOPNOTSUPP, and this has been
            the case since MADV_REMOVE was introduced in commit f6b3ec238d12
            ("madvise(MADV_REMOVE): remove pages from tmpfs shm backing
            store"). Specify the exact behavior.
    Michael Kerrisk
        SEE ALSO: add posix_madvise(2)

poll.2
    Michael Kerrisk  [Andreas Baak]
        SEE ALSO: add epoll(7)

posix_fadvise.2
    Michael Kerrisk
        Add "C library/kernel ABI differences" subsection

pread.2
    Michael Kerrisk
        Add "C library/kernel ABI differences" subsection

seccomp.2
    Michael Kerrisk  [Pierre Chifflier, Kees Cook]
        Note that seccomp_data is read-only

stat.2
    Michael Kerrisk
        Add some details on various "stat" versions
            Three versions of "stat" appeared on 32-bit systems,
            dealing with structures of different (increasing) sizes.
            Explain some of the details, and also note that the
            situation is simpler on modern 64-bit architectures.
    Michael Kerrisk
        Add mention of newfstatat()
            The underlying system call for fstatat() is newfstatat()
            on some architectures.

symlink.2
    Michael Kerrisk  [Jonny Grant]
        ERRORS: add linkpath=="" case for ENOENT

syscalls.2
    Michael Kerrisk
        Remove prlimit()
            There really is only the prlimit64() system call.
    Michael Kerrisk
        Add some details about the "multiple versions of system calls"
            The multiple-system-call-version phenomenon is particularly a
            feature of older 32-bit platforms. Hint at that fact in the text.

timerfd_create.2
    Cyrill Gorcunov  [Michael Kerrisk]
        Document TFD_IOC_SET_TICKS ioctl() operation
    Michael Kerrisk
        Add some details to C library/kernel ABI differences

unshare.2
    Michael Kerrisk  [Fabien Pichot]
        Remove mention of "System V" from discussion of CLONE_NEWIPC
            These days, CLONE_NEWIPC also affects POSIX message queues.

asprintf.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

carg.3
    Michael Kerrisk
        Add introductory sentence explaining what these functions calculate

ccos.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
    Michael Kerrisk
        Add introductory sentence explaining what these functions calculate

ccosh.3
    Michael Kerrisk
        Add introductory sentence explaining what these functions calculate

cexp.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe

clock.3
    Ma Shimiao
        ATTRIBUTES: Note functions that is thread-safe

clog.3
    Michael Kerrisk
        Add introductory sentence explaining what these functions calculate

csin.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
    Michael Kerrisk
        Add introductory sentence explaining what these functions calculate

csinh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
    Michael Kerrisk
        Add introductory sentence explaining what these functions calculate

csqrt.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
    Michael Kerrisk
        Simplify description of what  these functions calculate

ctan.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
    Michael Kerrisk
        Add introductory sentence explaining what these functions calculate

ctanh.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe
    Michael Kerrisk
        Add introductory sentence explaining what these functions calculate

ctime.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

exec.3
    Michael Kerrisk
        SYNOPSIS: Clarify calling signature for execl() and execlp()
    Michael Kerrisk  [Andreas Baak]
        Correct prototype for execle()
            Make the prototype shown into correct C.

ftw.3
    Michael Kerrisk  [Felix Sedlmeier]
        ftw() and nftw() differ for the non-stat-able symlink case
            The POSIX specification of ftw() says that an un-stat-able
            symlink may yield either FTW_NS or FTW_SL. The specification
            of nftw() does not carry this statement.
    Michael Kerrisk
        CONFORMING TO: add POSIX.1-2008
    Michael Kerrisk
        Update POSIX version references in NOTES

getcwd.3
    Jann Horn  [Michael Kerrisk]
        Note behavior for unreachable current working directory
    Michael Kerrisk
        Add ENOMEM error

gethostbyname.3
    Michael Kerrisk  [Jonny Grant]
        Clarify that NO_ADDRESS and NO_DATA are synonyms
    Michael Kerrisk
        Add some detail for NO_DATA
            Text consistent with POSIX and FreeBSD's gethostbyname() man page.
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

getnetent.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

get_nprocs_conf.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

getutent.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

glob.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

insque.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe

login.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

lseek64.3
    Michael Kerrisk
        Clarify details with respect to 32-bit and 64-bit systems

malloc.3
    Michael Kerrisk
        Add ENOMEM error

mbsnrtowcs.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

mbsrtowcs.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

mq_notify.3
    Michael Kerrisk
        Add "C library/kernel ABI differences" subsection

mq_open.3
    Michael Kerrisk  [Fabien Pichot]
        NOTES: explain differences from the underlying system call
            The check for the slash at the start of a pathname is done in glibc

openpty.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

perror.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

posix_memalign.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

printf.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe
    Walter Harms  [Michael Kerrisk]
        Simplify the example code

qsort.3
    Michael Kerrisk  [Rob Landley]
        alphasort() and versionsort() are not suitable for 'compar'
            In glibc 2.10, the prototypes of alphasort() and versionsort()
            were changed so that the arguments switched from 'const void *' to
            'const struct dirent **', to match the POSIX.1-2008 specification
            of alphasort(). As such, compiler warnings will result if
            these functions are used as the arguments of qsort().

                warning: passing argument 4 of 'qsort' from incompatible
                pointer type
                expected '__compar_fn_t' but argument is of type
                'int (*)(const struct dirent **, const struct dirent **)'

            Therefore, remove the ancient NOTES text suggesting that
            alphasort() and versionsort() can be used as suitable
            'compar' arguments for qsort().

realpath.3
    Michael Kerrisk  [Jon Grant]
        Add ENOMEM error

scandir.3
    Michael Kerrisk
        glibc 2.10 changed the argument types for alphasort() and versionsort()
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

scanf.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

setnetgrent.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

significand.3
    Ma Shimiao
        ATTRIBUTES: Note functions that are thread-safe

strcasecmp.3
    Michael Kerrisk  [Jonny Grant]
        Clarify that strcasecmp() does a byte-wise comparison
    Michael Kerrisk
        CONFORMING TO: add POSIX.1-2008

unlocked_stdio.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

updwtmp.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

wcrtomb.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

wcsnrtombs.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

wcsrtombs.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

wordexp.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

wprintf.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

proc.5
    Michael Kerrisk
        Describe "mnt_id" field of /proc/PID/fdinfo
    Michael Kerrisk
        Note that abstract sockets are included in /proc/net/unix
    Michael Kerrisk
        Update description /proc/sys/unix 'Type' field
            The existing text was very crufty. UNIX domain sockets
            support more than SOCK_STREAM for a _very_ long time now.
    Michael Kerrisk
        Add some detail to /proc/PID/timers
    Michael Kerrisk  [Vlastimil Babka]
        Enhance discussion of /proc/PID/status 'VmSwap' field

epoll.7
    Michael Kerrisk
        SEE ALSO: add poll(2) and select(2)

icmp.7
    YOSHIFUJI Hideaki/吉藤英明
        Document net.ipv4.ping_group_range knob

nptl.7
    Michael Kerrisk
        Add reference to timer_create(2)


==================== Changes in man-pages-4.00 ====================

Released: 2015-05-07, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Advait Dixi <advaitdixit@hotmail.com>
Alain Kalker <a.c.kalker@gmail.com>
Andi Kleen <andi@firstfloor.org>
Andreas Gruenbacher <agruenba@redhat.com>
Andreas Heiduk <asheiduk@googlemail.com>
Askar Safin <safinaskar@mail.ru>
Brice Goglin <Brice.Goglin@inria.fr>
Cameron Norman <camerontnorman@gmail.com>
Carlos O'Donell <carlos@redhat.com>
Chris Metcalf <cmetcalf@tilera.com>
Christophe Lohr <Christophe.Lohr@telecom-bretagne.eu>
Christopher Head <chead@chead.ca>
Christoph Hellwig <hch@infradead.org>
David Wilcox <davidvsthegiant@gmail.com>
Denis Du <denisdu@ruggedcom.com>
Egmont Koblinger <egmont@gmail.com>
Filipe Brandenburger <filbranden@gmail.com>
Filipus Klutiero <chealer@gmail.com>
Florian Weimer <fweimer@redhat.com>
Frédéric Maria <frederic.maria@free.fr>
Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org>
Graham Shaw <gdshaw@riscpkg.org>
Gregor Jasny <igjasny@googlemail.com>
Guillem Jover <guillem@hadrons.org>
Guy Harris <guy@alum.mit.edu>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Ian Pilcher <arequipeno@gmail.com>
Jann Horn <jann@thejh.net>
Jason Newton <nevion@gmail.com>
J. Bruce Fields <bfields@fieldses.org>
Jiri Pirko <jpirko@redhat.com>
Joachim Wuttke <j.wuttke@fz-juelich.de>
Joern Heissler <contact@joern.heissler.de>
Jonathan Nieder <jrnieder@gmail.com>
Joonas Salo <salo.joonas@gmail.com>
Jussi Lehtola <jussilehtola@fedoraproject.org>
Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Laurence Gonsalves <laurence@xenomachina.com>
Magnus REFTEL <magnus.xm.reftel@stericsson.com>
Michael Kerrisk <mtk.manpages@gmail.com>
NeilBrown <neilb@suse.de>
Regid Ichira <regid23@nt1.in>
Sam Varshavchik <mrsam@courier-mta.com>
Steinar H. Gunderson <sgunderson@bigfoot.com>
Stéphane Aulery <saulery@free.fr>
Stephane Fillod <fillods@users.sf.net>
Tetsuo Handa <from-linux-kernel@i-love.sakura.ne.jp>
Thomas Hood <jdthood@gmail.com>
Urs Thuermann <urs@isnogud.escape.de>
Vasiliy Kulikov <segooon@gmail.com>
Vegard Nossum <vegard.nossum@gmail.com>
Weijie Yang <weijie.yang@samsung.com>
William Woodruff <william@tuffbizz.com>
Zeng Linggang <zenglg.jy@cn.fujitsu.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

get_phys_pages.3
    William Woodruff
        Document get_phys_pages() and get_avphys_pages()

loop.4
    Urs Thuermann, Michael Kerrisk
        New page documenting the loop device

xattr.7
    Andreas Gruenbacher
        Import attr(5) man page from the 'attr' project
            After discussions with Andreas Gruenbacher, it makes sense to
            move this page into man-pages, since it mostly relates to
            kernel details. Since this is an overview page,
            we'll move it to Section 7.
    Michael Kerrisk
         Rename page
            "xattr" is a more meaningful name than "attr" (it resonates
            with the names of the system calls), so as long as we are
            moving the page to a new section, we'll change the name as well,
            and retain an acl(5) link so that old references remain valid.


Newly documented interfaces in existing pages
---------------------------------------------

mmap.2
    Michael Kerrisk  [Andi Kleen]
        Document MAP_HUGE_2MB, MAP_HUGE_1GB, and MAP_HUGE_SHIFT

shmget.2
    Michael Kerrisk  [Andi Kleen]
        Document SHM_HUGE_2MB, SHM_HUGE_1GB, and SHM_HUGE_SHIFT

resolver.3
    Michael Kerrisk  [Jonathan Nieder]
        Add descriptions of some other resolver functions
            Add res_ninit(), res_nquery(), res_nsearch(),
            and res_nquerydomain(), res_nmkquery(), res_nsend().

tty_ioctl.4
    Frédéric Maria  [Stephane Fillod, Andreas Heiduk]
        Document TIOCMIWAIT and TIOCGICOUNT
    Michael Kerrisk
        Document TIOCGEXCL
    Michael Kerrisk
        Document TIOGCPKT
    Michael Kerrisk
        Document TIOCSPTLCK
    Michael Kerrisk
        Document TIOCGPTLCK


New and changed links
---------------------

CMSG_DATA.3
    Michael Kerrisk
        New link to cmsg(3)

CMSG_LEN.3
    Michael Kerrisk
        New link to cmsg(3)

dprintf.3
    Michael Kerrisk
        Convert to a link to printf.3

get_avphys_pages.3
    William Woodruff
        New link to new get_phys_pages.3 page

res_ninit.3
res_nmkquery.3
res_nquery.3
res_nquerydomain.3
res_nsearch.3
res_nsend.3
    Michael Kerrisk
        New links to resolver(3) man page

loop-control.4
    Michael Kerrisk
        New link to loop.4

attr.5
    Michael Kerrisk
        New link to xattr(7)


Global changes
--------------

chown.2
execve.2
prctl.2
truncate.2
proc.5
capabilities.7
ld.so.8
    Michael Kerrisk
        Tighter wording: 'mode bit' rather than 'permission bit'
            For sticky, set-UID, and set-GID mode bits (as used in POSIX).


Changes to individual pages
---------------------------

add_key.2
keyctl.2
request_key.2
    Michael Kerrisk
        SEE ALSO: add keyrings(7)

add_key.2
request_key.2
    Michael Kerrisk
        SEE ALSO: add keyctl(3)

epoll_ctl.2
    Michael Kerrisk
        After EPOLLHUP, EOF will be seen only after all data has been consumed

epoll_wait.2
    Michael Kerrisk
        Clarify that signal mask treatment in epoll_pwait() is per-thread
            s/sigprocmask()/pthread_sigmask()/

fcntl.2
    Michael Kerrisk  [Vegard Nossum]
        Note an F_SETSIG corner case

get_mempolicy.2, set_mempolicy
    Brice Goglin
        Policy is per thread, not per process

getxattr.2
listxattr.2
removexattr.2
setxattr.2
capabilities.7
    Michael Kerrisk
        Adjust "attr(5)" references to "xattr(7)"

ioctl.2
    Michael Kerrisk
        SEE ALSO: add console_ioctl(2) and tty_ioctl(2)

listxattr.2
xattr.7
    Michael Kerrisk
        Describe listxattr(2) E2BIG error and document it as a BUG

mkdir.2
    Michael Kerrisk
        Wording fixes + point reader at stat(2) for explanation of file mode
    Michael Kerrisk  [Andreas Grünbacher]
        Further tweaks to text on S_ISVTX and 'mode' argument

mknod.2
    Michael Kerrisk
        Rewordings + point reader at stat(2) for details of mode bits

mmap.2
    Michael Kerrisk
        Remove text that implies that munmap() syncs MAP_SHARED mapping to file
            The existing text in this page:

                   MAP_SHARED Share  this  mapping.   Updates to the mapping
                              are visible to other processes that  map  this
                              file,  and are carried through to the underly‐
                              ing  file.   The  file  may  not  actually  be
                              updated until msync(2) or munmap() is called.

            implies that munmap() will sync the mapping to the underlying
            file. POSIX doesn't require this, and some light reading of the
            code and some light testing (fsync() after munmap() of a large
            file) also indicates that Linux doesn't do this.

msync.2
    Michael Kerrisk
        Rework text of DESCRIPTION
            Rewrite the text somewhat, for easier comprehension.
            No (intentional) changes to factual content

nfsservctl.2
    Michael Kerrisk  [J. Bruce Fields]
        Note that nfsservctl() was replaced by files in nfsd filesystem

open.2
    Michael Kerrisk  [Andreas Gruenbacher]
        open() honors the S_ISVTX, S_ISUID, and S_ISGID bits in 'mode'
    Michael Kerrisk
        Tighten wording: use 'mode bit' rather than 'permission bit'
    Michael Kerrisk  [NeilBrown]
        BUGS: O_CREAT | O_DIRECTORY succeeds if pathname does not exist

poll.2
    Michael Kerrisk  [Ian Pilcher]
        Clarify that signal mask treatment in ppoll() is per-thread
            s/sigprocmask()/pthread_sigmask()/
    Michael Kerrisk  [Sam Varshavchik]
        After POLLHUP, EOF will be seen only after all data has been consumed
    Michael Kerrisk
        Make it clearer which bits are ignored in 'events'

prctl.2
    Michael Kerrisk  [David Wilcox, Filipe Brandenburger]
        Note that "parent" for purposes of PR_SET_DEATHSIG is a *thread*
            See https://bugzilla.kernel.org/show_bug.cgi?id=43300

sendfile.2
    Michael Kerrisk  [Jason Newton]
        Note that sendfile does not support O_APPEND for 'out_fd'
            See https://bugzilla.kernel.org/show_bug.cgi?id=82841
    Michael Kerrisk  [Gregor Jasny]
        RETURN VALUE: note the possibility of "short sends"
            See https://bugzilla.kernel.org/show_bug.cgi?id=97491
    Michael Kerrisk  [Askar Safin]
        Clarify text on 'out_fd' and regular files in Linux 2.4
            See https://bugzilla.kernel.org/show_bug.cgi?id=86001

shutdown.2
    Michael Kerrisk  [Stéphane Aulery]
        BUGS: UNIX domain sockets now detect invalid 'how' values
            Bug fixed in Linux 3.7.
            See https://bugzilla.kernel.org/show_bug.cgi?id=47111

sigaction.2
    Michael Kerrisk
        Refer the reader to fcntl(2) F_SETSIG for further details on si_fd

stat.2
    Jann Horn
        Add note about stat() being racy
    Andreas Gruenbacher
        Improve description of some mode constants
    Michael Kerrisk  [Andreas Grünbacher]
        Remove excessive leading zeros on some constants
    Michael Kerrisk
        Add text on POSIX terms "file mode bits" and "file permission bits"
            Recent changes to various pages employ this distinction.
    Michael Kerrisk
        Tighten wording: use 'mode bit' rather than 'permission bit'
            According to POSIX, the 9 UGO*RWX bits are permissions, and
            'mode' is used to refer to collectively to those bits plus sticky,
            set-UID, and set_GID bits.

syslog.2
    Michael Kerrisk
        SEE ALSO: add dmesg(1)

umask.2
open.2
mknod.2
mkdir.2
    Andreas Gruenbacher
        Explain what default ACLs do
            Explain the effect that default ACLs have (instead of the umask)
            in umask.2.  Mention that default ACLs can have an affect in
            open.2, mknod.2, and mkdir.2.

unshare.2
    Michael Kerrisk  [Florian Weimer]
        Give the reader a hint that unshare() works on processes or threads
            See https://bugzilla.kernel.org/show_bug.cgi?id=59281

atexit.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

bsearch.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

cmsg.3
    Michael Kerrisk  [Christopher Head]
        Fix error in SCM_RIGHTS code sample
            Remove erroneous second initialization of msg.msg_controllen
            in the example code for SCM_RIGHTS.
            See https://bugzilla.kernel.org/show_bug.cgi?id=15952

CPU_SET.3
    Chris Metcalf
        Clarify language about "available" cpus
            The CPU_SET.3 man page uses the adjective "available" when
            explaining what the argument to CPU_SET() means.  This is
            confusing, since "available" isn't well-defined.  The kernel
            has a set of adjectives (possible, present, online, and active)
            that qualify cpus, but normally none of these are what the
            cpu_set_t bit index means: it's just "which cpu", using the
            kernel's internal numbering system, even if that cpu isn't
            possible or present.

            This change removes the word "available" and adds a sentence
            warning that cpu sets may not be contiguous due to dynamic
            cpu hotplug, etc.

err.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

ftw.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

gethostbyname.3
    Carlos O'Donell
        NSS plugins searched first
    Carlos O'Donell
        "order" is obsolete

gethostid.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

getmntent.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

get_nprocs_conf.3
    Michael Kerrisk
        Use exit() rather than return in main()

getopt.3
    Michael Kerrisk  [Guy Harris]
        Remove crufty BUGS section
            See https://bugzilla.kernel.org/show_bug.cgi?id=90261

iconv_close.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

inet_ntop.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

longjmp.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

lsearch.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

mcheck.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

on_exit.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

printf.3
    Michael Kerrisk  [Egmont Koblinger]
        Merge dprintf() and vdprintf() discussion into this page
    Michael Kerrisk
        SEE ALSO: add puts(3)
    Michael Kerrisk
        Move return value discussion to proper RETURN VALUE section

putpwent.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

qsort.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

regex.3
    Michael Kerrisk  [Laurence Gonsalves]
        Fix error in description of 'cflags'
            'cflags' is a bit mask of *zero* (not one) or more flags.

resolver.3
    Stéphane Aulery
        Add info about RES_INSECURE1 and RES_INSECURE2 option in debug mode

scanf.3
    Joern Heissler
        Improve description of %n specifier

setjmp.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

setlocale.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

setlogmask.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

sleep.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

strsignal.3
    Zeng Linggang
        ATTRIBUTES: Note function that isn't thread-safe

sysconf.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

undocumented.3
    William Woodruff
        Remove documented functions

tty_ioctl.4
    Michael Kerrisk  [Denis Du]
        Fix error in code example

proc.5
    Michael Kerrisk  [Cameron Norman, Vasiliy Kulikov]
        Document /proc mount options
            Document the 'hidepid' and 'gid' mount options that were added in
            Linux 3.3.  See https://bugzilla.kernel.org/show_bug.cgi?id=90641
            Based on text by Vasiliy Kulikov in
            Documentation/filesystems/proc.txt.
    Michael Kerrisk  [Kirill A. Shutemov]
        Improve description of /proc/PID/status
    Guillem Jover
        Document /proc/PID/exe behaviour on unlinked pathnames
    Michael Kerrisk  [Weijie Yang]
        Document /proc/PID/status VmPMD

resolv.conf.5
    Stéphane Aulery  [Thomas Hood]
        Document use-vc option added to glibc 2.14
            Fix Ubuntu bug #1110781:
            https://bugs.launchpad.net/ubuntu/+source/manpages/+bug/1110781
    Stéphane Aulery  [Thomas Hood]
        Document RES_SNGLKUPREOP
            Fix Ubuntu bug #1110781:
            https://bugs.launchpad.net/ubuntu/+source/manpages/+bug/1110781

tzfile.5
    Sam Varshavchik
        Add various details on version 2 format

aio.7
    Michael Kerrisk
        Add details and update URL for OLS 2003 paper on AIO

bootparam.7
    Michael Kerrisk  [Alain Kalker]
        Update discussion of 'debug' option
            See https://bugzilla.kernel.org/show_bug.cgi?id=97161
    Michael Kerrisk
        Summary of multiple changes: remove cruft from this page.
            Much of the detail on hardware specifics in this page dates
            from the 20th century. (The last major update to this page was in
            man-pages-1.14!) It's hugely out of date now (many of these
            devices disappeared from the kernel years ago.) So, I've taken
            a large scythe to the page to remove anything that looks
            seriously dated. In the process, the page has shrunk to less
            than 50% of its previous size.
    Michael Kerrisk
        Remove "buff=" details
            This seems to have gone away in Linux 2.2.
    Michael Kerrisk
        Remove crufty "Mouse drivers" options
    Michael Kerrisk
        Remove crufty "General non-device-specific boot arguments" options
    Michael Kerrisk
        Remove crufty "Hard disks" options
    Michael Kerrisk
        Remove crufty "mem=" details
    Michael Kerrisk
        Remove crufty details on IBM MCA bus devices
    Michael Kerrisk
        Remove 'swap=" details
            This seems to have gone away in Linux 2.2,
    Michael Kerrisk
        Remove crufty floppy disk driver options
            In the specific case of floppy drives: the drivers still
            exist, but it's been a while since most of saw these devices
            in the wild. So, just refer the reader to the kernel source
            file for details. (The detail in this man page was after all
            originally drawn from that file.)
        Remove crufty "ISDN drivers" options
    Michael Kerrisk
        Remove crufty "line printer driver" options
    Michael Kerrisk
        Remove crufty "Serial port drivers" options
    Michael Kerrisk
        Remove crufty reference to CONFIG_BUGi386
            That option disappeared in Linux 2.4.
    Michael Kerrisk
        Remove crufty text
            "bootsetups array" dates from Linux 2.0.
    Michael Kerrisk
        Remove crufty "Video hardware" options
    Michael Kerrisk
        Remove crufty SCSI device driver options

fanotify.7
    Michael Kerrisk  [Heinrich Schuchardt]
        Since Linux 3.19, fallocate(2) generates FAN_MODIFY events

inotify.7
    Michael Kerrisk  [Heinrich Schuchardt]
        Since Linux 3.19, fallocate(2) generates IN_MODIFY events

ip.7
    Michael Kerrisk
        Explain how IP_ADD_MEMBERSHIP determines its argument type
    Michael Kerrisk  [Jiri Pirko, Magnus REFTEL]
        Clarify details of the IP_MULTICAST_IF socket option
    Michael Kerrisk  [Advait Dixi]
        Remove dubious text that says that SO_PRIORITY sets IP TOS
            See https://bugzilla.kernel.org/show_bug.cgi?id=35852
    Michael Kerrisk
        Relocate misplaced text describing ENOPROTOOPT error

packet.7
    Graham Shaw
        Add sll_protocol to list of required fields for outbound packets

pthreads.7
    Michael Kerrisk  [KOSAKI Motohiro]
        Using thread IDs whose lifetime has expired gives undefined behavior
            See https://bugzilla.kernel.org/show_bug.cgi?id=53061

raw.7
    Michael Kerrisk  [Tetsuo Handa]
        For incoming datagrams, sin_port is set to zero
    Michael Kerrisk
        Mention sendto(), recvfrom(), and so on when discussing address format
            This gives the reader a little context for the following
            discussion of 'sin_port'.
    Michael Kerrisk
        Remove crufty reference to <netinet/in.h>
    Michael Kerrisk
        Replace reference to RFC 1700 with pointer to IANA protocol number list

signal.7
    Michael Kerrisk  [Steinar H. Gunderson]
        Clarify that I/O operations on disks are not interrupted by signals
            See https://bugzilla.kernel.org/show_bug.cgi?id=97721

unix.7
    Michael Kerrisk  [Christophe Lohr]
        Remove mention of UNIX_PATH_MAX
            This kernel constant is not exposed to user space.
    Michael Kerrisk
        Note the 108 bytes for sun_path is how things are done on Linux
            And refer the reader to NOTES for discussion of portability.

xattr.7
    Michael Kerrisk
        Document EA limits for Btrfs
    Michael Kerrisk
        Document VFS-imposed limits on EAs
            VFS imposes a 255-byte limit on EA names, and a 64kB limit on
            EA values.
    Michael Kerrisk
        The ext[234] block limitation applies to sum of all EAs
            It is not a per-EA limit.
    Michael Kerrisk
        Clarify permissions required to work with 'user' EAs
    Michael Kerrisk
        ext2 and ext3 no longer need mounting with 'user_xattr' for user EAs
    Michael Kerrisk
        Add various relevant pages to SEE ALSO
    Michael Kerrisk
        Add CONFORMING TO section
    Michael Kerrisk
        Modify headings to man-pages norms
    Michael Kerrisk
        Btrfs also supports extended attributes
    Michael Kerrisk
        File capabilities are implemented using *security* attributes
            Not *system* attributes
    Michael Kerrisk
        Describe limit on EA values for JFS, XFS, and Reiserfs
    Michael Kerrisk
        Explicitly mention some of the xattr system calls in DESCRIPTION
            Naming the system calls helps to orient the reader

nscd.8
    Michael Kerrisk
        Add mention of 'services' and 'netgroup' databases
            This makes the page consistent with nscd.conf(5).


==================== Changes in man-pages-4.01 ====================

Released: 2015-07-23, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alexei Starovoitov <ast@plumgrid.com>
Andries E. Brouwer <Andries.Brouwer@cwi.nl>
Arjun Shankar <arjun@redhat.com>
Ashish Sangwan <a.sangwan@samsung.com>
Ben Woodard <woodard@redhat.com>
Carlos O'Donell <carlos@redhat.com>
Christoph Thompson <cjsthompson@gmail.com>
Cortland Setlow <cortland.setlow@gmail.com>
Daniel Borkmann <daniel@iogearbox.net>
David Leppik <dleppik@vocalabs.com>
Dilyan Palauzov <dilyan.palauzov@aegee.org>
Doug Klima <cardoe@gentoo.org>
Eric B Munson <emunson@akamai.com>
Florian Weimer <fweimer@redhat.com>
Hack NDo <hackndo@gmail.com>
Jann Horn <jann@thejh.net>
Jens Axboe <axboe@fb.com>
Jian Wen <wenjianhn@gmail.com>
Joerg Roedel <jroedel@suse.de>
Julian Orth <ju.orth@gmail.com>
Kees Cook <keescook@chromium.org>
Laszlo Ersek <lacos@caesar.elte.hu>
Marko Myllynen <myllynen@redhat.com>
Mehdi Aqadjani Memar <m.aqadjanimemar@student.vu.nl>
Michael Kerrisk <mtk.manpages@gmail.com>
Michal Hocko <mhocko@suse.cz>
Mike Frysinger <vapier@gentoo.org>
Mike Hayward <hayward@loup.net>
Miklos Szeredi <miklos@szeredi.hu>
Namhyung Kim <namhyung@gmail.com>
Namjae Jeon <namjae.jeon@samsung.com>
Nathan Lynch <nathan_lynch@mentor.com>
NeilBrown <neilb@suse.de>
Pádraig Brady <P@draigBrady.com>
Pavel Machek <pavel@ucw.cz>
Peter Hurley <peter@hurleysoftware.com>
Sam Varshavchik <mrsam@courier-mta.com>
Scot Doyle <lkml14@scotdoyle.com>
Stephan Mueller <stephan.mueller@atsec.com>
Tobias Stoeckmann <tobias@stoeckmann.org>
Tulio Magno Quites Machado Filho <tuliom@linux.vnet.ibm.com>
Uwe Kleine-König <uwe+debian@kleine-koenig.org>
Vegard Nossum <vegard.nossum@oracle.com>
Ville Skyttä <ville.skytta@iki.fi>
Vince Weaver <vincent.weaver@maine.edu>
Zeng Linggang <zenglg.jy@cn.fujitsu.com>
文剑 <wenjianhn@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

bpf.2
    Alexei Starovoitov, Michael Kerrisk  [Daniel Borkmann]
        New page documenting bpf(2)

__ppc_get_timebase.3
    Tulio Magno Quites Machado Filho
        New page documenting __ppc_get_timebase() and __ppc_get_timebase_freq()
            Glibc 2.16 was released with a new function for the Power
            architecture that can read its Time Base Register.
            Glibc 2.17 adds a function to read the frequency at which the Time
            Base Register of Power processors is updated.

queue.3
    Michael Kerrisk  [David Leppik, Doug Klima]
        Reimport from latest FreeBSD page
            Long ago, Doug Klima noted that many macros were not
            documented in the queue(3) page. Fix by reimporting from
            latest [1] FreeBSD man page.

            [1] Revision 263142, Modified Fri Mar 14 03:07:51 2014 UTC

            This also fixes https://sourceware.org/bugzilla/show_bug.cgi?id=1506

            This time, I'll learn from past mistakes and not convert
            from 'mdoc' to 'man' macros.
    Michael Kerrisk
        Use subsections in DESCRIPTION
    Michael Kerrisk
        Remove SEE ALSO reference to nonexistent tree(3)
    Michael Kerrisk
        Use real hyphens in code samples
    Michael Kerrisk
        Comment out text for functions not in glibc
    Michael Kerrisk
        Replace HISTORY with CONFORMING TO


Newly documented interfaces in existing pages
---------------------------------------------

rename.2
    Michael Kerrisk  [Miklos Szeredi]
        Document RENAME_WHITEOUT
            Heavily based on text by Miklos Szeredi.


New and changed links
---------------------

__ppc_get_timebase_freq.3
    Tulio Magno Quites Machado Filho
        New link to new __ppc_get_timebase(3) page

LIST_EMPTY.3
LIST_FIRST.3
LIST_FOREACH.3
LIST_HEAD_INITIALIZER.3
LIST_INSERT_BEFORE.3
LIST_NEXT.3
SLIST_EMPTY.3
SLIST_ENTRY.3
SLIST_FIRST.3
SLIST_FOREACH.3
SLIST_HEAD.3
SLIST_HEAD_INITIALIZER.3
SLIST_INIT.3
SLIST_INSERT_AFTER.3
SLIST_INSERT_HEAD.3
SLIST_NEXT.3
SLIST_REMOVE.3
SLIST_REMOVE_HEAD.3
STAILQ_CONCAT.3
STAILQ_EMPTY.3
STAILQ_ENTRY.3
STAILQ_FIRST.3
STAILQ_FOREACH.3
STAILQ_HEAD.3
STAILQ_HEAD_INITIALIZER.3
STAILQ_INIT.3
STAILQ_INSERT_AFTER.3
STAILQ_INSERT_HEAD.3
STAILQ_INSERT_TAIL.3
STAILQ_NEXT.3
STAILQ_REMOVE.3
STAILQ_REMOVE_HEAD.3
TAILQ_CONCAT.3
TAILQ_EMPTY.3
TAILQ_FIRST.3
TAILQ_FOREACH.3
TAILQ_FOREACH_REVERSE.3
TAILQ_HEAD_INITIALIZER.3
TAILQ_INSERT_BEFORE.3
TAILQ_LAST.3
TAILQ_NEXT.3
TAILQ_PREV.3
TAILQ_SWAP.3
    Michael Kerrisk
        New links to queue.3


Global changes
--------------

Various pages
    Michael Kerrisk  [Andries E. Brouwer]
        Remove "ABI" from "C library/kernel ABI differences" subheadings
            The "ABI" doesn't really convey anything significant in
            the title. These subsections are about describing differences
            between the kernel and (g)libc interfaces.


Changes to individual pages
---------------------------

intro.1
    Michael Kerrisk  [Andries E. Brouwer]
        Drop intro paragraph on '$?' shell variable
            As Andries notes, this piece of text is rather out of place in
            a page that was intended to provide a tutorial introduction for
            beginners logging in on a Linux system.

locale.1
    Marko Myllynen
        A minor output format clarification
            A minor clarification for the locale output format which was
            brought up at
            https://sourceware.org/bugzilla/show_bug.cgi?id=18516.

            For reference, see
            https://sourceware.org/bugzilla/show_bug.cgi?id=18516
            http://pubs.opengroup.org/onlinepubs/9699919799/utilities/locale.html

        Add CONFORMING TO section

capget.2
    Julian Orth
        Clarify that hdrp->pid==0 is equivalent gettid() not getpid()

chroot.2
    Jann Horn
        chroot() is not intended for security; document attack
            It is unfortunate that this discourages this use of chroot(2)
            without pointing out alternative solutions - for example,
            OpenSSH and vsftpd both still rely on chroot(2) for security.

            Bind mounts should theoretically be usable as a replacement, but
            currently, they have a similar problem (CVE-2015-2925) that hasn't
            been fixed in ~6 months, so I'd rather not add it to the manpage
            as a solution before a fix lands.

clock_getres.2
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

eventfd.2
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

execve.2
    Michael Kerrisk
        Elaborate on envp/argv as NULL behavior

_exit.2
    Michael Kerrisk
        Open stdio frames are not flushed, temporary files are deleted
            Many years ago, text was added to the page saying that it is
            implementation-dependent whether stdio streams are flushed and
            whether temporary are removed. In part, this change appears to
            be because POSIX.1-2001 added text related to this point.
            However, that seems to have been an error in POSIX, and the
            text was subsequently removed for POSIX.1-2008. See
            https://collaboration.opengroup.org/austin/interps/documents/9984/AI-085.txt
            Austin Group Interpretation reference 1003.1-2001 #085

fallocate.2
    Namjae Jeon  [Michael Kerrisk]
        Document FALLOC_FL_INSERT_RANGE
    Michael Kerrisk
        Since Linux 4.2, ext4 supports FALLOC_FL_INSERT_RANGE

fcntl.2
    Michael Kerrisk
        OFD locks are proposed for inclusion in the next POSIX revision

getrlimit.2
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

getrusage.2
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

gettid.2
    Michael Kerrisk
        Note that for a thread group leader, gettid() == getpid()

iopl.2
    Michael Kerrisk
        Remove some historical libc5 and glibc 1 details
            These details are ancient, and long ago ceased to be relevant.

ioprio_set.2
    Michael Kerrisk  [Jens Axboe]
        Document meaning of ioprio==0

mlock.2
    Michael Kerrisk  [Mehdi Aqadjani Memar]
        Document another ENOMEM error case
            ENOMEM can occur if locking/unlocking in the middle of a region
            would increase the number of VMAs beyond the system limit (64k).

mmap.2
    Michal Hocko  [Eric B Munson]
        Clarify MAP_POPULATE
            David Rientjes has noticed that MAP_POPULATE wording might promise
            much more than the kernel actually provides and intends to provide.
            The primary usage of the flag is to pre-fault the range. There is
            no guarantee that no major faults will happen later on. The pages
            might have been reclaimed by the time the process tries to access
            them.
    Michal Hocko  [Eric B Munson]
        Clarify MAP_LOCKED semantics
            MAP_LOCKED had a subtly different semantic from mmap(2)+mlock(2)
            since it has been introduced.
            mlock(2) fails if the memory range cannot get populated to
            guarantee that no future major faults will happen on the range.
            mmap(MAP_LOCKED) on the other hand silently succeeds even if
            the range was populated only partially.

            Fixing this subtle difference in the kernel is rather awkward
            because the memory population happens after mm locks have been
            dropped and so the cleanup before returning failure (munlock)
            could operate on something else than the originally mapped area.

            E.g. speculative userspace page fault handler catching SEGV and
            doing mmap(fault_addr, MAP_FIXED|MAP_LOCKED) might discard portion
            of a racing mmap and lead to lost data. Although it is not clear
            whether such a usage would be valid, mmap page doesn't explicitly
            describe requirements for threaded applications so we cannot
            exclude this possibility.

            This patch makes the semantic of MAP_LOCKED explicit and suggests
            using mmap + mlock as the only way to guarantee no later major
            page faults.
    Michael Kerrisk
        ERRORS: point out that ENOMEM can occur even for munmap()

mprotect.2
    Michael Kerrisk
        Note ENOMEM error that can occur when we reach limit on maximum VMAs

open.2
read.2
write.2
    Michael Kerrisk  [Mike Hayward]
        Clarify that O_NONBLOCK is a no-op for regular files and block devices

perf_event_open.2
    Vince Weaver  [Joerg Roedel]
        Exclude_host/exclude_guest clarification
            This patch relates to the exclude_host and exclude_guest bits added
            by the following commit:

               exclude_host, exclude_guest; Linux 3.2
                    commit a240f76165e6255384d4bdb8139895fac7988799
                    Author: Joerg Roedel <joerg.roedel@amd.com>
                    Date:   Wed Oct 5 14:01:16 2011 +0200

                        perf, core: Introduce attrs to count in either host or guest mode

            The updated manpage text clarifies that the "exclude_host" and
            "exclude_guest" perf_event_open() attr bits only apply in the
            context of a KVM environment and are currently x86 only.
    Vince Weaver
        Document PERF_SAMPLE_REGS_INTR
            This patch relates to the addition of PERF_SAMPLE_REGS_INTR
            support added in the following commit:

                perf_sample_regs_intr; Linux 3.19
                commit 60e2364e60e86e81bc6377f49779779e6120977f
                Author: Stephane Eranian <eranian@google.com>

                        perf: Add ability to sample machine state on interrupt

            The primary difference between PERF_SAMPLE_REGS_INTR and the
            existing PERF_SAMPLE_REGS_USER is that the new support will
            return kernel register values.  Also if precise_ip is
            set higher than 0 then the PEBS register state will be returned
            rather than the saved interrupt state.

            This patch incorporates feedback from Stephane Eranian and
            Andi Kleen.

prctl.2
seccomp.2
    Michael Kerrisk
        Clarify that SECCOMP_SET_MODE_STRICT disallows exit_group(2)
            These days, glibc implements _exit() as a wrapper around
            exit_group(2). (When seccomp was originally introduced, this was
            not the case.) Give the reader a clue that, despite what glibc is
            doing, what SECCOMP_SET_MODE_STRICT permits is the true _exit(2)
            system call, and not exit_group(2).

pread.2
read.2
readv.2
sendfile.2
write.2
    Michael Kerrisk
        Clarify that Linux limits transfers to a maximum of 0x7ffff000 bytes
            See https://bugs.debian.org/629994 and
            https://bugs.debian.org/630029.

pread.2
    Michael Kerrisk
        Rewrite RETURN VALUE section
            (Also drop the text on pwrite() returning zero; that seems bogus.)

ptrace.2
    Michael Kerrisk  [Vegard Nossum]
        PTRACE_O_TRACEEXIT clarification

readv.2
    Michael Kerrisk
        Remove BUGS heading
            The text on mixing I/O syscalls and stdio is a general point
            of behavior. It's not a bug as such.

recv.2
send.2
    Michael Kerrisk
        Explain some subtleties of MSG_DONTWAIT versus O_NONBLOCK

rename.2
    Michael Kerrisk
    Michael Kerrisk
        Note that RENAME_NOREPLACE can't be employed with RENAME_EXCHANGE

sched_setaffinity.2
    Michael Kerrisk
        Add an example program
    Michael Kerrisk  [Florian Weimer]
        Explain how to deal with 1024-CPU limitation of glibc's cpu_set_t type
    Michael Kerrisk
        Mention the use of the 'isolcpus' kernel boot option

sched_setattr.2
    Julian Orth
        Remove a const attribute
            The attr argument of sched_setattr was documented as const but the
            kernel will modify the size field of this struct if it contains an
            invalid value. See the documentation of the size field for details.

seccomp.2
    Michael Kerrisk
        SEE ALSO: add bpf(2)

send.2
    Michael Kerrisk
        Expand on subtleties of MSG_NOSIGNAL versus ignoring SIGPIPE

sigaltstack.2
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

socket.2
    Stephan Mueller
        Update documentation reference for AF_ALG

truncate.2
    Michael Kerrisk
        ERRORS: ftruncate() can fail if the file descriptor is not writable

utimensat.2
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe
            After research, We think utimensat() and futimens() are thread-safe.
            But, there are not markings of utimensat() and futimens() in glibc
            document.

clearenv.3
    Zeng Linggang
        ATTRIBUTES: Note function that is not thread-safe

dl_iterate_phdr.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

error.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

fexecve.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

fpurge.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

fread.3
    Andries E. Brouwer
        Clarify terminology
            In the "RETURN VALUE" section the word item is in italics
            as if it were one of the function parameters. But the word
            "item" occurs here for the first time, earlier the text
            uses "element". [Patch improves this.]

fts.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

getaddrinfo.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

getaddrinfo_a.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

getauxval.3
    Michael Kerrisk
        File capabilities also trigger AT_SECURE
    Michael Kerrisk
        (Briefly) document AT_HWCAP2

getgrent_r.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

gethostbyname.3
    Michael Kerrisk  [Laszlo Ersek]
        Remove mention of IPv6 addresses, which are not supported
            As reported by Laszlo Ersek:

                gethostbyname(3) fails to resolve the IPv6 address "::1",
                but the manual page says: "If name is an IPv4 or IPv6 address,
                no lookup is performed and gethostbyname() simply copies name
                into the h_name field [...]".

                Debian bug report:
                http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=455762

                glibc bug report:
                http://sourceware.org/bugzilla/show_bug.cgi?id=5479

                SUSv3 link for gethostbyname(3):
                http://www.opengroup.org/onlinepubs/000095399/functions/gethostbyname.html

                It seems that the glibc behavior is conformant, and the manual
                page is in error.

getifaddrs.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

getnameinfo.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

getnetent_r.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

getprotoent.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

getprotoent_r.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

getpw.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

getpwent_r.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

getrpcent.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

getrpcent_r.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

getrpcport.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

getservent.3
    Zeng Linggang
        ATTRIBUTES: Note functions that aren't thread-safe

getservent_r.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

gsignal.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

key_setsecret.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

malloc_get_state.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

malloc_info.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

malloc_stats.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

malloc_trim.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

MB_LEN_MAX.3
    Michael Kerrisk
        Clarify meaning of MB_LEN_MAX
    Michael Kerrisk  [Pádraig Brady]
        MB_LEN_MAX is 16 in modern glibc versions

memcpy.3
    Michael Kerrisk
        NOTES: describe the glibc 2.13 changes that revealed buggy applications
            Adding a note on this point seems worthwhile as a way of
            emphasizing the point that the buffers must not overlap.

mq_notify.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

perror.3
    Michael Kerrisk
        Some wording improvements and clarifications

profil.3
    Zeng Linggang
        ATTRIBUTES: Note function that is not thread-safe

psignal.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

pthread_attr_init.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe
    Michael Kerrisk
        Use "%zd" for printing size_t in example code

pthread_attr_setaffinity_np.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

pthread_cancel.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

pthread_cleanup_push.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

pthread_create.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

pthread_detach.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

pthread_getattr_np.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

pthread_join.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

pthread_setname_np.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

pthread_tryjoin_np.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

putgrent.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

rcmd.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

resolver.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

rpc.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

rpmatch.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

sem_close.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

sem_open.3
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

setaliasent.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

setlocale.3
    Marko Myllynen
        Update CONFORMING TO
            http://pubs.opengroup.org/onlinepubs/9699919799/functions/setlocale.html

setlocale.3
    Marko Myllynen
        Tweak C/POSIX locale portability description
            As discussed earlier, the current description might be a little
            bit too stringent, let's avoid the issue by describing the
            portability aspect on a slightly higher level.

            References:

            http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap06.html
            http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html
            http://pubs.opengroup.org/onlinepubs/9699919799/functions/setlocale.html

shm_open.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

strfmon.3
    Marko Myllynen
        Document strfmon_l(3)
            Describe strfmon_l(3).

            http://pubs.opengroup.org/onlinepubs/9699919799/functions/strfmon.html
    Marko Myllynen
        Fix CONFORMING TO
            AFAICS strfmon(3) is now defined in POSIX and the glibc
            implementation is as specified there.

            http://pubs.opengroup.org/onlinepubs/9699919799/functions/strfmon.html
    Marko Myllynen
        Rewrite the example
            I think the example is more accurate when we use the exact
            locale names and also the Euro sign where appropriate.

xcrypt.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

xdr.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

console_codes.4
    Scot Doyle  [Pavel Machek, Michael Kerrisk]
        Add CSI sequence for cursor blink interval
            Add a Console Private CSI sequence to specify the current
            console's cursor blink interval. The interval is specified
            as a number of milliseconds until the next cursor display
            state toggle, from 50 to 65535.

null.4
    Michael Kerrisk
        Note that reads from /dev/zero are interruptible since Linux 2.6.31

core.5
    Michael Kerrisk
        Mention 'coredump_filter' boot option

host.conf.5
    Michael Kerrisk
        Wording fix: s/resolv+/the resolver library/
            The term "resolv+" seems to be historical cruft.

hosts.equiv.5
    Carlos O'Donell
        Fix format, clarify IdM needs, and provide examples.
            In some recent work with a Red Hat customer I had the opportunity
            to discuss the fine nuances of the ruserok() function and related
            API which are used to implement rlogin and rsh.

            It came to my attention after working with QE on some automated
            internal testing that there were no good examples in the hosts.equiv
            manual page showing how the format was supposed to work for this
            file and for ~/.rhosts, worse the "format" line showed that there
            should be spaces between arguments when that would clearly lead
            to incorrect behaviour. In addition some things that the format
            allows you to write are just wrong like "-host -user" which makes
            no sense since the host is already rejected, and should be written
            as "host -user" instead. I added notes in the example to make it
            clear that "-host -user" is invalid.

            I fixed three things:

            (a) The format line.
            - Either +, or [-]hostname, or +@netgrp or -@netgrp.
            - Either +, or [-]username, or +@netgrp or -@netgrp.
            - You must specify something in the hostname portion so remove
              optional brackets.

            (b) Clarify language around credentials
            - If the host is not trusted you must provide credentials to
              the login system and that could be anything really and it
              depends on your configuration e.g. PAM or whatever IdM you have.

            (c) Provide real-world examples
            - Provide several real world examples and some corner case
              examples for how you would write something. Hopefully others
              can add examples as they see fit.
    Michael Kerrisk  [Carlos O'Donell, Arjun Shankar]
        Improve explanation in EXAMPLE

locale.5
    Marko Myllynen
        Document map to_inpunct, map to_outpunct
            See e.g. fa_IR for reference.
    Marko Myllynen
        Document class in LC_CTYPE
            See e.g. the locale zh_CN and

            http://en.cppreference.com/w/cpp/string/wide/towctrans
            http://en.cppreference.com/w/cpp/string/wide/wctrans
    Marko Myllynen
        Add iconv(1) reference
    Marko Myllynen
        Document character transliteration
            See e.g. da_DK for reference.

            (Not sure should we actually provide an example here?)
    Marko Myllynen
        Document era keywords
            This patch completes the LC_TIME section - since these era
            keywords are so tightly coupled, I'm providing them as a
            single patch.

            Based on
            http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap07.html
            http://www.open-std.org/jtc1/SC22/WG20/docs/n972-14652ft.pdf
    Marko Myllynen
        Document default_missing
    Marko Myllynen
        Document outdigit and alt_digits
            See e.g. fa_IR for reference.
    Marko Myllynen
        Refer to locale(7) more prominently
            It's probably a good idea to refer to locale(7) so that a reader
            can check what a category is about before describing them in
            detail.
    Marko Myllynen
        Document charclass and charconv
            See e.g. the locales ja_JP and ko_KR and

            http://en.cppreference.com/w/cpp/string/wide/towctrans
            http://en.cppreference.com/w/cpp/string/wide/wctrans
    Marko Myllynen
        Copy is not exclusive in LC_CTYPE and LC_COLLATE
            See e.g. da_DK for reference.
    Marko Myllynen
        Remove the FIXME for timezone
            The timezone of LC_TIME is not in POSIX, only 6 (out of ~300)
            glibc locales define it, the glibc code comment below from
            glibc.git/programs/ld-time.c seems to suggest it's not a good
            idea, and there's been a proposal in upstream [1] to remove the
            existing timezone definitions from glibc locales so I think
            it's actually better to leave this one undocumented:

            /* XXX We don't perform any tests on the timezone value since this is
               simply useless, stupid $&$!@...  */

            1) https://sourceware.org/ml/libc-alpha/2015-06/msg00098.html

            Move the remaining LC_COLLATE FIXMEs together while at it.
    Marko Myllynen
        Fix country_isbn format
            Both plain numbers and Unicode code points are used in
            glibc locales but checking the code reveals that country_isbn
            is handled like the rest of its category expect for country_num
            which was clarified earlier.
    Marko Myllynen
        Sort according to the standard
            Sort the options so that those defined in POSIX are listed first,
            then followed by those defined in ISO/IEC TR 14652 in the order
            of common convention in many widely used glibc locales.

            Actual descriptions are unchanged.

            http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html
    Marko Myllynen
        Refer to strftime(3) where appropriate
            The relationship between the locale time format syntax
            and strftime() cannot be considered as obvious.
    Marko Myllynen
        Document map "totitle"
            See e.g. locales/i18n for reference.
    Michael Kerrisk  [Marko Myllynen]
        Remove BUGS section saying man page is not complete
            To some degree, this is true of many pages. And anyway, this
            page is much better after recent work by Marko.

proc.5
    Michael Kerrisk
        List /proc/vmstat fields
    Michael Kerrisk
        Tweak /proc/vmstat text
    Michael Kerrisk
        Add /proc/crypto entry with a pointer to further information
    Michael Kerrisk  [Kees Cook]
        Document /proc/sys/kernel/sysctl_writes_strict
            Based on text in Documentation/sysctl/kernel.txt.
    Michael Kerrisk
        Move misordered /proc/[pid]/timers entry
    Michael Kerrisk
        Refer to bpf(2) for explanation of /proc/sys/net/core/bpf_jit_enable

repertoiremap.5
    Marko Myllynen
        Symbolic names AKA mnemonics
            A long time ago in glibc, repertoire maps were used (but they
            were removed already in 2000), those mapping files were named
            as mnemonics, so "mnemonic" is a term that would almost
            certainly come up if somebody studies glibc side (perhaps even
            the related standards like ISO 9945 [which I don't have access
            to]) so I thought it's worth to mention to term in the man page
            to make sure we're talking about the same thing, otherwise
            someone might wonder is that something different or not.

            IOW, symbolic names and mnemonics are often used interchangeably,
            let's mention the other often used term in the page, too.

capabilities.7
    Michael Kerrisk
        CAP_SYS_ADMIN allows calling bpf(2)

locale.7
    Marko Myllynen
        LC_CTYPE determines transliteration rules on glibc systems

packet.7
    文剑  [Cortland Setlow]
        Fix description of binding a packet socket to an interface

pty.7
    NeilBrown  [Peter Hurley]
        Clarify asynchronous nature of PTY I/O
            A PTY is not like a pipe - there may be delayed between data
            being written at one end and it being available at the other.

            This became particularly apparent after
                 commit f95499c3030f
                ("n_tty: Don't wait for buffer work in read() loop")
            in Linux 3.12

            See also the mail thread at https://lkml.org/lkml/2015/5/1/35
                Date    Mon, 04 May 2015 12:32:04 -0400
                From    Peter Hurley <>
                Subject Re: [PATCH bisected regression] input_available_p()
                            sometimes says 'no' when it should say 'yes'

rtld-audit.7
    Ben Woodard
        Use correct printf() specifier for pointer types
            In the example code you used %x rather than %p in the example
            code for an audit library. The problem is that it truncates the
            pointers on 64b platforms. So you get something like:

            la_symbind64(): symname = strrchr sym->st_value = 0x7f4b8a3f8960
            ndx = 222 flags = 0x0 refcook = 8b53e5c8 defcook = 8b537e30

            rather than:

            la_symbind64(): symname = fclose sym->st_value = 0x7fa452dd49b0
            ndx = 1135 flags = 0x0 refcook = 0x7fa453f395c8 defcook = 0x7fa453f32e30

            This has bitten me a handful of times when playing around with
            audit test libraries to investigate its behavior.

sched.7
    Michael Kerrisk
        Remove ancient, wildly optimistic prediction about future of RT patches
            It seems the patches were not merged by 2.6.30...

socket.7
    Michael Kerrisk
        SEE ALSO: add bpf(2)

vdso.7
    Nathan Lynch  [Mike Frysinger]
        Update for ARM
            The 32-bit ARM architecture in Linux has gained a vDSO as of the
            4.1 release.  (I was the primary author.)

            Document the symbols exported by the ARM VDSO.

            Accepted kernel submission:
            http://lists.infradead.org/pipermail/linux-arm-kernel/2015-March/332573.html


==================== Changes in man-pages-4.02 ====================

Released: 2015-08-08, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Carlos O'Donell <carlos@redhat.com>
Daniel Borkmann <daniel@iogearbox.net>
David Rientjes <rientjes@google.com>
Dilyan Palauzov <dilyan.palauzov@aegee.org>
Gabriel F. T. Gomes <gftg@linux.vnet.ibm.com>
Gleb Fotengauer-Malinovskiy <glebfm@altlinux.org>
Goswin von Brederlow <goswin-v-b@web.de>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Jonathan David Amery <jdamery@ysolde.ucam.org>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Mike Kravetz <mike.kravetz@oracle.com>
Nicholas Miell <nmiell@gmail.com>
Nikola Forró <nforro@redhat.com>
Sam Varshavchik <mrsam@courier-mta.com>
Yaarit <yaarit@gmail.com>
Zeng Linggang <zenglg.jy@cn.fujitsu.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

dladdr.3
    Michael Kerrisk
        New page documenting dladdr() and dladdr1()
            Relocate/rewrite dladdr() text formerly contained in dlopen(3).

            Add documentation of dladdr1().
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe

dlerror.3
    Michael Kerrisk
        Migrate dlerror(3) to new separate man page
    Michael Kerrisk
        Note that the returned message may be in a statically allocated buffer
    Michael Kerrisk
        Note that the returned string does not include a trailing newline
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

dlinfo.3
    Michael Kerrisk
        New page describing dlinfo(3)
    Zeng Linggang
        ATTRIBUTES: Note function that is thread-safe

dlopen.3
    Michael Kerrisk
        This page was substantially rewritten and enhanced. Notably:
        * the dladdr(), dlsym, dlvsym(), and dlerror() content were moved
          to separate new pages;
        * documentation for dlmopen was added;
        * and other changes as noted below.
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe
    Michael Kerrisk
        Move atexit() discussion under "Initialization and Finalization"
    Michael Kerrisk
        Move discussion of _init() and _fini() to NOTES
    Michael Kerrisk
        Rework the discussion of initialization and finalization functions
            Deemphasize the obsolete _init/_fini and give more prominence
            to gcc constructors/destructors.
    Michael Kerrisk
        dlclose() will unload the object when all references have been released
    Michael Kerrisk
        EXAMPLE: Remove mention of "-rdynamic"
            That option isn't needed for compiling and running this program.
    Michael Kerrisk
        Remove reference to ld.so info page
            The command "info ld.so" simply shows the man page...
    Michael Kerrisk
        Add VERSIONS section
    Michael Kerrisk
        Reorganize conformance information for 'flags'

dlsysm.3
    Michael Kerrisk
        Move dlsym() and dlvsym() content to new separate page
    Zeng Linggang
        ATTRIBUTES: Note functions that are thread-safe


Newly documented interfaces in existing pages
---------------------------------------------

dlopen.3
    Michael Kerrisk, Carlos O'Donell
        Document dlmopen(3)

nl_langinfo.3
    Sam Varshavchik, Michael Kerrisk
        Add documentation for nl_langinfo_l(3)

__ppc_set_ppr_med.3
    Gabriel F. T. Gomes
        Document PPC functions providing access to PPR
            GNU C Library 2.18 adds functions (__ppc_set_ppr_low(3),
            __ppc_set_ppr_med(3), __ppc_set_ppr_med_low(3)) that provide
            access to the Program Priority Register (PPR).

__ppc_yield.3
    Gabriel F. T. Gomes
        Document PPC performance-hint functions
            GNU C Library 2.18 adds functions __ppc_yield(3), __ppc_mdoio(3),
            and __ppc_mdoom(3) that can be used provide a hint that
            performance could be improved if shared resources are released
            for use by other processors.


New and changed links
---------------------

dladdr1.3
    Michael Kerrisk
        New link to (new) dladdr(3) page

dlmopen.3
    Michael Kerrisk
        New link to dlopen.3

dlvsym.3
    Michael Kerrisk
        Adjust link to point to new self-contained dlsym(3) page

nl_langinfo_l.3
    Michael Kerrisk
        New link to nl_langinfo.3

__ppc_mdoio.3
    Gabriel F. T. Gomes
        New link to __ppc_yield.3

__ppc_mdoom.3
    Gabriel F. T. Gomes
        New link to __ppc_yield.3

__ppc_set_ppr_low.3
    Gabriel F. T. Gomes
        New link to __ppc_set_ppr_med.3

__ppc_set_ppr_med_low.3
    Gabriel F. T. Gomes
        New link to __ppc_set_ppr_med.3


Global changes
--------------

Very many pages
    Michael Kerrisk
        Update CONFORMING TO section to reflect POSIX.1-2001 and POSIX.1-2008
        details. (By now, I believe all pages should be up to date with
        respect to appropriately mentioning POSIX.1-2001 and POSIX.1-2008.)

ldd.1
sprof.1
execve.2
dlopen.3
ld.so.8
    Michael Kerrisk
        Prefer "shared object" over "shared library"
            The man pages variously use "shared library" or "shared object".
            Try to more consistently use one term ("shared object"), while
            also pointing out on a few pages that the terms are synonymous.


Changes to individual pages
---------------------------

accept.2
    Michael Kerrisk
        Add mention of POSIX.1-2008 regarding EAGAIN vs EWOULDBLOCK

bpf.2
    Daniel Borkmann
        Various updates/follow-ups to address some fixmes
            A couple of follow-ups to the bpf(2) man-page, besides others:

             * Description of map data types
             * Explanation on eBPF tail calls and program arrays
             * Paragraph on tc holding ref of the eBPF program in the kernel
             * Updated ASCII image with tc ingress and egress invocations
             * __sync_fetch_and_add() and example usage mentioned on arrays
             * minor reword on the licensing and other minor fixups

execve.2
    Michael Kerrisk
        Reword text on POSIX and #!

io_getevents.2
    Michael Kerrisk
        Note return value on interruption by a signal handler
    Michael Kerrisk
        Clarify details of return value for timeout-expired case
    Michael Kerrisk
        Clarify and extend discussion of 'timeout' argument

mmap.2
    Michael Kerrisk
        Note that 'length' need not be a page-size multiple for munmap()
    Michael Kerrisk  [David Rientjes, David Rientjes, Mike Kravetz]
        Describe mmap()/munmap() argument requirements for huge-page mappings
    Michael Kerrisk
        Move discussion of timestamps to NOTES
            A straight move; no changes to the content.
            This content is better placed in NOTES.

seccomp.2
    Michael Kerrisk
        SEE ALSO: mention libseccomp pages
        SEE ALSO: add scmp_sys_resolver(1)

sigaction.2
    Michael Kerrisk
        Correct the list of flags that were added in POSIX.1-2001

socketpair.2
    Michael Kerrisk  [Goswin von Brederlow]
        Clarify use of SOCK_* flags in 'type' argument
            See http://bugs.debian.org/794217

atexit.3
    Michael Kerrisk
        SEE ALSO: add dlopen(3)

clock_getcpuclockid.3
    Michael Kerrisk
        Improve wording of EPERM error
            It's imprecise to say that this is an "optional" error
            in POSIX.1.

dl_iterate_phdr.3
    Michael Kerrisk
        Note that 'size' allows callback() to discover structure extensions
    Michael Kerrisk
        SEE ALSO: add dladdr(3)
    Michael Kerrisk
        CONFORMING TO: note that this function appears on some other systems

fseeko.3
    Michael Kerrisk
        Remove crufty NOTES section
            This ancient System V detail is unneeded.

getutent.3
    Michael Kerrisk
        Mention POSIX.1-2008 for the "utmpx" functions

iconv_close.3
iconv_open.3
    Michael Kerrisk
        CONFORMING TO: change "UNIX98" to "SUSv2"

malloc.3
    Michael Kerrisk
        Change "UNIX 98" to "SUSv2"

mktemp.3
    Gleb Fotengauer-Malinovskiy
        Reference mkdtemp(3) in addition to mkstemp(3)
            Mention mkdtemp(3) as another secure alternative to mktemp(3).

            See also https://sourceware.org/bugzilla/show_bug.cgi?id=2898.

mq_receive.3
mq_send.3
    Michael Kerrisk
        Clarify discussion of 'timeout'
            In particular, remove the word 'ceiling', which falsely
            suggests that the call might return prematurely.

nl_langinfo.3
    Michael Kerrisk
        Explicitly describe the return value on success
    Michael Kerrisk
        POSIX specifies that the caller may not modify the returned string
    Michael Kerrisk
        Enhance RETURN VALUE description
            Note some further cases where returned string may be
            invalidated or overwritten.

perror.3
    Michael Kerrisk
        Reformat CONFORMING to information
    Michael Kerrisk
        Note that 'sys_errlist' and 'sys_nerr' are not in POSIX.1

posix_openpt.3
    Michael Kerrisk
        Reword text regarding systems that don't have posix_openpt()

printf.3
    Michael Kerrisk
        CONFORMING TO: update details for dprintf() and vdprintf()

setlogmask.3
    Michael Kerrisk
        Remove useless statement in CONFORMING TO
            Saying that the description in PSOX.1-2001 is flawed,
            without saying what the fla is, is not helpful.
            (And no, I don't know what the flaw is.)

shm_open.3
    Michael Kerrisk
        Add POSIX.1-2008 details regarding group ID of new shared memory object

strfmon.3
    Michael Kerrisk
        Fix erroneous CONFORMING to
            strfmon() is in POSIX.1.

fanotify.7
    Heinrich Schuchardt
        Clarify effects of file moves
            If files or directories are moved to other mounts, the inode is
            deleted. Fanotify marks are lost.

mq_overview.7
    Michael Kerrisk
        Remove unneeded CONFORMING TO section

nptl.7
    Michael Kerrisk  [Nicholas Miell]
        Note that i386 and x86-64 binaries can't share mutexes

sched.7
    Nikola Forró
        Fix descriptions of sched_get_priority_max() / sched_get_priority_min()

sem_overview.7
    Michael Kerrisk
        Remove unneeded CONFORMING TO section

shm_overview.7
    Michael Kerrisk
        Remove unneeded CONFORMING TO section

sigevent.7
    Michael Kerrisk
        Remove unneeded CONFORMING TO section

symlink.7
    Michael Kerrisk
        Update with POSIX.1-2008 details for link(2)

ld.so.8
    Michael Kerrisk  [Jonathan David Amery]
        Items in LD_LIBRARY_PATH can also be delimited by semicolons
            See http://bugs.debian.org/794559.


==================== Changes in man-pages-4.03 ====================

Released: 2015-12-05, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alexander Shishkin <alexander.shishkin@linux.intel.com>
Alexei Starovoitov <ast@plumgrid.com>
Andy Lutomirski <luto@kernel.org>
Arto Bendiken <arto@bendiken.net>
Carlos O'Donell <carlos@redhat.com>
Casper Ti. Vector <caspervector@gmail.com>
Daniel Borkmann <daniel@iogearbox.net>
David Drysdale <drysdale@google.com>
Eric B Munson <emunson@akamai.com>
Florian Weimer <fweimer@redhat.com>
Gabriel F. T. Gomes <gftg@linux.vnet.ibm.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Ingo Molnar <mingo@kernel.org>
Jakub Wilk <jwilk@jwilk.net>
Johannes Stüttgen <Johannes.Stuettgen@gmail.com>
Jonathan Wakely <jwakely@redhat.com>
Jonny Grant <jg@jguk.org>
Kees Cook <keescook@chromium.org>
Maria Guseva <m.guseva@samsung.com>
Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Meikun Wang <alikewmk@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Michal Hocko <mhocko@suse.com>
Mike Frysinger <vapier@gentoo.org>
Namhyung Kim <namhyung@gmail.com>
Nikola Forró <nforro@redhat.com>
Olivier TARTROU <olivier.tartrou@gmail.com>
Peter Hurley <peter@hurleysoftware.com>
Peter Zijlstra (Intel) <peterz@infradead.org>
Ross Zwisler <ross.zwisler@linux.intel.com>
Serge Hallyn <serge.hallyn@canonical.com>
Silvan Jegen <s.jegen@gmail.com>
Stefan Tauner <tauner@technikum-wien.at>
Steven Rostedt <rostedt@goodmis.org>
Tobias Stoeckmann <tobias@stoeckmann.org>
Tycho Andersen <tycho.andersen@canonical.com>
Ville Skyttä <ville.skytta@iki.fi>
Vince Weaver <vincent.weaver@maine.edu>
Zeng Linggang <zenglg.jy@cn.fujitsu.com>

Apologies if I missed anyone!


Newly documented interfaces in existing pages
---------------------------------------------

perf_event_open.2
    Vince Weaver
        4.1 adds AUX sample support
    Vince Weaver
        4.1 data_offset and data_size fields
    Vince Weaver  [Alexander Shishkin]
        Document aux_{head,tail,offset,size} support
    Vince Weaver
        4.0 update rdpmc documentation
    Vince Weaver
        4.1 adds PERF_RECORD_ITRACE_START
    Vince Weaver
        Document 4.1 clockid support
    Vince Weaver  [Steven Rostedt, Masami Hiramatsu]
        4.1 PERF_EVENT_IOC_SET_BPF support
    Vince Weaver
        4.1 adds AUX_FLAG_OVERWRITE support
    Vince Weaver
        4.1 PERF_SAMPLE_BRANCH_CALL_STACK
    Vince Weaver
        4.1 adds aux_watermark
    Vince Weaver
        Add possibility of EBUSY error

prctl.2
    Andy Lutomirski  [Kees Cook, Serge Hallyn]
        Document operations for ambient capabilities
    Michael Kerrisk
        Rework PR_CAP_AMBIENT text
        Note that arg4 and arg5 must be zero for CAP_AMBIENT
        RETURN VALUE: Add PR_CAP_AMBIENT + PR_CAP_AMBIENT_IS_SET case
        ERRORS: document PR_CAP_AMBIENT error cases

__ppc_set_ppr_med.3
    Gabriel F. T. Gomes
        Document PPC functions providing access to PPR
            GNU C Library commit 1747fcda4902a3b46183d93fb16ed9b436b2608b
            extends the priorities that can be set to the Program Priority
            Register (PPR), with the functions: __ppc_set_ppr_very_low(3)
            and __ppc_set_ppr_med_high(3).

capabilities.7
    Andy Lutomirski  [Kees Cook, Serge Hallyn]
        Document ambient capabilities
    Michael Kerrisk
        Various additions and reworkings for ambient capability text


New and changed links
---------------------

__ppc_set_ppr_med_high.3
    Gabriel F. T. Gomes
        New link to __ppc_set_ppr_med.3

__ppc_set_ppr_very_low.3
    Gabriel F. T. Gomes
        New link to __ppc_set_ppr_med.3


Changes to individual pages
---------------------------

mremap.2
    Eric B Munson  [Michal Hocko]
        Add note about mremap() with locked areas
            When mremap() is used to move or expand a mapping that is locked
            with mlock() or equivalent it will attempt to populate the new
            area.  However, like mmap(MAP_LOCKED), mremap() will not fail if
            the area cannot be populated.  Also like mmap(MAP_LOCKED) this
            might come as a surprise to users and should be noted.
open.2
    Michael Kerrisk  [David Drysdale]
        Remove accidental mention of O_TTY_INIT
            An earlier edit mentioned O_TTY_INIT as a file creation flag.
            That's true, according POSIX, but Linux does not implement
            this flag, so remove mention of it.

pipe.2
    Michael Kerrisk
        SEE ALSO: add splice(2)

prctl.2
    Michael Kerrisk
        Reorder options alphabetically
            Employ a pseudo-alphabetical order, ordering options after removal
            of any "PR_", "PR_SET_", or "PR_GET" prefix.
    Michael Kerrisk
        Fix alphabetical misplacements in ERRORS

ptrace.2
    Tycho Andersen
        Document PTRACE_O_SUSPEND_SECCOMP flag
    Michael Kerrisk
        Document /proc/sys/kernel/yama/ptrace_scope
    Michael Kerrisk
        Note that PTRACE_ATTACH cannot be applied to nondumpable processes
    Michael Kerrisk
        SEE ALSO: add prctl(2)

reboot.2
    Casper Ti. Vector
        1-argument reboot() is also provided by alternative libc

seccomp.2
    Michael Kerrisk
        Describe use of 'instruction_pointer' data field
    Michael Kerrisk  [Kees Cook]
        Note why all filters in a set are executed even after SECCOMP_RET_KILL

signalfd.2
    Michael Kerrisk
        Describe semantics with respect to SCM_RIGHTS

syscalls.2
    Michael Kerrisk
        Add mlock(2)
    Michael Kerrisk
        Add userfaultfd()

daemon.3
    Michael Kerrisk  [Johannes Stüttgen]
        Note that daemon() is buggy with respect to controlling tty acquisition

dirfd.3
    Jonathan Wakely
        Remove outdated NOTES
            As stated in the SYNOPSIS, since glibc 2.10 this function is also
            declared by the relevant X/Open and POSIX macros.

dlopen.3
    Michael Kerrisk
        Make it more explicit that LD_BIND_NOW overrides RTLD_LAZY
    Michael Kerrisk  [Florian Weimer]
        Correct the pathname used in EXAMPLE
            Quoting Florian:

                This does not work because libm.so can be a linker script:

                       handle = dlopen("libm.so", RTLD_LAZY);

                The proper way to do this is to include <gnu/lib-names.h>
                and use LIBM_SO.

            See https://bugzilla.kernel.org/show_bug.cgi?id=108821
    Michael Kerrisk
        Include a shell session showing build/run in EXAMPLE
    Michael Kerrisk
        Change arguments to main() to "void" in EXAMPLE

fgetgrent.3
    Zeng Linggang
        ATTRIBUTES: Note function that is not thread-safe

fgetpwent.3
    Zeng Linggang
        ATTRIBUTES: Note function that is not thread-safe

getauxval.3
    Michael Kerrisk
        Add some details for AT_SECURE

getspnam.3
    Zeng Linggang
        ATTRIBUTES: Note functions that are/aren't thread-safe

mallinfo.3
    Zeng Linggang
        ATTRIBUTES: Note function that is not thread-safe

mallopt.3
    Carlos O'Donell
        Document M_ARENA_TEST and M_ARENA_MAX

posix_fallocate.3
    Michael Kerrisk
        Clarify text relating to MT-safety
    Carlos O'Donell
        Mention glibc emulation caveats

termios.3
    Olivier TARTROU
        Add missing details on behaviour of PARMRK
            For a serial terminal, with a specific configuration, input bytes
            with value 0377 are passed to the program as two bytes, 0377 0377.

tty_ioctl.4
    Michael Kerrisk  [Peter Hurley]
        Note that TIOCTTYGSTRUCT went away in Linux 2.5.67

core.5
    Ross Zwisler
        Add info about DAX coredump filtering flags
            Kernel 4.4 added two new core dump filtering flags,
            MMF_DUMP_DAX_PRIVATE and MMF_DUMP_DAX_SHARED.

            These flags allow us to explicitly filter DAX mappings.
            This is desirable because DAX mappings, like hugetlb
            mappings, have the potential to be very large.

nsswitch.conf.5
    Nikola Forró
        Add list of files being read when "files" service is used
            This is not mentioned anywhere. Users can assume that the file
            being read is something like /etc/$DATABASE, but that's not
            always the case. It's better to explicitly specify which
            file is read for each respective database.  The list of
            files was acquired from glibc source code.

proc.5
    Heinrich Schuchardt  [Michael Kerrisk]
        Add details for threads-max
            Add detail information for threads-max.
            The checks for minimum and maximum values exist since kernel 4.1.
            https://lkml.org/lkml/2015/3/15/96
    Heinrich Schuchardt
        /proc/sys: Describe whitespace characters
    Michael Kerrisk
        Document 'CapAmb' in /proc/PID/status
    Michael Kerrisk
        Add reference to ptrace(2) for /proc/sys/kernel/yama/ptrace_scope

aio.7
    Michael Kerrisk  [Meikun Wang]
        Add missing include file, <fcntl.h>, to example program

mq_overview.7
    Michael Kerrisk  [Arto Bendiken]
        Document QSIZE bug that appeared in 3.5 and was fixed in 4.2

path_resolution.7
    Michael Kerrisk
        Clarify recursive resolution of symlinks and note limits

pipe.7
    Michael Kerrisk
        SEE ALSO: add splice(2)

rtld-audit.7
    Namhyung Kim
        Fix (typo) error in la_pltenter() description
            s/la_pltenter()/la_pltexit()/

            la_pltenter() is called regardless of the value of
            framesizep but la_pltexit() is called only if la_pltenter()
            returns with non-zero framesizep set.  I spent long time to
            figure out why la_pltexit() is not called at all.

signal.7
    Michael Kerrisk  [Michael Hocko]
        Note async-signal-safe functions added by POSIX.1-2008 TC1

tcp.7
    Daniel Borkmann  [Michael Kerrisk]
        Improve paragraphs on tcp_ecn and add tcp_ecn_fallback bullet
            Improve description of tcp_ecn, fix the RFC number and it's
            not a boolean anymore since long time, and add a description
            for tcp_ecn_fallback.

            See also kernel doc under Documentation/networking/ip-sysctl.txt
            on tcp_ecn and tcp_ecn_fallback.

ld.so.8
    Michael Kerrisk
        LD_POINTER_GUARD has been removed in glibc 2.23
    Michael Kerrisk
        Describe secure-execution mode
    Michael Kerrisk  [Maria Guseva]
        Replace mentions of set-UID/set-GID programs with secure-execution mode
            Inspired by a patch from Maria Guseva.
    Maria Guseva  [Silvan Jegen]
        LD_DEBUG is effective in secure-execution mode if /etc/suid-debug exists


==================== Changes in man-pages-4.04 ====================

Released: 2015-12-29, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alexander Monakov <amonakov@ispras.ru>
Andries E. Brouwer <Andries.Brouwer@cwi.nl>
Archie Cobbs <archie.cobbs@gmail.com>
Carlos O'Donell <carlos@redhat.com>
Colin Rice <colin@daedrum.net>
Darren Hart <dvhart@infradead.org>
Davidlohr Bueso <dave@stgolabs.net>
Dmitry V. Levin <ldv@altlinux.org>
Eric B Munson <emunson@akamai.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
H.J. Lu <hjl.tools@gmail.com>
Jakub Wilk <jwilk@jwilk.net>
Jonathan Wakely <jwakely@redhat.com>
Jonny Grant <jg@jguk.org>
Laurent Georget <laurent.georget@supelec.fr>
Lennart Poettering <lennart@poettering.net>
Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Michal Hocko <mhocko@suse.com>
Mike Frysinger <vapier@gentoo.org>
Pádraig Brady <P@draigBrady.com>
Paul Eggert <eggert@cs.ucla.edu>
Pavel Machek <pavel@ucw.cz>
Phil Blundell <pb@pbcl.net>
Richard Voigt <richardvoigt@gmail.com>
Rich Felker <dalias@libc.org>
Rusty Russell <rusty@rustcorp.com.au>
Thomas Gleixner <tglx@linutronix.de>
Tom Gundersen <teg@jklm.no>
Torvald Riegel <triegel@redhat.com>
Vincent Lefevre <vincent@vinc17.net>
Vlastimil Babka <vbabka@suse.cz>
Walter Harms <wharms@bfs.de>
Zack Weinberg <zackw@panix.com>


Apologies if I missed anyone!


New and rewritten pages
-----------------------

futex.2
    Michael Kerrisk, Thomas Gleixner, Torvald Riegel  [Davidlohr Bueso, Heinrich Schuchardt, Darren Hart, Rusty Russell, Pavel Machek, Rich Felker]
        Rewrite and massively expand page

membarrier.2
    Mathieu Desnoyers  [Michael Kerrisk]
        New page documenting membarrier() system call


Newly documented interfaces in existing pages
---------------------------------------------

mlock.2
    Eric B Munson  [Michal Hocko, Vlastimil Babka, Michael Kerrisk]
        Document mlock2(2) and MCL_ONFAULT


New and changed links
---------------------

mlock2.2
    Eric B Munson
        New link to mlock.2


Global changes
--------------

Various pages
    Michael Kerrisk
        ERRORS: standardize text for EMFILE error

Various pages
    Michael Kerrisk
        ERRORS: standardize error text for ENOTSOCK error

Various pages
    Michael Kerrisk
        ERRORS: standardize text for ENFILE error


Changes to individual pages
---------------------------

clock_getres.2
    Michael Kerrisk
        SEE ALSO: add vdso(7)

epoll_create.2
    Michael Kerrisk
        ERRORS: add another EMFILE error case

fanotify_init.2
    Michael Kerrisk
        ERRORS: add an EMFILE error case

fork.2
    Michael Kerrisk
        Child of MT-process is restricted to async-signal-safe functions

getcpu.2
    Michael Kerrisk
        SEE ALSO: add vdso(7)

getrlimit.2
    Michael Kerrisk  [Lennart Poettering]
        The init of measurement for RLIMIT_RSS is bytes, not pages

get_robust_list.2
    Michael Kerrisk
        Reword EINVAL error text

gettimeofday.2
    Carlos O'Donell
        Expand on the historical meaning of tz_dsttime
    Michael Kerrisk
        SEE ALSO: add vdso(7)

inotify_init.2
    Michael Kerrisk
        ERRORS: add an EMFILE error case

personality.2
    Dmitry V. Levin
        Note kernel and glibc versions that introduced this system call

poll.2
    Richard Voigt
        timeout_ts is a pointer, so use -> not . for member access
    Michael Kerrisk
        Shorten name of timeout argument for ppoll()
            The name is overly long, and does not hint at the fact
            that this argument is a pointer. Fix this by renaming:
            s/timeout_ts/tmo_p/

sendfile.2
    Laurent Georget
        Document more ERRORS

sigreturn.2
    Michael Kerrisk
        SEE ALSO: add vdso(7)

socketcall.2
    Michael Kerrisk
        Since Linux 4.3, x86-32 provides direct system calls for the sockets API

time.2
    Zack Weinberg
        Explain why the glibc time() wrapper never sets 'errno'
    Michael Kerrisk  [H.J. Lu]
        Where time() is provided by vDSO, an invalid address may give SIGSEGV
    Michael Kerrisk  [Paul Eggert]
        Describe EOVERFLOW details
    Michael Kerrisk
        SEE ALSO: add vdso(7)
    Michael Kerrisk
        Rename 't' argument to 'tloc'

dlerror.3
    Michael Kerrisk  [Jonny Grant]
        Clarify that the string returned by dlerror() is null terminated

dlopen.3
    Michael Kerrisk
        Include a shell session showing build/run in EXAMPLE
    Michael Kerrisk
        Change arguments to main() to "void" in EXAMPLE

drand48.3
    Michael Kerrisk  [Vincent Lefevre]
        Correct descriptions of ranges returned by these functions
            See http://bugs.debian.org/803459

errno.3
    Michael Kerrisk
        Note probable cause of ENFILE error

fnmatch.3
    Pádraig Brady
        Describe the FNM_EXTMATCH flag and pattern syntax

iconv.3
    Andries E. Brouwer
        NOTES: describe correct usage for flushing partially buffered input

random_r.3
    Michael Kerrisk  [Archie Cobbs]
        Clarify need to use initstate_r()

tzset.3
    Carlos O'Donell
        Clarify "daylight" and remove erroneous note

random.4
    Michael Kerrisk  [Tom Gundersen]
        Rework example scripts to assume 'poolsize' unit is bits, not bytes
    Michael Kerrisk  [Walter Harms]
        Use modern command substitution syntax in shell session log

proc.5
    Michael Kerrisk
        Reaching /proc/sys/fs/file-max limit normally produces an ENFILE error

futex.7
    Heinrich Schuchardt
        SEE ALSO updates
    Michael Kerrisk
        Note some other locking primitives that are built with futexes
    Heinrich Schuchardt
        NPTL, avoid abbreviation
    Michael Kerrisk
        Note that a futex is 4 bytes on all platforms

vdso.7
    Michael Kerrisk
        Add note on strace(1) and vDSO

ld.so.8
    H.J. Lu [Michael Kerrisk]
        Document LD_PREFER_MAP_32BIT_EXEC
    Michael Kerrisk
        Clarify setting of LD_BIND_NOT
    Michael Kerrisk
        Clarify setting of LD_DYNAMIC_WEAK
    Michael Kerrisk
        Clarify setting of LD_TRACE_PRELINKING
    Michael Kerrisk
        Clarify some details for LD_SHOW_AUXV


==================== Changes in man-pages-4.05 ====================

Released: 2016-03-15, Christchurch


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Adhemerval Zanella <adhemerval.zanella@linaro.org>
Akihiro Suda <suda.kyoto@gmail.com>
Alan Aversa <alan.aversa@cox.net>
Alan Cox <etchedpixels@gmail.com>
Alec Leamas <leamas.alec@gmail.com>
Alex Henrie <alexhenrie24@gmail.com>
Alexander Miller <alex.miller@gmx.de>
Andreas Gruenbacher <agruenba@redhat.com>
Andreas Schwab <schwab@suse.de>
Anna Schumaker <Anna.Schumaker@Netapp.com>
Askar Safin <safinaskar@mail.ru>
Bill O. Gallmeister <bgallmeister@gmail.com>
Carlos O'Donell <carlos@redhat.com>
Chris Pick <kernel@chrispick.com>
Christoph Hellwig <hch@infradead.org>
Craig Gallek <kraig@google.com>
Darrick J. Wong <darrick.wong@oracle.com>
Davidlohr Bueso <dave@stgolabs.net>
Dmitry V. Levin <ldv@altlinux.org>
Dr. Tobias Quathamer <toddy@debian.org>
Eric Blake <eblake@redhat.com>
Eric Dumazet <edumazet@google.com>
Florian Weimer <fweimer@redhat.com>
Gabriel Corona <gabriel.corona@enst-bretagne.fr>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Ivan Shapovalov <intelfx@intelfx.name>
Jakub Wilk <jwilk@jwilk.net>
Jason Baron <jbaron@akamai.com>
Jason Vas Dias <jason.vas.dias@gmail.com>
Jérémie Galarneau <jeremie.galarneau@efficios.com>
Jeremy Harris <jeharris@redhat.com>
Joachim Wuttke <j.wuttke@fz-juelich.de>
Joe Stein <joeaarons@gmail.com>
John Stultz <john.stultz@linaro.org>
Josh Triplett <josh@joshtriplett.org>
Kondo, Naoya <kondo-naoya@jp.fujitsu.com>
Krzysztof Adamski <k@japko.eu>
Manfred Spraul <manfred@colorfullife.com>
Marianne CHEVROT <blackmoor@openmailbox.org>
Marko Myllynen <myllynen@redhat.com>
Mark Post <mpost@suse.com>
Martin Gebert <Murphy.Gebert@gmx.de>
Mats Wichmann <mats@linuxfoundation.org>
Matt Zimmerman <mdz@debian.org>
Michael Kerrisk <mtk.manpages@gmail.com>`
Mike Frysinger <vapier@gentoo.org>
Minchan Kim <minchan@kernel.org>
Naoya Kondo <kondo-naoya@jp.fujitsu.com>
Naresh Kamboju <naresh.kernel@gmail.com>
Nikola Forró <nforro@redhat.com>
Nikos Mavrogiannopoulos <nmav@gnutls.org>
Orion Poplawski <orion@cora.nwra.com>
Pakin Yury <zxwarior@yandex.ru>
Patrick Donnelly <batrick@batbytes.com>
Paul Eggert <eggert@cs.ucla.edu>
Paul Pluzhnikov <ppluzhnikov@google.com>
Peter Hurley <peter@hurleysoftware.com>
Peter Wu <peter@lekensteyn.nl>
Petr Gajdos <pgajdos@suse.cz>
Philip Semanchuk <linux_kernel.20.ick@spamgourmet.com>
Rasmus Villemoes <Rasmus.Villemoes@decode.is>
Rich Felker <dalias@aerifal.cx>
Simon Que <sque@chromium.org>
Stephan Bergmann <sbergman@redhat.com>
Stéphane Aulery <lkppo@free.fr>
Stephen Hurd <shurd@sasktel.net>
Vincent Bernat <bernat@luffy.cx>
William Preston <wpreston@suse.de>
Yuri Kozlov <yuray@komyakino.ru>
Zefram <zefram@fysh.org>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

copy_file_range.2
    Anna Schumaker  [Darrick J. Wong, Christoph Hellwig, Michael Kerrisk]
        New page documenting copy_file_range()
            copy_file_range() is a new system call for copying ranges of data
            completely in the kernel.  This gives filesystems an opportunity to
            implement some kind of "copy acceleration", such as reflinks or
            server-side-copy (in the case of NFS).

personality.2
    Michael Kerrisk
        This page has been greatly expanded, to add descriptions of
        personality domains.

fmemopen.3
    Michael Kerrisk  [Adhemerval Zanella]
        Significant reworking of this page:
        * Rework discussion of the (obsolete) binary mode
        * Split open_memstream(3) description into a separate page.
        * Note various fmemopen() bugs that were fixed in glibc 2.22
        * Greatly expand description of 'mode' argument
        * Rework description of 'buf' and 'len' arguments
        * Expand discussion of "current position" for fmemopen() stream

ntp_gettime.3
    Michael Kerrisk
        New page describing ntp_gettime(3) and ntp_gettimex(3)

open_memstream.3
    Michael Kerrisk
        New page created by split of fmemopen(3).
        At the same time, add and rework a few details in the text.

posix_spawn.3
    Bill O. Gallmeister, Michael Kerrisk
        New man page documenting posix_spawn(3) and posix_spawnp(3)

readdir.3
    Michael Kerrisk  [Florian Weimer]
        Split readdir_r() content into separate page
            As suggested by Florian Weimer:

                It may make sense to move this documentation to a separate
                manual page, specific to readdir_r.  This will keep the
                readdir() documentation nice and crisp.  Most programmers
                will never have to consult all these details.
    Michael Kerrisk
        Near complete restructuring of the page and add some further details
    Michael Kerrisk  [Florian Weimer, Rich Felker, Paul Eggert]
        Add a lot more detail on portable use of the 'd_name' field

readdir_r.3
    Michael Kerrisk  [Florian Weimer]
        New page created after split of readdir(3).
    Michael Kerrisk  [Florian Weimer]
        Explain why readdir_r() is deprecated and readdir() is preferred
    Michael Kerrisk  [Florian Weimer]
        Remove misleading code example using pathconf()

lirc.4
    Alec Leamas
        New page documenting lirc device driver


Newly documented interfaces in existing pages
---------------------------------------------

adjtimex.2
    Michael Kerrisk
        Document ntp_adjtime(3)

epoll_ctl.2
    Michael Kerrisk  [Jason Baron]
        Document EPOLLEXCLUSIVE

madvise.2
    Minchan Kim  [Michael Kerrisk]
        Document MADV_FREE
            Document the MADV_FREE flag added to madvise() in Linux 4.5.

proc.5
    Michael Kerrisk
        Document CmaTotal and CmaFree fields of /proc/meminfo
    Michael Kerrisk
        Document additional /proc/meminfo fields
            Document DirectMap4k, DirectMap4M, DirectMap2M, DirectMap1G
    Michael Kerrisk
        Document MemAvailable /proc/meminfo field
    Michael Kerrisk
        Document inotify /proc/PID/fdinfo entries
    Michael Kerrisk
        Document fanotify /proc/PID/fdinfo entries
    Michael Kerrisk
        Add some kernel version numbers for /proc/PID/fdinfo entries
    Michael Kerrisk  [Patrick Donnelly]
        /proc/PID/fdinfo displays the setting of the close-on-exec flag
            Note also the pre-3.1 bug in the display of this info.

socket.7
    Craig Gallek  [Michael Kerrisk, Vincent Bernat]
        Document some BPF-related socket options
            Document the behavior and the first kernel version for each of the
            following socket options:

                SO_ATTACH_FILTER
                SO_ATTACH_BPF
                SO_ATTACH_REUSEPORT_CBPF
                SO_ATTACH_REUSEPORT_EBPF
                SO_DETACH_FILTER
                SO_DETACH_BPF
                SO_LOCK_FILTER


New and changed links
---------------------

isalpha_l.3
    Michael Kerrisk
        New link to isalpha.3

longjmp.3
    Michael Kerrisk
        Replace page with link to setjmp(3), which now incorporates longjmp()

ntp_adjtime.3
    Michael Kerrisk
        New link to adjtimex(2)

ntp_gettimex.3
    Michael Kerrisk
        New link to ntp_gettime.3

open_wmemstream.3
    Michael Kerrisk
        Update link to point to new open_memstream(2) page

posix_spawnp.3
    Michael Kerrisk
        New link to new posix_spawn.3 page

siglongjmp.3
    Michael Kerrisk
        Rewire link to point to setjmp(3)

strerror_l.3
    Michael Kerrisk
        New link to strerror.3
            Fix missing link


Global changes
--------------

Various pages
    Michael Kerrisk
        Update FTM requirements (_DEFAULT_SOURCE)
    Michael Kerrisk
        Update feature test macro requirements
            Update to use _DEFAULT_SOURCE, and also changes brought by
            glibc commit 266865c0e7b79d4196e2cc393693463f03c90bd8.

Various pages
    Michael Kerrisk
        Simplify FTM requirements
            Looking at <features.h> (or feature_test_macros(7)), one can
            see that when _XOPEN_SOURCE is defined with the value 700
            (or greater), then _POSIX_C_SOURCE is defined with the value
            200809L (or greater). Therefore, terms in the man pages such as

                _XOPEN_SOURCE\ >=\ 700 || _POSIX_C_SOURCE\ >=\ 200809L

            can be simplified to:

                _POSIX_C_SOURCE\ >=\ 200809L

Various pages
    Michael Kerrisk
        Simplify FTM requirements
            Looking at <features.h> (or feature_test_macros(7)), one can
            see that when _XOPEN_SOURCE is defined with the value 600
            (or greater), then _POSIX_C_SOURCE is defined with the value
            200112L (or greater). Therefore, terms in the man pages such as

                _XOPEN_SOURCE\ >=\ 600 || _POSIX_C_SOURCE\ >=\ 200112L

            can be simplified to:

                _POSIX_C_SOURCE\ >=\ 200112L

Various pages
    Michael Kerrisk
        Simplify FTM requirements
            _XOPEN_SOURCE implies _POSIX_C_SOURCE >=2, so simplify FTM
            requirements in various pages.

Various pages
    Michael Kerrisk
        Remove "or 'cc -std=c99'" from SYNOPSIS
            Under the FTM requirements all of these pages document the
            requirement for _ISOC99_SOURCE. And feature_test_macros(7) now
            documents that "cc -std=c99" produces the same effect as defining
            _ISOC99_SOURCE. So, all of these pages don't additionally need
            to specify "or 'cc -std=c99'" under the FTM requirements
            in the SYNOPSIS. Removing that redundant text also simplifies
            the SYNOPSIS a little.

Various pages
    Michael Kerrisk
        Simplify FTM requirements
            Looking at <features.h> (or feature_test_macros(7)), one can
            see that when _XOPEN_SOURCE is defined with the value 600
            (or greater), then _POSIX_C_SOURCE is defined with the value
            200112L (or greater). Therefore, terms in the man pages such as

                _XOPEN_SOURCE\ >=\ 600 || _POSIX_C_SOURCE\ >=\ 200112L

            can be simplified to:

                _POSIX_C_SOURCE\ >=\ 200112L

Various pages
    Michael Kerrisk
        Remove references to _XOPEN_SOURCE_EXTENDED in SYNOPSIS
            _XOPEN_SOURCE_EXTENDED is obsolete (it existed in SUSv1, but not
            subsequent standards). _XOPEN_SOURCE >= 500 produces the same
            effects as (_XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED). Modifying
            the SYNOPSIS of various ages that contain:

                _XOPEN_SOURCE\ >=\ 500 ||
                    _XOPEN_SOURCE\ &&\ _XOPEN_SOURCE_EXTENDED

            to just:

                _XOPEN_SOURCE\ >=\ 500

            This has the following benefits:

            a) Simplifying the SYNOPSIS by removing ancient
               historical information.

            b) Preventing users from being misled into using
               _XOPEN_SOURCE_EXTENDED in new source code.

Various pages
    Michael Kerrisk
        Remove mention of the obsolete _POSIX_SOURCE macro from SYNOPSIS
            _POSIX_SOURCE was a POSIX.1-1990 creation that was soon made
            obsolete bu _POSIX_C_SOURCE. Retaining mention of it
            in the feature test macro requirements section of the
            SYNOPSIS doesn't contain important information, and may
            mislead readers into actually trying to use this macro.
            A few mentions of it are maintained in a some pages where
            defining _POSIX_SOURCE inhibits some behavior.

Various sockets-related pages
    Michael Kerrisk  [Carlos O'Donell]
        Use consistent argument/variable names for socket addresses and lengths
            As noted by Carlos, there's quite a bit of inconsistency across
            pages. Use 'addr' and 'addrlen' consistently in variables and
            function arguments.

Various pages
    Michael Kerrisk
        Wording fix: "current file offset" ==> "file offset"
            "File offset" is the preferred POSIX terminology.

Various pages
    Michael Kerrisk
        Word "descriptor" more precisely
            Use either "file descriptor" or "message queue descriptor".

Various pages
    Michael Kerrisk
        ERRORS: add reference to signal(7) in description of EINTR


Changes to individual pages
---------------------------

locale.1
    Marko Myllynen
        Add "locale -c charmap" as an example
            Addresses https://bugzilla.kernel.org/show_bug.cgi?id=104511.

localedef.1
    Marko Myllynen
        Add hint on purpose of --no-archive
            Indicate why using --no-archive might be a good idea. The issue
            is that if you create a custom locale with localedef(1) and put
            it to the locale archive then during the next glibc upgrade the
            locale archive is updated as well and your custom locale is gone.)

accept.2
    Michael Kerrisk
        ERRORS: improve description for EBADF

adjtimex.2
    Michael Kerrisk  [John Stultz]
        Various improvements after feedback from John Stultz
    Michael Kerrisk
        Remove FTM requirements
            It seems that adjtimex() never needed _BSD_SOURCE (and my
            earlier commit 5918743bc8b02b was simply a blunder).
    Michael Kerrisk
        Split EINVAL error cases
    Michael Kerrisk
        Note treatment of out-of-range buf.offset
    Michael Kerrisk
        Don't refer reader to adjtime(3)
            Probably, it's not wise to suggest adjtime(3) as the more
            portable API. Rather, ntp_adjtime(3) should be used.
    Michael Kerrisk  [Naresh Kamboju]
        Update details of buf.offset EINVAL error
    Michael Kerrisk
        SEE ALSO: add ntp_gettime(3)
    Michael Kerrisk
        Improve description of some PPS timex fields
    Michael Kerrisk
        Add ATTRIBUTES section
    William Preston  [Petr Gajdos]
        Update a detail in adjtimex return value description
    Michael Kerrisk
        Note range constraints and clamping for ADJ_FREQUENCY

bdflush.2
    Michael Kerrisk
        Note that glibc support for this system call went away in version 2.23

bind.2
    Michael Kerrisk
        Improve description of ENOENT error

bpf.2
    Michael Kerrisk
        Document close-on-exec semantics
            The close-on-exec file descriptor flag is automatically enabled
            for FDs returned by bpf().

chmod.2
    Michael Kerrisk
        Clarify terminology (file mode versus file permission bits)

chown.2
    Michael Kerrisk
        ERRORS: improve EBADF description

clone.2
unshare.2
    Michael Kerrisk
        Remove mention of _BSD_SOURCE and _SVID_SOURCE
            The right way to expose declarations for these Linux-specific
            system calls was always _GNU_SOURCE. Mentioning the historical
            use of _BSD_SOURCE and _SVID_SOURCE just clouds the issue.

connect.2
    Michael Kerrisk
        ERRORS: improve EBADF description

create_module.2
    Michael Kerrisk
        Glibc 2.23 removed last vestiges of support for this system call

delete_module.2
    Michael Kerrisk
        Glibc 2.23 removed last vestiges of support for this system call

epoll_ctl.2
    Michael Kerrisk
        Document ELOOP error for circular monitoring loops

eventfd.2
    Michael Kerrisk
        Note that eventfd info is available in /proc/PID/fdinfo

execve.2
    Michael Kerrisk  [Krzysztof Adamski]
        Add EPERM error for capabilities check of capability-dumb binaries
    Michael Kerrisk
        Add reference to ld-linux.so(8)
    Michael Kerrisk
        SEE ALSO: add system(3)

fanotify_init.2
    Michael Kerrisk
        Note kernel version that allowed O_CLOEXEC for event_f_flags

fcntl.2
flock.2
    Michael Kerrisk
        SEE ALSO: add lslocks(8)

fcntl.2
    Michael Kerrisk  [Jason Vas Dias]
        Rework description of F_SETOWN
            As suggested by Jason, make it clearer that I/O signalling
            requires the use of both F_SETOWN and O_ASYNC. While we're at,
            make a few other cleanups to the text.
    Michael Kerrisk
        Remove mention of _BSD_SOURCE to get definition of F_SETOWN/F_GETOWN
            This usage went away in glibc 2.20, and the simplest remedy
            is just to omit mention of it.

futex.2
    Michael Kerrisk
        FUTEX_CLOCK_REALTIME can now be used with FUTEX_WAIT

get_kernel_syms.2
    Michael Kerrisk
        Note that glibc does not support this system call

init_module.2
    Michael Kerrisk
        Glibc 2.23 removed last vestiges of support for this system call

ioctl_list.2
    Heinrich Schuchardt
        Include uapi/linux/wireless.h
            Add the list of wireless IOCTLs.
    Heinrich Schuchardt
        Path to sockios.h
            sockios.h is now in include/uapi
    Heinrich Schuchardt
        Add reference to netdevice.7
            netdevice.7 describes most of the IOCTLs of sockios.h
    Heinrich Schuchardt
        Transfer structure (wireless.h IOCTLs)
            The sole parameter to be passed to the wireless.h IOCTLs is
            of type struct iwreq *.

ioperm.2
    Michael Kerrisk  [Alex Henrie]
        ioperm.2: Permissions are inherited across fork(2)
            See https://bugzilla.kernel.org/show_bug.cgi?id=99911

iopl.2
    Michael Kerrisk  [Alex Henrie]
        Permissions are not inherited across fork(2) or preserved on execve(2)
            See https://bugzilla.kernel.org/show_bug.cgi?id=99901

lseek.2
    Michael Kerrisk
        FUSE now supports SEEK_HOLE and SEEK_DATA
    Michael Kerrisk
        NFS supports SEEK_HOLE and SEEK_DATA

    Michael Kerrisk
        SEE ALSO: add open(2)

madvise.2
    Michael Kerrisk
        Clarify MADV_HWPOISON wording to say that it applies to a page range

mknod.2
    Michael Kerrisk
        SEE ALSO: add mknod(1)

mount.2
    Michael Kerrisk
        SEE ALSO: add findmnt(8)

open.2
    Michael Kerrisk
        NOTES: mention existence of proc/PID/fd and /proc/PID/fdinfo
    Mark Post  [Petr Gajdos]
        O_TMPFILE support is now provided bt Btrfs

pipe.2
    Michael Kerrisk  [Eric Blake]
        Note treatment of 'pipefd' on error

poll.2
    Michael Kerrisk  [Josh Triplett]
        Document spurious EAGAIN error that can occur on other systems
            Light reworking of text proposed by Josh Triplett.

readlink.2
    Michael Kerrisk
        Clarify EINVAL error description

recv.2
    Heinrich Schuchardt
        Equivalence to read()
            Describe the recv(2)-read(2) and the recvfrom(2)-recv(2)
            equivalences for zero-valued arguments.
    Michael Kerrisk
        MSG_WAITALL has no effect for datagram sockets

recv.2
cmsg.3
    Nikola Forró
        Fix type of cmsg_len member of cmsghdr structure
            The type shown for cmsg_len member of cmsghdr structure is socklen_t,
            but the actual type used by glibc and the kernel is size_t.
            The information was obtained from glibc source code:
            http://bit.ly/21m1RMp
    Michael Kerrisk
        Note that cmsg_len is typed as socklen_t in POSIX.1


sched_setaffinity.2
    Michael Kerrisk  [Florian Weimer, Florian Weimer]
        Warn that CPU_ALLOC() may allocate a slightly CPU set than requested
    Michael Kerrisk  [Florian Weimer]
        Add reference to CPU_ALLOC(3)

sched_setattr.2
    Michael Kerrisk  [Akihiro Suda]
        EPERM depends on affinity mask of target thread, not calling thread

select.2
    Michael Kerrisk  [Josh Triplett]
        Document spurious EAGAIN error that can occur on other systems
            Light reworking of text proposed by Josh Triplett.
    Nikos Mavrogiannopoulos
        Mention the 'fd_set' size limitation early and refer to poll(2)
            Change this because of the serious limitation of select()
            imposing a limit on the range of file descriptors that can
            be monitored. This is currently mentioned too late in the
            documentation (in the NOTES section). The man page should
            warn early and refer to poll(2) as soon as possible.
    Michael Kerrisk
        Add details on the glibc fixed-size fd_set limitation
            No modern application should use select() on Linux.

select_tut.2
    Michael Kerrisk
        Some readability fixes to example program
    Michael Kerrisk
        Better variable names in example program
    Michael Kerrisk
        Simplify 'if' logic in example program
    Michael Kerrisk
        Use correct type (socklen_t) for addrlen

semctl.2
    Michael Kerrisk  [Davidlohr Bueso, Manfred Spraul, Philip Semanchuk]
        NOTES: note when 'sempid' is set on various implementations
            See https://bugzilla.kernel.org/show_bug.cgi?id=112271 and
            http://thread.gmane.org/gmane.linux.kernel/2162754/
                Subject: [PATCH] Don't set sempid in semctl syscall.
                Date: 2016-02-26 12:21:38 GMT

semop.2
    Michael Kerrisk
        Tweak comment describing 'sempid'

sendfile.2
    Askar Safin
        Fix incorrect description in text referring to splice(2)
    Michael Kerrisk
        SEE ALSO: add copy_file_range(2)

setpgid.2
    Michael Kerrisk
        Correct/simplify FTM requirements for BSD setpgrp() and getpgrp()

signalfd.2
    Michael Kerrisk
        Note that signalfd info is available in /proc/PID/fdinfo

sigprocmask.2
    Michael Kerrisk  [Mike Frysinger]
        Explicitly refer the reader to sigsetops(3)
            This man page did not make it obvious which functions
            should be used for manipulating signals sets, nor where
            those functions were documented.

socketpair.2
    Michael Kerrisk  [Eric Blake]
        Note treatment of 'sv' on error

splice.2
    Askar Safin
        Improve description of 0 return value.
            See https://bugzilla.kernel.org/show_bug.cgi?id=90911

statfs.2
    Michael Kerrisk  [Jakub Wilk]
        Use consistent case for hex constants

sync.2
    Christoph Hellwig
        Clarify description and document the Linux data integrity guarantees

syscall.2
    Mike Frysinger
        Add more architectures and improve error documentation
            Move the error register documentation into the main table rather
            than listing them in sentences after the fact.

            Add sparc error return details.

            Add details for alpha/arc/m68k/microblaze/nios2/powerpc/superh/
            tile/xtensa.

syscalls.2
    Michael Kerrisk
        Add copy_file_range(2)

times.2
    Kondo, Naoya
        Fix an incorrect description in NOTES
            The text has an incorrect description in NOTES, it says
            that (2^32/HZ) - 300 is about 429 million. It is correct
            only if HZ=10 which does not look common today. So just
            removing "(i.e., about 429 million)" is good enough.

truncate.2
    Michael Kerrisk
        SEE ALSO: add truncate(1)

uselib.2
    Michael Kerrisk
        Mention CONFIG_USELIB
    Michael Kerrisk
        Note that glibc does not support this (obsolete) system call

wait.2
wait4.2
    Michael Kerrisk
        Rename the "status" argument to "wstatus"
            The fact that exit(3)/_exit(2) has an argument called
            "status" and the same name is used in the arguments to the
            wait*() calls can a little too easily lead the user into
            thinking that the two arguments hold the same information,
            when of course they don't. So, use a different name
            for the argument of the wait*() functions, to reduce
            the chances of such confusion.

backtrace.3
    Michael Kerrisk  [Martin Gebert]
        Small fixes to example program

clearenv.3
    Michael Kerrisk  [Matt Zimmerman]
        Clarify the use and effect of clearenv()
            See http://bugs.debian.org/679323
    Michael Kerrisk
        Variables can be added to the environment after calling clearenv()

clog10.3
    Michael Kerrisk
        Show an alternative equivalence for clog10()
    Michael Kerrisk
        Update CONFORMING TO
            Fix grammar error and add C11.

dl_iterate_phdr.3
    Michael Kerrisk  [Paul Pluzhnikov]
        Describe 'struct dl_phdr_info' fields added in glibc 2.4
            See https://bugzilla.kernel.org/show_bug.cgi?id=103011
    Michael Kerrisk  [Simon Que]
        Note that first object visited by 'callback' is the main program
            See https://bugzilla.kernel.org/show_bug.cgi?id=94141

errno.3
    Michael Kerrisk
        Add some explanation of ENOENT error

exec.3
    Michael Kerrisk
        SEE ALSO: add system(3)

exp.3
    Michael Kerrisk  [Joachim Wuttke]
        SEE ALSO: add expm1(3)

fopen.3
    Michael Kerrisk
        SEE ALSO: add open_memstream(3)

fts.3
    Michael Kerrisk
        BUGS: glibc-2.23 now has LFS support for the fts functions

gamma.3
    Michael Kerrisk  [Alan Cox]
        gamma() was documented in SVID 2

getaddrinfo.3
    Michael Kerrisk  [Andreas Schwab, Orion Poplawski]
        Update FTM requirements for glibc 2.22
            Since glibc 2.22 getaddrinfo() etc. are only declared for
            POSIX.1-2001 or later.

getcwd.3
    Michael Kerrisk
        SEE ALSO: add pwd(1)

opendir.3
    Michael Kerrisk
        Help the reader by explicitly mentioning the use of readdir(3)

perror.3
    Michael Kerrisk
        Suggest use of strerror(3) in place of deprecated 'sys_errlist'

posix_fallocate.3
    Jérémie Galarneau
        ERRORS: add EINTR
            The glibc implementation of posix_fallocate(), which calls
            fallocate(), may be interrupted. The fallocate() emulation
            also makes use of pread()/pwrite(), which may also be
            interrupted.

posix_memalign.3
    Michael Kerrisk  [Eric Blake]
        Note posix_memalign()'s treatment of 'memptr' on error

pthread_setaffinity_np.3
    Michael Kerrisk
        SEE ALSO: add CPU_SET(3)

queue.3
    Dr. Tobias Quathamer
        Remove double CONFORMING TO section

rcmd.3
    Nikola Forró
        Add missing condition concerning .rhosts file
            The list of conditions determining if iruserok() and ruserok()
            functions automatically fail is incomplete. According to glibc
            source code, the functions also fail if the .rhosts file
            is hard linked anywhere.

setbuf.3
    Michael Kerrisk
        SEE ALSO: add stdbuf(1)

setjmp.3
    Michael Kerrisk
        Rewrite and merge longjmp()/siglongjmp() discussion into this page
            The discussion of nonlocal gotos is much easier to read if
            setjmp() and longjmp() are discussed in the same page. While
            we're at it, rework almost the entire text and add several
            more details.
    Michael Kerrisk
        Note the interactions of longjmp() and non-async-signal-safe functions
            POSIX.1-2008 TC2 adds explicit text on this point.
            See http://austingroupbugs.net/view.php?id=516#c1195
    Michael Kerrisk
        Explain why nonlocal gotos make code harder to maintain
    Michael Kerrisk
        Reword warning on longjmp() to function that has already returned
    Michael Kerrisk
        Remove reference to obsolete _XOPEN_SOURCE_EXTENDED

sleep.3
    Michael Kerrisk
        SEE ALSO: add sleep(1)

strftime.3
    Michael Kerrisk  [Jeremy Harris]
        Note which 'tm' fields are used to calculate each output string
            See https://bugzilla.redhat.com/show_bug.cgi?id=1162218

strlen.3
    Michael Kerrisk  [Alan Aversa]
        CONFORMING TO: add C11

system.3
    Michael Kerrisk
        SEE ALSO: add execve(2)

termios.3
    Dr. Tobias Quathamer
        Document line length in canonical mode
            See https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/drivers/tty/n_tty.c#n1673
            See https://bugs.debian.org/797479
    Michael Kerrisk
        SEE ALSO: add tty(1)
    Michael Kerrisk  [Peter Hurley]
        Further improvements to recent tweaks of canonical mode 4096 char limit

timegm.3
    Michael Kerrisk  [Stephen Hurd, Mats Wichmann]
        Remove sample implementation of timegm()
            Stephen and Mats both question the wisdom of showing a portable
            *non-thread-safe* implementation of timegm(), and I find it
            hard to disagree. So, remove this code.

            See https://bugzilla.kernel.org/show_bug.cgi?id=103701
    Michael Kerrisk
        Expand DESCRIPTION a little

st4.4
    Dr. Tobias Quathamer
        Remove spurious copyright section

tty_ioctl.4
    Michael Kerrisk
        SEE ALSO: add ldattach(1)

elf.5
    Michael Kerrisk  [Gabriel Corona, Mike Frysinger]
        Fix description of STV_PROTECTED
    Michael Kerrisk
        Improve description of STV_DEFAULT
    Michael Kerrisk
        Improve description of STV_HIDDEN
    Chris Pick
        Remove erroneous, duplicate SHN_* section
    Michael Kerrisk  [Chris Pick]
        Reword discussion of range values a little

gai.conf.5
    Michael Kerrisk
        Add VERSIONS section

group.5
    Michael Kerrisk
        SEE ALSO: add groups(2)
        SEE ALSO: add gpasswd(1)
        SEE ALSO: add sg(1)
        SE ALSO: add gshadow(5)
        SEE ALSO: add chgrp(1)

locale.5
    Marko Myllynen  [Mike Frysinger]
        tel + fax are deprecated

nsswitch.conf.5
    Nikola Forró
        Update NSS compatibility mode description

utmp.5
    Michael Kerrisk
        SEE ALSO: add lslogins(1)

aio.7
    Andreas Gruenbacher
        Improve example
            When aio_sigevent.sigev_notify is set to SIGEV_SIGNAL, signal
            handlers called for asynchronous I/O operations will have
            si->si_code set to SI_ASYNCIO.  Check to make sure that
            si->si_value.sival_ptr is defined.

capabilities.7
    Michael Kerrisk
        Explain safety check for capability-dumb binaries
    Michael Kerrisk
        SEE ALSO: add sg(1), su(1)
        SEE ALSO: add id(1), group(5), passwd(5)

credentials.7
    Michael Kerrisk
        SEE ALSO: add groups(2)

environ.7
    Michael Kerrisk
        Describe the Bourne "NAME=value command" syntax
    Michael Kerrisk
        Add some details describing hos shell's environment is initialized
    Michael Kerrisk
        Note that child of fork(2) inherits copy of parent's environment
    Michael Kerrisk
        SEE ALSO: add pam_env(3)

epoll.7
    Michael Kerrisk
        Mention that epoll info is available via /proc/PID/fdinfo

fanotify.7
    Michael Kerrisk
        Refer reader to proc(5) for info on /proc/PID/fdinfo fanotify entries


feature_test_macros.7
    Michael Kerrisk
        Add a summary of some FTM key points
    Michael Kerrisk
        Give an early hint about some macros being defined by default
    Michael Kerrisk
        Clarify relation between _XOPEN_SOURCE >=500 and _XOPEN_SOURCE_EXTENDED
            Emphasize that defining _XOPEN_SOURCE >=500 produces same
            effects as defining  _XOPEN_SOURCE_EXTENDED.
    Michael Kerrisk
        Note that man pages don't mention _XOPEN_SOURCE_EXTENDED
            As per previous commit, mention of _XOPEN_SOURCE_EXTENDED
            has generally been removed from the man pages.
    Michael Kerrisk
        Note effects of "cc -std=c99" and "cc -std=c11"
    Michael Kerrisk
        Clarify some _ISOC99_SOURCE / _DEFAULT_SOURCE details
    Michael Kerrisk
        Clarify that _XOPEN_SOURCE_EXTENDED is obsolete
            Since SUSv2, _XOPEN_SOURCE_EXTENDED is no longer specified
            in the standard.

inotify.7
    Michael Kerrisk
        Refer reader to proc(5) for info on /proc/PID/fdinfo inotify entries

ip.7
    Eric Dumazet
        Document IP_BIND_ADDRESS_NO_PORT socket option

mq_overview.7
    Michael Kerrisk
        Note that the close-on-exec flag is automatically set on MQ descriptors

namespaces.7
    Michael Kerrisk
        SEE ALSO: add lsns(1)
            lsns(1) was recently added in util-linux, probably to appear
            in next release (2.28?).

pipe.7
    Michael Kerrisk  [Jason Vas Dias]
        Clarify that I/O signalling requires use of both F_SETOWN and O_ASYNC
    Michael Kerrisk
        SEE ALSO: add mkfifo(1)

signal.7
    Michael Kerrisk
        Note the interactions of longjmp() and non-async-signal-safe functions
            See http://austingroupbugs.net/view.php?id=516#c1195.

socket.7
    Michael Kerrisk
        SEE ALSO: add pcap(3)
        SEE ALSO: add wireshark(1) and tcpdump(8)

standards.7
    Michael Kerrisk
        Add POSIX.1-2008 TC2 (POSIX.1-2016)

svipc.7
    Michael Kerrisk
        Tweak description of 'sempid'
    Michael Kerrisk
        SEE ALSO: add lsipc(1)

symlink.7
    Michael Kerrisk  [Zefram]
        Some "magic" symlinks have permissions other than 0777
            See https://bugs.debian.org/743525

time.7
    Michael Kerrisk
        SEE ALSO: add timeout(1)
        SEE ALSO: add ntp_adjtime(3) and ntp_gettime(3)

unicode.7
    Dr. Tobias Quathamer
        Document private use areas
            See https://bugs.debian.org/285444

unix.7
    Heinrich Schuchardt
        Add example
            A complete example demonstrating the usage of sockets for local
            interprocess communication is added.
    Michael Kerrisk
        Introduce term "sequenced-packet" for SOCK_SEQPACKET
    Michael Kerrisk
        Some wording improvements


==================== Changes in man-pages-4.06 ====================

Released: 2016-05-09, Oslo


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alexander Miller <alex.miller@gmx.de>
Alon Bar-Lev <alon.barlev@gmail.com>
Benjamin Poirier <bpoirier@suse.com>
Christoph Hellwig <hch@lst.de>
Colin Ian King <colin.king@canonical.com>
Dr. Tobias Quathamer <toddy@debian.org>
Ed Avis <eda@waniasset.com>
Georg Sauthoff <gsauthof@techfak.uni-bielefeld.de>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Jakub Wilk <jwilk@jwilk.net>
Jordan Birks <birkses@hotmail.com>
Marko Myllynen <myllynen@redhat.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Nikola Forró <nforro@redhat.com>
Rasmus Villemoes <linux@rasmusvillemoes.dk>
Serge E. Hallyn <serge@hallyn.com>
Serge Hallyn <serge.hallyn@ubuntu.com>
Valery Reznic <valery_reznic@yahoo.com>
Zubair Lutfullah Kakakhel <Zubair.Kakakhel@imgtec.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

cgroups.7
    Serge Hallyn, Michael Kerrisk
        New page documenting cgroups

cgroup_namespaces.7
    Michael Kerrisk  [Serge Hallyn]
        New page describing cgroup namespaces


Newly documented interfaces in existing pages
---------------------------------------------

clone.2
    Michael Kerrisk
        Document CLONE_NEWCGROUP

readv.2
    Christoph Hellwig
        Document preadv2() and pwritev2()
setns.2
    Michael Kerrisk
        Document CLONE_NEWCGROUP

unshare.2
    Michael Kerrisk
        Document CLONE_NEWCGROUP


Changes to individual pages
---------------------------

clock_getres.2
    Michael Kerrisk  [Rasmus Villemoes]
        Note that coarse clocks need architecture and VDSO support

clone.2
fork.2
    Nikola Forró
        Document ERESTARTNOINTR error code

clone.2
    Michael Kerrisk  [Colin Ian King]
        ERRORS: add EINVAL for improperly aligned 'child_stack' value

execve.2
    Michael Kerrisk  [Valery Reznic]
        Since Linux 2.6.28, recursive script interpretation is supported

fcntl.2
    Michael Kerrisk
        Note that mandatory locking is now governed by a configuration option

fsync.2
    Michael Kerrisk  [Georg Sauthoff]
        Give some examples of files where sync can fail with EINVAL

getrlimit.2
    Michael Kerrisk
        SEE ALSO: add cgroups(7)

ioctl_fat.2
    Heinrich Schuchardt
        Use %04x to print volume ID
            Leading zeroes should be used when display a FAT volume ID.

ioprio_set.2
    Michael Kerrisk
        SEE ALSO: add cgroups(7)

lseek.2
    Michael Kerrisk
        Note that 'off_t' is an integer data type defined by POSIX

memfd_create.2
    Michael Kerrisk
        Note that memfd_create() does not have a glibc wrapper

mount.2
    Michael Kerrisk
        MS_MANDLOCK requires CAP_SYS_ADMIN (since Linux 4.5)

quotactl.2
    Michael Kerrisk
        Document Q_GETNEXTQUOTA and Q_XGETNEXTQUOTA
    Michael Kerrisk
        Rework/reorder ERRORS list
            Make into a single alphabetically ordered list
    Michael Kerrisk
        Note kernel version that removed Q_GETSTATS
    Michael Kerrisk
        Add kernel version for G_GETINFO, Q_SETINFO, and Q_GETFMT

readv.2
    Michael Kerrisk
        Clarify that 'size_t' and 'ssize_t' are integer types specified in POSIX

semctl.2
    Michael Kerrisk
        From kernel 4.6, Linux now updates 'sempid' on SETALL operations

sigaction.2
    Michael Kerrisk
        Document SEGV_BNDERR
    Michael Kerrisk
        Document SEGV_PKUERR

syscalls.2
    Michael Kerrisk
        Add preadv2() and pwritev2()

write.2
    Michael Kerrisk
        Clarify that 'size_t' and 'ssize_t' are integer types specified in POSIX

makedev.3
    Mike Frysinger
        Use <sys/sysmacros.h> in SYNOPSIS
            Defining these functions via <sys/types.h> causes problems for
            some folk. As noted by Zack Wein:

                libstdc++ force-enables _GNU_SOURCE, which means people
                writing in C++ _can't_ avoid these nonstandard macros by
                using a strict conformance mode.

            Since glibc has basically always used <sys/sysmacros.h>,
            update the docs to have people include that instead.
    Michael Kerrisk
        NOTES: mention that <sys/types.h> may also define these macros

popen.3
    Nikola Forró
        RETURN VALUE: describe successful case
            Reference:
            http://pubs.opengroup.org/onlinepubs/9699919799/functions/popen.html
            http://pubs.opengroup.org/onlinepubs/9699919799/functions/pclose.html

strtod.3
    Michael Kerrisk  [Ed Avis]
        Improve a detail in RETURN VALUE

core.5
    Michael Kerrisk
        Document /proc/sys/kernel/core_pipe_limit

locale.5
    Marko Myllynen
        Adjust LC_IDENTIFICATION / abbreviation
            Tiny tweak to locale.5 based on the on ISO/IEC TR 14652:

            http://www.open-std.org/jtc1/SC22/WG20/docs/n972-14652ft.pdf
    Marko Myllynen
        Update LC_ADDRESS after glibc change
            This patch updates locale.5 to match the recent glibc change
            in commit a837257199ffab76237385b830cc7b6179fc2f18
    Marko Myllynen
        Complete LC_COLLATE
            Here's the first attempt to (almost) complete the locale.5 manual
            page by documenting all (but perhaps one) of the missing
            LC_COLLATE keywords.
    Mike Frysinger
        country_car: Add a better description


nsswitch.conf.5
    Marko Myllynen
        Document group merging
            Document the recently merged glibc group merge support.
            Glibc commit ced8f8933673f4efda1d666d26a1a949602035ed
            https://sourceware.org/glibc/wiki/Proposals/GroupMerging

proc.5
    Michael Kerrisk
        Move /proc/PID/cgroup discussion to cgroups(7) page
    Michael Kerrisk
        Add some background on why /proc/PID/mountinfo was added
    Michael Kerrisk
        Improve description of /proc/PID/mountinfo 'root' field
    Michael Kerrisk
        Add pointer to cgroups(7) for documentation of /proc/cgroups
    Michael Kerrisk
        Add reference to core(5) for info on /proc/sys/kernel/core_pipe_limit

cpuset.7
    Michael Kerrisk
        SEE ALSO: add cgroups(7)

ip.7
    Benjamin Poirier
        Fix incorrect sockopt name
            "IP_LEAVE_GROUP" does not exist. It was perhaps a confusion with
            MCAST_LEAVE_GROUP. Change the text to IP_DROP_MEMBERSHIP which has
            the same function as MCAST_LEAVE_GROUP and is documented in the
            ip.7 man page.

            Reference:
            Linux kernel net/ipv4/ip_sockglue.c do_ip_setsockopt()

namespaces.7
    Michael Kerrisk
        SEE ALSO: add cgroups(7), cgroup_namespaces(7)

vdso.7
    Zubair Lutfullah Kakakhel  [Mike Frysinger]
        Update for MIPS
            Document the symbols exported by the MIPS VDSO.
            VDSO support was added from kernel 4.4 onwards.

            See https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/log/arch/mips/vdso
    Michael Kerrisk  [Rasmus Villemoes]
        The __kernel_clock_* interfaces don't support *_COARSE clocks on PowerPC

ld.so.8
    Michael Kerrisk  [Alon Bar-Lev]
        Document use of $ORIGIN, $LIB, and $PLATFORM in environment variables
            These strings are meaningful in LD_LIBRARY_PATH and LD_PRELOAD.


==================== Changes in man-pages-4.07 ====================

Released: 2016-07-17, Ulm


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Alec Leamas <leamas.alec@gmail.com>
Andrey Vagin <avagin@openvz.org>
Andy Lutomirski <luto@amacapital.net>
Carsten Grohmann <carstengrohmann@gmx.de>
Chris Gassib <position0x45@hotmail.com>
Christoph Hellwig <hch@lst.de>
Darren Hart <dvhart@infradead.org>
Darrick J. Wong <darrick.wong@oracle.com>
Élie Bouttier <elie@bouttier.eu>
Eric Biggers <ebiggers3@gmail.com>
Eric W. Biederman <ebiederm@xmission.com>
Florian Weimer <fweimer@redhat.com>
Håkon Sandsmark <hsandsma@cisco.com>
Iustin Pop <iustin@k1024.org>
Jacob Willoughby <jacob@spacemonkey.com>
Jakub Wilk <jwilk@jwilk.net>
James H Cownie <james.h.cownie@intel.com>
Jann Horn <jann@thejh.net>
John Wiersba <jrw32982@yahoo.com>
Jörn Engel <joern@purestorage.com>
Josh Triplett <josh@kernel.org>
Kai Mäkisara <kai.makisara@kolumbus.fi>
Kees Cook <keescook@chromium.org>
Keno Fischer <keno@juliacomputing.com>
Li Peng <lip@dtdream.com>
Marko Kevac <marko@kevac.org>
Marko Myllynen <myllynen@redhat.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Michał Zegan <webczat_200@poczta.onet.pl>
Miklos Szeredi <mszeredi@redhat.com>
Mitch Walker <mitch@gearnine.com>
Neven Sajko <nsajko@gmail.com>
Nikos Mavrogiannopoulos <nmav@redhat.com>
Omar Sandoval <osandov@fb.com>
Ori Avtalion <ori@avtalion.name>
Rahul Bedarkar <rahulbedarkar89@gmail.com>
Robin Kuzmin <kuzmin.robin@gmail.com>
Rob Landley <rob@landley.net>
Shawn Landden <shawn@churchofgit.com>
Stefan Puiu <stefan.puiu@gmail.com>
Stephen Smalley <sds@tycho.nsa.gov>
Szabolcs Nagy <szabolcs.nagy@arm.com>
Thomas Gleixner <tglx@linutronix.de>
Tobias Stoeckmann <tobias@stoeckmann.org>
Tom Callaway <tcallawa@redhat.com>
Tom Gundersen <teg@jklm.no>
Vince Weaver <vincent.weaver@maine.edu>
W. Trevor King <wking@tremily.us>
"Yuming Ma(马玉明)" <mayuming@le.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

ioctl_fideduperange.2
    Darrick J. Wong  [Christoph Hellwig, Michael Kerrisk]
        New page documenting the FIDEDUPERANGE ioctl
            Document the FIDEDUPERANGE ioctl, formerly known as
            BTRFS_IOC_EXTENT_SAME.

ioctl_ficlonerange.2
    Darrick J. Wong  [Christoph Hellwig, Michael Kerrisk]
        New page documenting FICLONE and FICLONERANGE ioctls
            Document the FICLONE and FICLONERANGE ioctls, formerly known as
            the BTRFS_IOC_CLONE and BTRFS_IOC_CLONE_RANGE ioctls.

nextup.3
    Michael Kerrisk
        New page documenting nextup(), nextdown(), and related functions

mount_namespaces.7
    Michael Kerrisk  [Michael Kerrisk]
        New page describing mount namespaces


Newly documented interfaces in existing pages
---------------------------------------------

mount.2
    Michael Kerrisk
        Document flags used to set propagation type
            Document MS_SHARED, MS_PRIVATE, MS_SLAVE, and MS_UNBINDABLE.
    Michael Kerrisk
        Document the MS_REC flag

ptrace.2
    Michael Kerrisk  [Kees Cook, Jann Horn, Eric W. Biederman, Stephen Smalley]
        Document ptrace access modes

proc.5
    Michael Kerrisk
        Document /proc/[pid]/timerslack_ns
    Michael Kerrisk
        Document /proc/PID/status 'Ngid' field
    Michael Kerrisk
        Document /proc/PID/status fields: 'NStgid', 'NSpid', 'NSpgid', 'NSsid'
    Michael Kerrisk
        Document /proc/PID/status 'Umask' field


New and changed links
---------------------

preadv2.2
pwritev2.2
    Michael Kerrisk
        New links to readv(2)

nextdown.3
nextdownf.3
nextdownl.3
nextupf.3
nextupl.3
    Michael Kerrisk
        New links to nextup(3)


Changes to individual pages
---------------------------

ldd.1
    Michael Kerrisk
        Add a little more detail on why ldd is unsafe with untrusted executables
    Michael Kerrisk
        Add more detail on the output of ldd

localedef.1
    Marko Myllynen
        Drop --old-style description
            The glibc upstream decided to drop localedef(1) --old-style
            option [1] altogether, I think we can do the same with
            localedef(1), the option hasn't done anything in over 16
            years and I doubt anyone uses it.

add_key.2
    Mitch Walker
        Empty payloads are not allowed in user-defined keys

chroot.2
    Michael Kerrisk
        SEE ALSO: add pivot_root(2)

clone.2
    Michael Kerrisk
        Add reference to mount_namespaces(7) under CLONE_NEWNS description

fork.2
    Michael Kerrisk
        Add ENOMEM error for PID namespace where "init" has died

futex.2
    Michael Kerrisk
        Correct an ENOSYS error description
            Since Linux 4.5, FUTEX_CLOCK_REALTIME is allowed with FUTEX_WAIT.
    Michael Kerrisk  [Darren Hart]
        Remove crufty text about FUTEX_WAIT_BITSET interpretation of timeout
            Since Linux 4.5, FUTEX_WAIT also understands
            FUTEX_CLOCK_REALTIME.
    Michael Kerrisk  [Thomas Gleixner]
        Explain how to get equivalent of FUTEX_WAIT with an absolute timeout
    Michael Kerrisk
        Describe FUTEX_BITSET_MATCH_ANY
            Describe FUTEX_BITSET_MATCH_ANY and FUTEX_WAIT and FUTEX_WAKE
            equivalences.
    Michael Kerrisk
        Note that at least one bit must be set in mask for BITSET operations
            At least one bit must be set in the 'val3' mask supplied for the
            FUTEX_WAIT_BITSET and FUTEX_WAKE_BITSET operations.
    Michael Kerrisk  [Thomas Gleixner, Darren Hart]
        Fix descriptions of various timeouts
    Michael Kerrisk
        Clarify clock default and choices for FUTEX_WAIT

getitimer.2
    Michael Kerrisk
        Substantial rewrites to various parts of the page
    Michael Kerrisk  [Tom Callaway]
        Change license to note that page may be modified
            The page as originally written carried text that said the page may
            be freely distributed but made no statement about modification.
            In the 20+ years since it was first written, the page has in fact
            seen repeated, sometimes substantial, modifications, and only a
            small portion of the original text remains. One could I suppose
            rewrite the last few pieces that remain from the original,
            but as the largest contributor to the pages existing text,
            I'm just going to relicense it to explicitly note that
            modification is permitted. (I presume the failure by the
            original author to grant permission to modify was simply an
            oversight; certainly, the large number of people who have
            changed the page have taken that to be the case.)

            See also https://bugzilla.kernel.org/show_bug.cgi?id=118311

get_mempolicy.2
    Michael Kerrisk  [Jörn Engel]
        Correct rounding to 'maxnodes' (bits, not bytes)
    Michael Kerrisk  [Jörn Engel]
        Fix prototype for get_mempolicy()
            In numaif.h, 'addr' is typed as 'void *'

getpriority.2
    Michael Kerrisk
        Make discussion of RLIMIT_NICE more prominent
            The discussion of RLIMIT_NICE was hidden under the EPERM error,
            where it was difficult to find. Place some relevant text in
            DESCRIPTION.
    Michael Kerrisk
        Note that getpriority()/setpriority deal with same attribute as nice(2)
    Michael Kerrisk  [Robin Kuzmin]
        Clarify equivalence between lower nice value and higher priority

get_robust_list.2
    Michael Kerrisk
        get_robust_list() is governed by PTRACE_MODE_READ_REALCREDS

ioctl.2
    Michael Kerrisk
        SEE ALSO: add ioctl_fideduperange(2) and ioctl_ficlonerange(2)

kcmp.2
    Michael Kerrisk
        kcmp() is governed by PTRACE_MODE_READ_REALCREDS
    Shawn Landden
        Note about SECURITY_YAMA
kill.2
    Michael Kerrisk  [John Wiersba]
        Clarify the meaning if sig==0

lookup_dcookie.2
    Michael Kerrisk
        SEE ALSO: add oprofile(1)

mmap.2
    Michael Kerrisk  [Rahul Bedarkar]
        EXAMPLE: for completeness, add munmap() and close() calls

mount.2
    Michael Kerrisk
        Restructure discussion of 'mountflags' into functional groups
            The existing text makes no differentiation between different
            "classes" of mount flags. However, certain flags such as
            MS_REMOUNT, MS_BIND, MS_MOVE, etc. determine the general
            type of operation that mount() performs. Furthermore, the
            choice of which class of operation to perform is performed in
            a certain order, and that order is significant if multiple
            flags are specified. Restructure and extend the text to
            reflect these details.
    Michael Kerrisk
        Relocate text on multimounting and mount stacking to NOTES
            The text was somewhat out of place in its previous location;
            NOTES is a better location.
    Michael Kerrisk
        Remove version numbers attached to flags that are modifiable on remount
            This information was simply bogus. Mea culpa.
    Michael Kerrisk
        Refer reader to mount_namespaces(7) for details on propagation types
    Michael Kerrisk
        SEE ALSO: s/namespaces(7)/mount_namespaces(7)/
    Omar Sandoval
        MS_BIND still ignores mountflags
            This is clear from the do_mount() function in the kernel as of v4.6.
    Michael Kerrisk
        Note the default treatment of ATIME flags during MS_REMOUNT
            The behavior changed in Linux 3.17.
    Michael Kerrisk
        Clarify that MS_MOVE ignores remaining bits in 'mountflags'
    Michael Kerrisk
        Note kernel version that added MS_MOVE
    Michael Kerrisk
        MS_NOSUID also disables file capabilities
    Michael Kerrisk
        Relocate/demote/rework text on MS_MGC_VAL
            The use of this constant has not been needed for 15 years now.
    Michael Kerrisk
        Clarify that 'source' and 'target' are pathnames, and can refer to files
    Michael Kerrisk
        Update example list of filesystem types
            Put more modern examples in; remove many older examples.
    Michael Kerrisk
        MS_LAZYTIME and MS_RELATIME can be changed on remount
    Michael Kerrisk
        Explicitly note that MS_DIRSYNC setting cannot be changed on remount
    Michael Kerrisk
        Move text describing 'data' argument higher up in page
            In preparation for other reworking.
    Michael Kerrisk
        Since Linux 2.6.26, bind mounts can be made read-only

open.2
    Eric Biggers
        Refer to correct functions in description of O_TMPFILE

pciconfig_read.2
    Michael Kerrisk  [Tom Callaway]
        Change license to note that page may be modified
            Niki Rahimi, the author of this page, has agreed that it's okay
            to change the license to note that the page can be modified.

            See https://bugzilla.kernel.org/show_bug.cgi?id=118311

perf_event_open.2
    Michael Kerrisk
        If pid > 0, the operation is governed by PTRACE_MODE_READ_REALCREDS
    Jann Horn
        Document new perf_event_paranoid default
    Keno Fischer  [Vince Weaver]
        Add a note that dyn_size is omitted if size == 0
            The perf_output_sample_ustack in kernel/events/core.c only writes
            a single 64 bit word if it can't dump the user registers. From the
            current version of the man page, I would have expected two 64 bit
            words (one for size, one for dyn_size). Change the man page to
            make this behavior explicit.

prctl.2
    Michael Kerrisk
        Some wording improvements in timer slack description
    Michael Kerrisk
        Refer reader to discussion of /proc/[pid]/timerslack_ns
            Under discussion of PR_SET_TIMERSLACK, refer the reader to
            the /proc/[pid]/timerslack_ns file, documented in proc(5).

process_vm_readv.2
    Michael Kerrisk
        Rephrase permission rules in terms of a ptrace access mode check

ptrace.2
    Michael Kerrisk  [Jann Horn]
        Update Yama ptrace_scope documentation
            Reframe the discussion in terms of PTRACE_MODE_ATTACH checks,
            and make a few other minor tweaks and additions.
    Michael Kerrisk, Jann Horn
        Note that user namespaces can be used to bypass Yama protections
    Michael Kerrisk
        Note that PTRACE_SEIZE is subject to a ptrace access mode check
    Michael Kerrisk
        Rephrase PTRACE_ATTACH permissions in terms of ptrace access mode check

quotactl.2
    Michael Kerrisk  [Jacob Willoughby]
        'dqb_curspace' is in bytes, not blocks
            This error appears to have been injected into glibc
            when copying some headers from BSD.

            See https://bugs.debian.org/825548

recv.2
    Michael Kerrisk  [Tom Gundersen]
        With pending 0-length datagram read() and recv() with flags == 0 differ

setfsgid.2
setfsuid.2
    Jann Horn  [Michael Kerrisk]
        Fix note about errors from the syscall wrapper
            See sysdeps/unix/sysv/linux/i386/setfsuid.c in glibc-2.2.1.
            (This code is not present in modern glibc anymore.)
    Michael Kerrisk
        Move glibc wrapper notes to "C library/kernel differences" subsection

sysinfo.2
    Michael Kerrisk
        Rewrite and update various pieces

umask.2
    Michael Kerrisk
        NOTES: Mention /proc/PID/status 'Umask' field

umount.2
    Michael Kerrisk
        SEE ALSO: add mount_namespaces(7)

unshare.2
    Michael Kerrisk
        Add reference to mount_namespaces(7) under CLONE_NEWNS description

utimensat.2
    Michael Kerrisk  [Rob Landley]
        Note that the glibc wrapper disallows pathname==NULL

wait.2
    Michael Kerrisk
        Since Linux 4.7, __WALL is implied if child being ptraced
    Michael Kerrisk
        waitid() now (since Linux 4.7) also supports __WNOTHREAD/__WCLONE/__WALL

assert.3
    Nikos Mavrogiannopoulos
        Improved description
            Removed text referring to text not being helpful to users. Provide
            the error text instead to allow the reader to determine whether it
            is helpful.  Recommend against using NDEBUG for programs to
            exhibit deterministic behavior.  Moved description ahead of
            recommendations.
    Michael Kerrisk
        Clarify details of message printed by assert()

fmax.3
fmin.3
    Michael Kerrisk
        SEE ALSO: add fdim(3)

getauxval.3
    Cownie, James H
        Correct AT_HWCAP result description

inet_pton.3
    Stefan Puiu
        Mention byte order

malloc_hook.3
    Michael Kerrisk
        glibc 2.24 removes __malloc_initialize_hook

memmem.3
    Michael Kerrisk  [Shawn Landden]
        Note that memmem() is present on some other systems

mkdtemp.3
mktemp.3
    Michael Kerrisk
        SEE ALSO: add mktemp(1)

printf.3
    Michael Kerrisk  [Shawn Landden]
        Note support in other C libraries for %m and %n

strcasecmp.3
    Michael Kerrisk  [Ori Avtalion]
        Make details of strncasecmp() comparison clearer

strcat.3
    Michael Kerrisk
        Add a program that shows the performance characteristics of strcat()
            In honor of Joel Spolksy's visit to Munich, let's start educating
            Schlemiel The Painter.

strtoul.3
    Michael Kerrisk
        SEE ALSO: add a64l(3)

strxfrm.3
    Michael Kerrisk  [Florian Weimer]
        Remove NOTES section
            strxfrm() and strncpy() are not precisely equivalent in the
            POSIX locale, so this NOTES section was not really correct.

            See https://bugzilla.kernel.org/show_bug.cgi?id=104221

console_codes.4
console_ioctl.4
tty.4
vcs.4
charsets.7
    Marko Myllynen
        Remove console(4) references
            0f9e647 removed the obsolete console(4) page but we still have few
            references to it. The patch below removes them or converts to refs
            to console_ioctl(4) where appropriate.

console_ioctl.4
    Michael Kerrisk  [Chris Gassib]
        The argument to KDGETMODE is an 'int'

lirc.4
    Alec Leamas
        Update after upstreamed lirc.h, bugfixes.

st.4
    Kai Mäkisara
        Fix description of read() when block is larger than request
    Kai Mäkisara
        Update MTMKPART for kernels >= 4.6
            Update the description of the MTMKPART operation of MTIOCTOP to match
            the changes in kernel version 4.6.

charmap.5
    Marko Myllynen
        Clarify keyword syntax
            Updates charmap(5) to match the syntax all the glibc
            charmap files are using currently.

elf.5
    Michael Kerrisk
        SEE ALSO: add readelf(1)

locale.5
    Marko Myllynen
        Document missing keywords, minor updates
    Marko Myllynen
        Clarify keyword syntax
    Marko Myllynen
        Adjust conformance

proc.5
namespaces.7
    Michael Kerrisk
        Move /proc/PID/mounts information to proc(5)
            There was partial duplication, and some extra information
            in namespaces(7). Move everything to proc(5).

proc.5
    Michael Kerrisk
        /proc/PID/fd/* are governed by PTRACE_MODE_READ_FSCREDS
            Permission to dereference/readlink /proc/PID/fd/* symlinks is
            governed by a PTRACE_MODE_READ_FSCREDS ptrace access mode check.
    Michael Kerrisk
        /proc/PID/timerslack_ns is governed by PTRACE_MODE_ATTACH_FSCREDS
            Permission to access /proc/PID/timerslack_ns is governed by
            a PTRACE_MODE_ATTACH_FSCREDS ptrace access mode check.
    Michael Kerrisk
        Document /proc/PID/{maps,mem,pagemap} access mode checks
            Permission to access /proc/PID/{maps,pagemap} is governed by a
            PTRACE_MODE_READ_FSCREDS ptrace access mode check.

            Permission to access /proc/PID/mem is governed by a
            PTRACE_MODE_ATTACH_FSCREDS ptrace access mode check.
    Michael Kerrisk
        Note /proc/PID/stat fields that are governed by PTRACE_MODE_READ_FSCREDS
    Michael Kerrisk
        /proc/PID/{cwd,exe,root} are governed by PTRACE_MODE_READ_FSCREDS
            Permission to dereference/readlink /proc/PID/{cwd,exe,root} is
            governed by a PTRACE_MODE_READ_FSCREDS ptrace access mode check.
    Michael Kerrisk
        /proc/PID/io is governed by PTRACE_MODE_READ_FSCREDS
            Permission to access /proc/PID/io is governed by
            a PTRACE_MODE_READ_FSCREDS ptrace access mode check.
    Michael Kerrisk
        /proc/PID/{personality,stack,syscall} are governed by PTRACE_MODE_ATTACH_FSCREDS
            Permission to access /proc/PID/{personality,stack,syscall} is
            governed by a PTRACE_MODE_ATTACH_FSCREDS ptrace access mode check.
    Michael Kerrisk
        /proc/PID/{auxv,environ,wchan} are governed by PTRACE_MODE_READ_FSCREDS
            Permission to access /proc/PID/{auxv,environ,wchan} is governed by
            a PTRACE_MODE_READ_FSCREDS ptrace access mode check.
    Michael Kerrisk
        Move shared subtree /proc/PID/mountinfo fields to mount_namespaces(7)
            Move information on shared subtree fields in /proc/PID/mountinfo
            to mount_namespaces(7).
    Michael Kerrisk  ["Yuming Ma(马玉明)"]
        Note that /proc/net is now virtualized per network namespace
    Michael Kerrisk
        Add references to mount_namespaces(7)

repertoiremap.5
    Marko Myllynen
        Clarify keyword syntax

utmp.5
    Michael Kerrisk
        SEE ALSO: add logname(1)

capabilities.7
    Michael Kerrisk  [Andy Lutomirski]
        Note on SECURE_NO_CAP_AMBIENT_RAISE for capabilities-only environment
    Michael Kerrisk
        Add a detail on use of securebits

cgroup_namespaces.7
    Michael Kerrisk
        SEE ALSO: add namespaces(7)

cgroups.7
    Michael Kerrisk
        ERRORS: add mount(2) EBUSY error

cp1251.7
cp1252.7
iso_8859-1.7
iso_8859-15.7
iso_8859-5.7
koi8-r.7
koi8-u.7
    Marko Myllynen
        Add some charset references
            Add some references to related charsets here and there.

credentials.7
    Michael Kerrisk
        SEE ALSO: add runuser(1)
        SEE ALSO: add newgrp(1)
        SEE ALSO: add sudo(8)

feature_test_macros.7
    Michael Kerrisk
        Emphasize that applications should not directly include <features.h>

man-pages.7
    Michael Kerrisk
        Clarify which sections man-pages provides man pages for
    Michael Kerrisk  [Josh Triplett]
        Add a few more details on formatting conventions
            Add some more details for Section 1 and 8 formatting.
            Separate out formatting discussion into commands, functions,
            and "general".

namespaces.7
    Michael Kerrisk
        /proc/PID/ns/* are governed by PTRACE_MODE_READ_FSCREDS
            Permission to dereference/readlink /proc/PID/ns/* symlinks is
            governed by a PTRACE_MODE_READ_FSCREDS ptrace access mode check.
    Michael Kerrisk
        Nowadays, file changes in /proc/PID/mounts are notified differently
            Exceptional condition for select(), (E)POLLPRI for (e)poll
    Michael Kerrisk
        Remove /proc/PID/mountstats description
            This is a duplicate of information in proc(5).
    Michael Kerrisk
        Refer to new mount_namespaces(7) for information on mount namespaces

netlink.7
    Andrey Vagin
        Describe netlink socket options
    Michael Kerrisk
        Rework version information
            (No changes in technical details.)

pid_namespaces.7
    Michael Kerrisk
        SEE ALSO: add namespaces(7)

unix.7
    Michael Kerrisk
        Move discussion on pathname socket permissions to DESCRIPTION
    Michael Kerrisk
        Expand discussion of socket permissions
    Michael Kerrisk
        Fix statement about permissions needed to connect to a UNIX domain socket
            Read permission is not required (verified by experiment).
    Michael Kerrisk
        Clarify ownership and permissions assigned during socket creation
    Michael Kerrisk  [Carsten Grohmann]
        Update text on socket permissions on other systems
            At least some of the modern BSDs seem to check for write
            permission on a socket. (I tested OpenBSD 5.9.) On Solaris 10,
            some light testing suggested that write permission is still
            not checked on that system.
    Michael Kerrisk
        Note that umask / permissions have no effect for abstract sockets
    W. Trevor King
        Fix example code: 'ret' check after accept populates 'data_socket'
    Michael Kerrisk
        Move some abstract socket details to a separate subsection
    Michael Kerrisk
        Note that abstract sockets automatically disappear when FDs are closed

user_namespaces.7
    Michael Kerrisk  [Michał Zegan]
        Clarify meaning of privilege in a user namespace
            Having privilege in a user NS only allows privileged
            operations on resources governed by that user NS. Many
            privileged operations relate to resources that have no
            association with any namespace type, and only processes
            with privilege in the initial user NS can perform those
            operations.

            See https://bugzilla.kernel.org/show_bug.cgi?id=120671
    Michael Kerrisk  [Michał Zegan]
        List the mount operations permitted by CAP_SYS_ADMIN
            List the mount operations permitted by CAP_SYS_ADMIN in a
            noninitial userns.

            See https://bugzilla.kernel.org/show_bug.cgi?id=120671
    Michael Kerrisk  [Michał Zegan]
        CAP_SYS_ADMIN allows mounting cgroup filesystems
            See https://bugzilla.kernel.org/show_bug.cgi?id=120671
    Michael Kerrisk
        Clarify details of CAP_SYS_ADMIN and cgroup v1 mounts
            With respect to cgroups version 1, CAP_SYS_ADMIN in the user
            namespace allows only *named* hierarchies to be mounted (and
            not hierarchies that have a controller).
    Michael Kerrisk
        Clarify CAP_SYS_ADMIN details for mounting FS_USERNS_MOUNT filesystems
    Michael Kerrisk
        Correct user namespace rules for mounting /proc
    Michael Kerrisk
        Describe a concrete example of capability checking
            Add a concrete example of how the kernel checks capabilities in
            an associated user namespace when a process attempts a privileged
            operation.
    Michael Kerrisk
        Correct kernel version where XFS added support for user namespaces
            Linux 3.12, not 3.11.
    Michael Kerrisk
        SEE ALSO: add ptrace(2)
        SEE ALSO: add cgroup_namespaces(7)

utf-8.7:
    Shawn Landden
        Include RFC 3629 and clarify endianness which is left ambiguous
            The endianness is suggested by the order the bytes are displayed,
            but the text is ambiguous.


==================== Changes in man-pages-4.08 ====================

Released: 2016-10-08, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Arnaud Gaillard <arnaud.mgaillard@gmail.com>
Bill Pemberton <wfp5p@worldbroken.com>
Carlos O'Donell <carlos@redhat.com>
Christoph Hellwig <hch@lst.de>
David Turner <novalis@novalis.org>
Dr. Tobias Quathamer <toddy@debian.org>
Elliott Hughes <enh@google.com>
Eugene Syromyatnikov <evgsyr@gmail.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Hu Keping <hukeping@huawei.com>
Igor Liferenko <igor.liferenko@gmail.com>
Ivan Kharpalev <ivan.kharpalev@gmail.com>
Jakub Wilk <jwilk@jwilk.net>
Jann Horn <jann@thejh.net>
Josh Triplett <josh@joshtriplett.org>
Keno Fischer <keno@juliacomputing.com>
Laurent Georget <laurent.georget@supelec.fr>
Local Lembke <logan@blackhillsinfosec.com>
Mats Wichmann <mats@wichmann.us>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Crowe <mac@mcrowe.com>
Mike Frysinger <vapier@gentoo.org>
Namhyung Kim <namhyung@gmail.com>
Nikola Forró <nforro@redhat.com>
Patrick McLean <patrickm@gaikai.com>
Peter Wu <peter@lekensteyn.nl>
Petr Cermak <petrcermak@chromium.org>
Quentin Rameau <quinq@fifth.space>
Ray Bellis <ray@isc.org>
Rich Felker <dalias@libc.org>
Ruben Kerkhof <ruben@rubenkerkhof.com>
Sam Varshavchik <mrsam@courier-mta.com>
Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Siward de Groot <siward@wanadoo.nl>
Sloane Bernstein <sloane@cpanel.net>
Stefan Tauner <tauner@technikum-wien.at>
Tim Savannah <kata198@gmail.com>
Ursache Vladimir <f35f22fan@gmail.com>
Zefram <zefram@fysh.org>
王守堰 <wangshouyan@gmail.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

quotactl.2
    Eugene Syromyatnikov  [Michael Kerrisk]
        Updated information regarding disk quota flags
            Added information regarding DQF_SYS_FILE flag; updated definition
            of V1_DQF_RSQUASH, which has been defined privately and defined
            publicly as DQF_ROOT_SQUASH.
    Eugene Syromyatnikov
        Updated information regarding XFS-specific quotactl subcommands
            Added information regarding structure definitions used for
            XFS-specific subcommands, updated flag constants, added
            information regarding ignored syscall arguments, added notes on
            usage of kernel UAPI header.
    Eugene Syromyatnikov
        Additions regarding project quotas
            Added information regarding presence of project quotas.

bswap.3
    Michael Kerrisk
        New page documenting bswap_16(), bswap_32(), and bswap_64()

cgroups.7
    Michael Kerrisk
       Substantial rewrites, additions, and corrections.


Newly documented interfaces in existing pages
---------------------------------------------

readv.2
    Michael Kerrisk
        Document the pwritev2() RWF_SYNC and RWF_DSYNC flags

proc.5
    Michael Kerrisk
        Document /proc/PID/seccomp
    Jann Horn
        Document /proc/[pid]/task/[tid]/children
            Document the /proc/[pid]/task/[tid]/children interface from
            CRIU, and more importantly, document why it's usually not
            a good interface.


New and changed links
---------------------

bswap_16.3
bswap_32.3
bswap_64.3
        New link to new bswap.3


Global changes
--------------

Various pages
    Michael Kerrisk
        Fix section ordering
            Various pages had sections in an order different from
            that prescribed in man-pages(7).

Various pages
    Michael Kerrisk  [Mike Frysinger]
        Consistently use /proc/[pid] (not /proc/PID)

Various pages
    Michael Kerrisk
        Fix order of SEE ALSO entries
            Entries should be ordered first by section, and then alphabetically
            within the section.

Various pages
    Michael Kerrisk
        Order ERRORS alphabetically

Various pages
    Michael Kerrisk
        Remove section number from page self reference
            Fix places where pages refer to the function that they describe
            and include a section number in that reference. Such references
            cause some HTML-rendering tools to create self-references in the
            page.

A few pages
    Michael Kerrisk
        Eliminate groff "cannot adjust line" warnings


Changes to individual pages
---------------------------

pldd.1
    Michael Kerrisk  [Carlos O'Donell]
        Note gdb(1) command that can be used as a replacement for pldd
            Taken from Carlos O'Donnell's suggestion in
            https://sourceware.org/bugzilla/show_bug.cgi?id=18035#c2
    Michael Kerrisk
        BUGS: pldd has not worked since glibc 2.19

accept.2
    Michael Kerrisk
        Mention epoll(7) alongside poll()/select()
    Michael Kerrisk
        Demote discussion of DECNet to NOTES
            DECNet ceased to be important long ago...

adjtimex.2
    Nikola Forró
        Fix kernel version references

chroot.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SYS_CHROOT

clone.2
    Keno Fischer  [Josh Triplett]
        Adjust syscall prototype and expand CLONE_SETTLS description
    Michael Kerrisk  [Josh Triplett, Josh Triplett]
        Document raw syscall interfaces on various other architectures
    Michael Kerrisk
        Change types for 'ptid' and 'ctid' in syscall prototypes
            These types changed from 'void *' to 'int *' back in Linux 3.8.
    Michael Kerrisk
        EINVAL is generated by glibc wrapper for NULL 'fn' or 'child_stack'
            Clarify that this error is produced by the wrapper function, not
            the underlying system call. In particular, the point is that the
            raw system call can accommodate a NULL pointer for 'child_stack'.
    Michael Kerrisk  [Elliott Hughes]
        Make the implications of CLONE_FILES more explicit
            If CLONE_FILES is not set, the duplicated FDs nevertheless share
            file offset and status flags via the open file description.
    Michael Kerrisk
        Mention kcmp() under notes

close.2
    Michael Kerrisk
        Add mention of the close-on-exec flag
    Michael Kerrisk
        Clarify discussion noting that close() does not flush buffer cache

epoll_wait.2
    Mike Crowe
        Clarify that the timeout is measured against CLOCK_MONOTONIC

execve.2
    Michael Kerrisk
        Mention use of 'environ' to access environment list
    Michael Kerrisk
        Note that real UID, real GID, and supplementary GIDs are unchanged

fanotify_init.2
    Heinrich Schuchardt
        Update BUGS information

fcntl.2
    Michael Kerrisk
        Note an important detail of F_SETOWN permission rules for signals
            F_SETOWN records the caller's credentials at the time of
            the fcntl() call, and it is these saved credentials that
            are used for subsequent permission checks.
    Michael Kerrisk
        Make the description of the effect of close-on-exec a little clearer
    Michael Kerrisk
        Clarify that F_GETFD and F_GETFL return flags via the function result

fork.2
    Michael Kerrisk
        PID of new process also does not match any existing session ID

fsync.2
    Michael Kerrisk
        SEE ALSO: add pwritev(2)
            Since Linux 4.7, pwritev() has flags related to I/O
            integrity completion.

getdomainname.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SYS_ADMIN

getgroups.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SETGID

gethostname.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SYS_ADMIN

getrlimit.2
    Michael Kerrisk
        Note user namespace semantics for CAP_SYS_RESOURCE

getsid.2
    Michael Kerrisk
        Rework description to be somewhat clearer
    Michael Kerrisk
        Correct the definition of "session ID"

getunwind.2
    Michael Kerrisk
        Simplify text referring to vdso(7)
            The detail given here is redundant, since this info is also
            in vdso(7).

kcmp.2
    Michael Kerrisk
        Add an example program

kill.2
    Michael Kerrisk
        Note the user namespace requirement for CAP_KILL

killpg.2
    Michael Kerrisk
        Refer reader to kill(2) for signal permission rules

mlock.2
    Sebastian Andrzej Siewior
        Document that fork() after mlock() may be a bad idea in a RT process

mmap.2
    Jann Horn
        Describe treatment of 'offset' for MAP_ANONYMOUS
    Michael Kerrisk  [Siward de Groot]
        Small improvement to description of MAP_SHARED
            See https://sourceware.org/bugzilla/show_bug.cgi?id=6887

msgctl.2
msgget.2
msgop.2
semctl.2
semget.2
semop.2
shmctl.2
shmget.2
shmop.2
    Michael Kerrisk
        Note the user namespace requirements for CAP_IPC_OWNER

open.2
    Michael Kerrisk
        Clarify user namespace capability requirements for O_NOATIME
    Michael Kerrisk
        NOTES: kcmp() can be used to test if two FDs refer to the same OFD
    Michael Kerrisk
        F2FS support for O_TMPFILE was added in Linux 3.16
    Michael Kerrisk
        Clarify the rules about how the group ID of a new file is determined

prctl.2
    Michael Kerrisk
        Refer to proc(5) for effects of dumpability on ownership of /proc/PID/*
    Michael Kerrisk
        ERRORS: Add EACCES error for PR_SET_SECCOMP-SECCOMP_MODE_FILTER
    Michael Kerrisk
        Simplify list of cases where "dumpable" attribute is reset
    Michael Kerrisk
        Note user namespace requirements for PR_CAPBSET_DROP CAP_SETPCAP

readlink.2
    Michael Kerrisk  [Ursache Vladimir]
        Make example program handle links that report a size of zero
            Some "magic" symlinks created by the kernel (e.g., those under
            /proc and /sys) report 'st_size' as zero. Modify the example
            program to handle that possibility.
    Michael Kerrisk
        Emphasize that truncation of returned buffer generates no error

readv.2
    Michael Kerrisk  [Christoph Hellwig]
        Clarify that RWF_DSYNC and RWF_SYNC apply only to data being written
    Michael Kerrisk
        Add preadv2() and pwritev2() to NAME line

reboot.2
    Michael Kerrisk
        Note user namespace requirements around CAP_SYS_BOOT

rename.2
    Michael Kerrisk  [Tim Savannah]
        Clarify that ERRORS may cause rename to fail (not to be nonatomic)

sched_setaffinity.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SYS_NICE

seccomp.2
    Michael Kerrisk
        CAP_SYS_ADMIN is required only in caller's user namespace

select_tut.2
    Peter Wu
        Fix various issues in example program

seteuid.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SETUID and CAP_SETGID

setgid.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SETGID

setpgid.2
    Michael Kerrisk
        Add a reference to credentials(7)

setpgid.2
setsid.2
    Michael Kerrisk
        Relocate some text on sessions and sessions leaders
            Some text that was in setpgid(2) is better placed in setsid(2).

setresuid.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SETUID

setreuid.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SETUID and CAP_SETGID

setsid.2
    Michael Kerrisk
        Refer to credentials(7) for details for details on controlling terminal
            Refer to credentials(7) for details of how a session obtains
            a controlling terminal.

set_thread_area.2
    Michael Kerrisk
        Add get_thread_area() to NAME

setuid.2
    Michael Kerrisk
        Note user namespace requirements for CAP_SETUID

sigprocmask.2
    Keno Fischer
        Expand/clarify libc/kernel sigset_t difference

stat.2
    Michael Kerrisk  [Ursache Vladimir, Mats Wichmann]
        Improve discussion of 'st_size' for /proc and /sys files
    Michael Kerrisk
        _BSD_SOURCE and _SVID_SOURCE no longer expose nanosecond timestamps

umask.2
    Michael Kerrisk
        Provide a rationale for the existence of /proc/PID/status 'Umask' field

wait.2
    Michael Kerrisk
        Remove erroneous statement that waitpid() is implemented via wait4()
            There is a fallback to wait4(), but only if the kernel does
            not provide a waitpid() system call.

bindresvport.3
rcmd.3
ip.7
    Michael Kerrisk
        Note user namespace requirements for CAP_NET_BIND_SERVICE

byteorder.3
    Michael Kerrisk
        SEE ALSO: add bswap(3)

dlopen.3
    Michael Kerrisk
        dlmopen() is still broken in glibc 2.24

endian.3
    Michael Kerrisk
        SEE ALSO: add bswap(3)

ffs.3
    Michael Kerrisk  [Stefan Tauner]
        Correct feature test macro requirements

fmemopen.3
    Michael Kerrisk  [Rich Felker]
        Remove bogus suggestion to use setbuffer()

getlogin.3
    Michael Kerrisk
        Update feature test macro requirements for cuserid()

getumask.3
    Michael Kerrisk
        Note that getumask() is still unavailable in glibc 2.24
    Michael Kerrisk
        Point to umask(2) for a thread-safe way to discover process's umask

mkstemp.3
    Quentin Rameau
        Fix _POSIX_C_SOURCE value for mkstemp()
            The correct _POSIX_C_SOURCE value has always been 200809L,
            not 200112L.

pthread_join.3
    Michael Kerrisk  [Mats Wichmann]
        Note that the caller might do clean up after joining with a thread
    Michael Kerrisk  [王守堰]
        Clarify use of 'retval' pointer

resolver.3
    Ray Bellis
        Correct arguments to res_ninit(res_state statep)

strverscmp.3
    Michael Kerrisk
        Add an example program

wcstombs.3
    Michael Kerrisk  [Igor Liferenko]
        wcsrtombs() does not provide thread-safe interface to same functionality
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=741360

core.5
    Mike Frysinger  [Michael Kerrisk]
       Add more details for output paths and the crash handler
            People sometimes assume that the crash handler runs in the same
            context as the crashing process.  They would be incorrect :).

proc.5
    Mike Frysinger
        Clarify the root symlink and mount namespaces
            If the target process is in a different mount namespace, the root
            symlink actually shows that view of the filesystem.
    Michael Kerrisk  [Mike Frysinger]
        Expand discussion of /proc/[pid]/root
            Add a shell example showing that /proc/[pid]/root is more
            than a symlink. Based on an example provided by Mike Frysinger
            in an earlier commit message.
    Michael Kerrisk
        Explain rules determining ownership of /proc/PID/* files
            Describe the effect of the "dumpable" attribute on ownership
            of /proc/PID files.
    Michael Kerrisk
        Note effect of 'suid_dumpable' on ownership of /proc/PID files
    Michael Kerrisk
        Refer to ptrace(2) for info on effect of suid_dumpable on ptraceability
    Michael Kerrisk
        Add reference to core(5) in discussion of 'suid_dumpable'
    Michael Kerrisk
        Note that 'suid_dumpable' mode 1 is insecure
    Michael Kerrisk
        Document /proc/meminfo '+ShmemHugePages' and 'ShmemPmdMapped' fields
    Michael Kerrisk
        Document /proc/PID/status 'RssAnon', 'RssFile', and 'RssShmem' fields
    Michael Kerrisk
        Document /proc/PID/status 'HugetlbPages' field
    Michael Kerrisk  [Zefram]
        Clarify that /proc/PID/statm 'shared' field counts *resident* pages
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=741360
    Michael Kerrisk
        Add reference to umask(2) in discussion of /proc/PID/status 'Umask'
    Michael Kerrisk
        Clarify user namespace requirements for /proc/sys/fs/protected_hardlinks
    Michael Kerrisk
        Note changes to config option governing /proc/[pid]/task/[tid]/children
    Michael Kerrisk
        Clarify description of /proc/PID/statm 'lib' and 'dt' fields
            These fields are always zero since Linux 2.6.
    Namhyung Kim  [Petr Cermak]
        Add description of CLEAR_REFS_MM_HIWATER_RSS
    Michael Kerrisk
        Update example VM values in /proc/PID/status

capabilities.7
    Michael Kerrisk
        Add note about nosuid to file capabilities section
    Michael Kerrisk
        SEE ALSO: add proc(5)
    Michael Kerrisk
        SEE ALSO: add setsid(2) and setpgid(2)

glob.7
    Michael Kerrisk  [Arnaud Gaillard]
        Clarify that syntactically incorrect patterns are left unchanged

packet.7
    Michael Kerrisk
        Clarify user namespace requirements for CAP_NET_RAW

pipe.7
    Michael Kerrisk  [Patrick McLean]
        Document FIONREAD

raw.7
    Michael Kerrisk
        Clarify user namespace requirements for CAP_NET_RAW
            Also remove mention of UID 0 as a method or creating
            a raw socket. As far as I can tell from reading the
            kernel source (net/ipv4/af_inet.c), this is not true.

socket.7
    Michael Kerrisk
        SIOCSPGRP: refer to fcntl(2) F_SETOWN for correct permission rules
            The permission rules described for SIOCCPGRP are wrong. Rather
            than repeat the rules here, just refer the reader to fcntl(2),
            where the rules are described for F_SETOWN.

unix.7
    Michael Kerrisk  [Laurent Georget, Ivan Kharpalev]
        Remove mention of recvmsg() from discussion of EPIPE error
            See https://bugzilla.kernel.org/show_bug.cgi?id=137351

ld.so.8
    Michael Kerrisk
        Expand description of LD_DEBUG
            Provide a list of the categories, and note that multiple
            categories can be specified.
    Michael Kerrisk
        Add glibc version for LD_USE_LOAD_BIAS
    Michael Kerrisk
        Clarify text describing whether secure-mode programs preload libraries
    Michael Kerrisk
        Remove discussion of environment variables understood by libc5
            libc5 disappeared long ago, so cease cluttering up this page
            with those ancient details. Thus, remove discussion of the
            following environment variables: LD_AOUT_LIBRARY_PATH,
            LD_AOUT_PRELOAD, LD_KEEPDIR, LD_NOWARN, and LDD_ARGV0.
    Michael Kerrisk
        Remove text with ancient libc4 and Linux libc details
    Michael Kerrisk
        Remove mention of "ELF only"
            Drawing a distinction between ELF-only features versus a,out
            ceased to be relevant long ago, so cluttering the page
            with "ELF-only" serves no purpose.



==================== Changes in man-pages-4.09 ====================

Released: 2016-12-12, Munich


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Afzal Mohammed <afzal.mohd.ma@gmail.com>
Andrew Clayton <andrew@digital-domain.net>
Carlos O'Donell <carlos@redhat.com>
Christoph Lameter <cl@linux.com>
Daniel Baluta <daniel.baluta@gmail.com>
Daniel Berrange <berrange@redhat.com>
Daniel Wagner <wagi@monom.org>
Darrick J. Wong <darrick.wong@oracle.com>
Dave Hansen <dave.hansen@intel.com>
Dmitry V. Levin <ldv@altlinux.org>
Dr. Tobias Quathamer <toddy@debian.org>
Elliott Hughes <enh@google.com>
Eric W. Biederman <ebiederm@xmission.com>
Eugene Syromyatnikov <evgsyr@gmail.com>
Florian Weimer <fweimer@redhat.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Igor Liferenko <igor.liferenko@gmail.com>
Jakub Wilk <jwilk@jwilk.net>
Jann Horn <jann@thejh.net>
Jeremy Harris <jgh@redhat.com>
Kees Cook <keescook@chromium.org>
Keno Fischer <keno@juliacomputing.com>
Laurent Georget <laurent.georget@supelec.fr>
Laurent Georget <laurent@lgeorget.eu>
Marcos Mello <marcosfrm@gmail.com>
Michael Hausenblas <michael.hausenblas@gmail.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@gentoo.org>
Mike Galbraith <efault@gmx.de>
Miroslav Koskar <mk@mkoskar.com>
Nikos Mavrogiannopoulos <nmav@redhat.com>
Omar Sandoval <osandov@fb.com>
Pavel Emelyanov <xemul@virtuozzo.com>
Piotr Kwapulinski <kwapulinski.piotr@gmail.com>
Siddhesh Poyarekar <siddhesh@sourceware.org>
Theodore Ts'o <tytso@mit.edu>
Vegard Nossum <vegard.nossum@oracle.com>
Vincent Lefevre <vincent@vinc17.net>
Vince Weaver <vincent.weaver@maine.edu>
Wainer dos Santos Moschetta <wainersm@linux.vnet.ibm.com>
Wang Long <long.wanglong@huawei.com>
Willy Tarreau <w@1wt.eu>
Zack Weinberg <zackw@panix.com>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

pkey_alloc.2
    Dave Hansen  [Michael Kerrisk]
        New page documenting pkey_alloc(2) and pkey_free(2)

pthread_getattr_default_np.3
    Michael Kerrisk
        New page documenting pthread_getattr_default_np(3) and pthread_setattr_default_np(3)

strfromd.3
    Wainer dos Santos Moschetta
        New page documenting strfromd(3), strfromf(3), and strfroml(3)
            The ISO/IEC TS 18661-1 specifies the strfrom() class
            of functions that convert a float-point value to string.

fuse.4
    Keno Fischer  [Michael Kerrisk]
        New page describing /dev/fuse
            This is my writeup of a basic description of /dev/fuse after
            playing with it for a few hours today. It is of course woefully
            incomplete, and since I neither have a use case nor am working
            on this code, I will not be in a position to expand it in the
            near future. However, I'm hoping this could still serve as a
            handy reference for others looking at this interface.

            [mtk: Notwithstanding the incompleteness of this page,
            it's a good base for future extension.]

tmpfs.5
    Michael Kerrisk
        New page documenting the tmpfs filesystem

pkeys.7
    Dave Hansen  [Michael Kerrisk]
        New page with overview of Memory Protection Keys

random.7
    Michael Kerrisk  [Theodore Ts'o, Nikos Mavrogiannopoulos, Laurent Georget]
        New page providing an overview of interfaces for obtaining randomness
            Contains material extracted from getrandom(2) and random(4),
            as well as new material.

sock_diag.7
    Pavel Emelyanov, Dmitry V. Levin
        New page documenting NETLINK_SOCK_DIAG interface

close.2
getpriority.2
nice.2
timer_create.2
timerfd_create.2
random.4
elf.5
proc.5
sched.7
    Various authors
        These pages also saw substantial updates, as described under
        "Changes to individual pages".


Newly documented interfaces in existing pages
---------------------------------------------

mmap.2
    Michael Kerrisk
        Add (much) more detail on MAP_GROWSDOWN

mprotect.2
    Dave Hansen
        Document the new pkey_mprotect() system call
    Eugene Syromyatnikov
        Document PROT_SEM, PROT_SAO, PROT_GROWSUP, and PROT_GROWSDOWN

prctl.2
    Eugene Syromyatnikov
        Document PR_SET_FP_MODE and PR_GET_FP_MODE

perf_event_open.2
    Vince Weaver
        PERF_RECORD_SWITCH support
            Linux 4.3 introduced two new record types for recording context
            switches: PERF_RECORD_SWITCH and PERF_RECORD_SWITCH_CPU_WIDE.
    Vince Weaver
        Add PERF_SAMPLE_BRANCH_CALL branch sample type
    Vince Weaver
        PERF_SAMPLE_BRANCH_IND_JUMP branch_sample_type
            Linux 4.2 added a new branch_sample_type: PERF_SAMPLE_BRANCH_IND_JUMP
    Vince Weaver
        Document PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT
    Vince Weaver
        Document sample_max_stack and /proc/sys/kernel/perf_event_max_stack
            Linux 4.8 added a new sample_max_stack parameter, as well as
            /proc/sys/kernel/perf_event_max_stack which limits it and a new
            EOVERFLOW error return.
    Dave Hansen
        PERF_RECORD_LOST_SAMPLES record type
            Linux 4.2 added a new record type: PERF_RECORD_LOST_SAMPLES
            It is generated when hardware samples (currently only Intel PEBS)
            are lost.

ptrace.2
    Michael Kerrisk
        Document PTRACE_SECCOMP_GET_FILTER
    Michael Kerrisk
        Document PTRACE_GET_THREAD_AREA and PTRACE_SET_THREAD_AREA

namespaces.7
    Michael Kerrisk  [Eric W. Biederman]
        Document the NS_GET_USERNS and NS_GET_PARENT ioctl() operations

sched.7
    Michael Kerrisk  [Mike Galbraith]
        Document the autogroup feature
            Includes documenting autogroup nice value
    Michael Kerrisk
        Autogrouping breaks traditional semantics of nice in many cases
            When autogrouping is enabled (the default in many distros)
            there are many traditional use cases where the nice value
            ceases to have any effect.
    Michael Kerrisk
        Add a subsection on nice value and group scheduling


New and changed links
---------------------

killpg.2
    Michael Kerrisk
        New link to relocated killpg(3) page

pkey_free.2
    Michael Kerrisk
        New link to new pkey_alloc(2) page

pkey_mprotect.2
    Michael Kerrisk
        New link to mprotect(2)

pthread_setattr_default_np.3
    Michael Kerrisk
        New link to new pthread_getattr_default_np.3

strfromf.3
    Wainer dos Santos Moschetta
        New link to strfromd(3)

strfroml.3
    Wainer dos Santos Moschetta
        New link to strfromd(3)


Global changes
--------------

Various pages
    Michael Kerrisk
        Remove ancient libc4 and libc5 details
            It's nearly 20 years now since Linux libc went away.
            Remove some ancient details from the pages.

Various pages
    Michael Kerrisk
        Add cross references to new tmpfs(5) page

Various pages
    Michael Kerrisk
        Change section number from 2 to 3 in killpg() references


Changes to individual pages
---------------------------

accept.2
    Michael Kerrisk
        Remove editorializing comments about 'socklen_t'
    Michael Kerrisk
        Simplify the discussion of 'socklen_t'
            We don't really need to list the old OSes in this discussion.

adjtimex.2
clock_getres.2
gettimeofday.2
    Michael Kerrisk
        SEE ALSO: add hwclock(8)

bind.2
connect.2
getpeername.2
getsockname.2
getsockopt.2
    Michael Kerrisk
        Replace discussion of 'socklen_t' with reference to accept(2)
            The discussion of 'socklen_t' editorializes and is repeated
            across several pages. Replace it with a reference to accept(2),
            where some details about this type are provided.

chmod.2
    Michael Kerrisk
        SEE ALSO: add chmod(1)

chown.2
    Michael Kerrisk
        SEE ALSO: add chgrp(1) and chown(1)

chroot.2
    Michael Kerrisk
        SEE ALSO: add chroot(1)

clone.2
    Michael Kerrisk
        The CLONE_*_SETTID operations store TID before return to user space
            CLONE_PARENT_SETTID and CLONE_CHILD_SETTID store the new
            TID before clone() returns to user space

close.2
    Michael Kerrisk  [Daniel Wagner]
        Rework and greatly extend discussion of error handling
            Further clarify that an error return should be used only
            for diagnostic or remedial purposes.
    Michael Kerrisk
        Other UNIX implementations also close the FD, even if reporting an error
            Looking at some historical source code suggests
            that the "close() always closes regardless of error return"
            behavior has a long history, predating even POSIX.1-1990.
    Michael Kerrisk
        Note that future POSIX plans to require that the FD is closed on error
            See http://austingroupbugs.net/view.php?id=529#c1200.
    Michael Kerrisk
        Clarify the variation in EINTR behavior per POSIX and other systems

fallocate.2
    Darrick J. Wong
        Document behavior with shared blocks
            Note that FALLOC_FL_UNSHARE may use CoW to unshare blocks to
            guarantee that a disk write won't fail with ENOSPC.

fanotify_mark.2
    Heinrich Schuchardt
        Mention FAN_Q_OVERFLOW
            To receive overflow events it is necessary to set this bit
            in fanotify_mark().

fcntl.2
    Michael Kerrisk
        F_GETPIPE_SZ allocates next power-of-2 multiple of requested size
            Add some detail about current implementation, since this helps
            the user understand the effect of the user pipe limits added in
            Linux 4.5 (described in pipe(7)).
    Michael Kerrisk
        Add EPERM that occurs for F_SETPIPE_SZ when user pipe limit is reached

fideduperange.2
    Darrick J. Wong  [Omar Sandoval]
        Fix the discussion of maximum sizes
            Fix the discussion of the limitations on the dest_count and
            src_length parameters to the fideduperange ioctl() to reflect
            what's actually in the kernel.

fsync.2
    Michael Kerrisk
        SEE ALSO: add fileno(3)
            fileno(3) is useful if one is combining fflush(3)/fclose(3)
            and fsync(2).
    Michael Kerrisk
        SEE ALSO: add fflush(3)

getgroups.2
    Andrew Clayton
        FTM requirements fix for setgroups(2)

gethostname.2
    Michael Kerrisk
        SEE ALSO: add hostname(1)

get_mempolicy.2
    Michael Kerrisk
        Note that 'addr' must be NULL when 'flags' is 0

getpriority.2
    Michael Kerrisk
        Warn that autogrouping voids the effect of 'nice' in many cases
            Refer the reader to sched(7) for the details.
    Michael Kerrisk
        Expand discussion of getpriority() return value
    Michael Kerrisk
        The nice value supplied to setpriority() is clamped
            Note that the nice value supplied to setpriority() is clamped
            to the permitted range.
    Michael Kerrisk
        Improve description of setpriority() return value

getpriority.2
sched.7
    Michael Kerrisk
        Move nice value details from getpriority(2) to sched(7)
            Centralizing these details in sched(7) is more logical.

getrandom.2
random.4
    Michael Kerrisk
        Consolidate and improve discussion on usage of randomness
            Currently, recommendations on how to consume randomness are
            spread across both getrandom(2) and random(4) and the general
            opinion seems to be that the text in getrandom(2) does a
            somewhat better job. Consolidate the discussion to a single
            page (getrandom(2)) and address some of the concerns
            expressed about the existing text in random(4).
            [Some of this text ultimately made its way into the new
            random(7) page.]

getrandom.2
    Michael Kerrisk
        Remove material incorporated into random(7)
    Michael Kerrisk
        Note advantages of fact that getrandom() doesn't use file descriptors
    Michael Kerrisk
        Clarify that getrandom() is not "reading" from /dev/{random,urandom}

getrlimit.2
    Michael Kerrisk
        Refer to sched(7) in discussion of RLIMIT_RTPRIO and RLIMIT_RTTIME
    Michael Kerrisk
        Describe the range of the RLIMIT_NICE limit
    Michael Kerrisk
        Refer to sched(7) in the discussion of RLIMIT_NICE
    Michael Kerrisk
        SEE ALSO: add credentials(7)

ioctl_ficlonerange.2
ioctl_fideduperange.2
    Darrick J. Wong
        Clarify the behavior of the FIDEDUPERANGE ioctl

kill.2
    Michael Kerrisk
        SEE ALSO: add kill(1)

mbind.2
    Michael Kerrisk  [Christoph Lameter]
        Memory policy is a per-thread attribute, not a per-process attribute

mbind.2
set_mempolicy.2
    Piotr Kwapulinski  [Christoph Lameter, Michael Kerrisk]
        Add MPOL_LOCAL NUMA memory policy documentation

mount.2
    Michael Kerrisk
        SEE ALSO: add mountpoint(1)

mprotect.2
    Michael Kerrisk
        CONFORMING TO: note that pkey_mprotect() is Linux-specific

nice.2
    Michael Kerrisk
        Warn that autogrouping voids the effect of 'nice' in many cases
    Michael Kerrisk
        CONFORMING TO: Remove an ancient SVr4 detail on errno values
    Michael Kerrisk
        Rework discussion of nice() return value and standards conformance
            Make the text a little clearer. In particular, clarify that the
            raw system call (still) returns 0 on success.
    Michael Kerrisk
        Clarify the range of the nice value, and note that it is clamped
    Michael Kerrisk
        Add mention of RLIMIT_NICE
    Michael Kerrisk
        Move discussion of handling the -1 success return to RETURN VALUE
            This detail was rather hidden in NOTES. Also, rework the text
            a little.
    Michael Kerrisk
        Clarify that nice() changes the nice value of the calling *thread*
    Michael Kerrisk
        Add "C library/kernel differences" subsection heading
    Michael Kerrisk
        Add reference to sched(7) for further details on the nice value

open.2
    Michael Kerrisk
        ubifs supports O_TMPFILE starting with Linux 4.9
    Michael Kerrisk
        Document ENOMEM that occurs when opening FIFO because of pipe hard limit

perf_event_open.2
    Vince Weaver
        Add cycles field in LBR records
            Linux 4.3 added a cycles field to the PERF_SAMPLE_BRANCH_STACK
            last branch records.
    Vince Weaver
        Update time_shift sample code
            Linux 4.3 improved the accuracy of the clock/ns conversion routines.
    Michael Kerrisk
        Clarify the use of signals for capturing overflow events

pipe.2
    Michael Kerrisk
        Add ENFILE error for user pipe hard limit reached

prctl.2
    Eugene Syromyatnikov
        Some additional details regarding the PR_GET_UNALIGNED operation
    Eugene Syromyatnikov
        Note the output buffer size for PR_GET_TID_ADDRESS operation on x32/n32
    Michael Kerrisk
        Remove numeric definitions of PR_FP_MODE_FR and PR_FP_MODE_FRE bits

ptrace.2
    Keno Fischer
        Document the behavior of PTRACE_SYSEMU stops
    Keno Fischer
        Expand documentation PTRACE_EVENT_SECCOMP traps
            In Linux 4.8, the order of PTRACE_EVENT_SECCOMP and
            syscall-entry-stops was reversed.  Document both behaviors and
            their interaction with the various forms of restart.

quotactl.2
    Eugene Syromyatnikov
        Describe Q_XQUOTASYNC, which is present but no-op in recent kernels

reboot.2
    Wang Long
        Note errors for invalid commands inside a PID namespace

sched_setattr.2
    Michael Kerrisk
        Fix cross reference for further info on the nice value
            The information moved from getpriority(2) to sched(7).

sched_setscheduler.2
    Michael Kerrisk  [Daniel Berrange]
        Mention SCHED_DEADLINE
            Give the reader a clue that there is another policy
            available that can't be set via sched_setscheduler(2).

seccomp.2
    Jann Horn
        Document changed interaction with ptrace
            Before kernel 4.8, the seccomp check will not be run again
            after the tracer is notified. Fixed in kernel 4.9.
    Michael Kerrisk
        NOTES: mention ptrace(PTRACE_SECCOMP_GET_FILTER) to dump seccomp filters

set_mempolicy.2
    Michael Kerrisk
        Reformat list of modes

setsid.2
    Michael Kerrisk
        Improve wording of text on calling setsid() after fork()+_exit()
    Michael Kerrisk
        SEE ALSO: add sched(7)
            List sched(7), because setsid(2) is part of the machinery
            of autogrouping.

sigaction.2
    Dave Hansen
        Further documentation of SEGV_PKUERR

signalfd.2
    Michael Kerrisk
        Document ssi_addr_lsb field of signalfd_siginfo

symlink.2
    Michael Kerrisk
        SEE ALSO: add namei(1)

sync_file_range.2
    Michael Kerrisk
        Fix description for ESPIPE error
            A file descriptor can't refer to a symbolic link.

syscalls.2
    Michael Kerrisk
        Add pkey_alloc(), pkey_free(), and pkey_mprotect()
            New system calls in Linux 4.9.
    Michael Kerrisk
        Add ppc_swapcontext(2)

timer_create.2
    Michael Kerrisk
        Document CLOCK_BOOTTIME
    Michael Kerrisk
        Document CLOCK_REALTIME_ALARM and CLOCK_BOOTTIME_ALARM

timerfd_create.2
    Michael Kerrisk
        Document CLOCK_BOOTTIME, CLOCK_REALTIME_ALARM, and CLOCK_BOOTTIME_ALARM
    Michael Kerrisk
        Document TFD_TIMER_CANCEL_ON_SET
    Michael Kerrisk
        Rework discussion on relative and absolute timers

unlink.2
    Michael Kerrisk
        SEE ALSO: add unlink(2)

utime.2
utimensat.2
    Michael Kerrisk
        SEE ALSO: add touch(1)

wait.2
    Michael Kerrisk
        On some architectures, waitpid() is a wrapper that calls wait4().

atof.3
    Wainer dos Santos Moschetta
        SEE ALSO: add strfromd(3)

ctime.3
    Michael Kerrisk
        Add ERRORS section
    Michael Kerrisk
        RETURN VALUE: describe return values more explicitly

errno.3
    Michael Kerrisk  [Igor Liferenko]
        Add glibc error text for EILSEQ

fclose.3
fflush.3
    Michael Kerrisk
        SEE ALSO: add fileno(2)

getlogin.3
    Michael Kerrisk
        Remove deprecated _REENTRANT from FTM requirements for getlogin_r()
    Michael Kerrisk
        SEE ALSO: add logname(1)

isalpha.3
    Michael Kerrisk
        Note circumstances where 'c' must be cast to 'unsigned char'

killpg.3
    Michael Kerrisk
        Move killpg.2 from section to section 3

mallopt.3
    Michael Kerrisk  [Siddhesh Poyarekar]
        Document 0 as default value of M_ARENA_MAX and explain its meaning
    Michael Kerrisk
        Improve description of M_ARENA_TEST
    Michael Kerrisk
        Document default value for M_ARENA_TEST
    Michael Kerrisk
        Note default value of M_PERTURB

mbsnrtowcs.3
    Michael Kerrisk  [Igor Liferenko]
        Note behavior of mbsnrtowcs() for an incomplete character
            Note the behavior of mbsnrtowcs() when an incomplete character
            is found at end of the input buffer.

mbstowcs.3
wcstombs.3
    Michael Kerrisk  [Igor Liferenko]
        Improve language relating to "initial state"
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=839705

mbstowcs.3
    Michael Kerrisk  [Igor Liferenko]
        Add missing include to example program
            See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=845172

mq_close.3
    Michael Kerrisk
        DESCRIPTION: add reference to mq_notify(3)

mq_open.3
    Eugene Syromyatnikov
        Clarification regarding usage of mq_flags attribute in mq_open()

mq_receive.3
mq_send.3
    Eugene Syromyatnikov
        Clarification regarding reasons behind EBADF

printf.3
    Wainer dos Santos Moschetta
        SEE ALSO: add strfromd(3)

pthread_attr_init.3
    Michael Kerrisk
        SEE ALSO: add pthread_setattr_default_np(3)

pthread_create.3
    Michael Kerrisk
        SEE ALSO: add pthread_setattr_default_np(3)

ptsname.3
    Michael Kerrisk
        Note that ptsname_r() is proposed for future inclusion in POSIX.1
    Michael Kerrisk
        CONFORMING TO:: clarify that only ptsname() is standardized (so far)

remainder.3
    Michael Kerrisk
        Note fix to remainder(nan(""), 0) handling
            The bug https://www.sourceware.org/bugzilla/show_bug.cgi?id=6779
            has been fixed in glibc 2.15.
    Michael Kerrisk
        Document fixes for EDOM handling for range errors
            The bug http://sources.redhat.com/bugzilla/show_bug.cgi?id=6783
            was fixed in glibc 2.15.

setjmp.3
    Michael Kerrisk
        _BSD_SOURCE must be *explicitly* defined to get BSD setjmp() semantics

strtod.3
    Wainer dos Santos Moschetta
        SEE ALSO: add strfromd(3)

tgamma.3
    Michael Kerrisk
        Document fixes to give ERANGE for underflow range error
            The bug https://www.sourceware.org/bugzilla/show_bug.cgi?id=6810
            was fixed in glibc 2.19.

timegm.3
    Michael Kerrisk
        Add ERRORS section
    Michael Kerrisk  [Vincent Lefevre]
        Add RETURN VALUE section

tmpnam.3
    Michael Kerrisk
        Properly document tmpnam_r(3)

toupper.3
    Michael Kerrisk
        Note circumstances where 'c' must be cast to 'unsigned char'

ttyname.3
    Michael Kerrisk
        SEE ALSO: add tty(1)

console_ioctl.4
    Michael Kerrisk
        Add brief descriptive text for KDGKBMODE modes
    Miroslav Koskar
        Add K_OFF keyboard mode

random.4
    Michael Kerrisk
        Add reference to new random(7) page
    Michael Kerrisk
        Rework formatting of /proc interfaces
            Make the information easier to parse by formatting the file
            descriptions as hanging lists. No significant content changes.
    Nikos Mavrogiannopoulos  [Laurent Georget]
        Provide a more accurate description of /dev/urandom
            This documents the "property" of /dev/urandom of being able to
            serve numbers prior to pool being initialized, and removes any
            suggested usages of /dev/random which are disputable
            (i.e., one-time pad).  Document the fact /dev/random is only
            suitable for applications which can afford indeterminate delays
            since very few applications can do so.  Smooth the alarming
            language about a theoretical attack, and mention that its
            security depends on the cryptographic primitives used by the
            kernel, as well as the total entropy gathered.
    Michael Kerrisk  [Laurent Georget, Theodore Ts'o]
        Improve discussion of /dev/urandom, blocking reads, and signals
            The text currently states that O_NONBLOCK has no effect for
            /dev/urandom, which is true.  It also says that reads from
            /dev/urandom are nonblocking.  This is at the least confusing.
            If one attempts large reads (say 10MB) from /dev/urandom
            there is an appreciable delay, and interruption by a signal
            handler will result in a short read. Amend the text to
            reflect this.

elf.5
    Mike Frysinger
        Add subsection headers at major points
            The current pages dumps all the content into one big DESCRIPTION
            with no real visual break up between logically independent
            sections.  Add some subsection headers to make it easier to
            read and scan.
    Mike Frysinger
        Document notes
            Document the Elf{32,64}_Nhdr structure, the sections/segments that
            contain notes, and how to interpret them.  I've been lazy and only
            included the GNU extensions here, especially as others are not
            defined in the elf.h header file as shipped by glibc.

filesystems.5
    Michael Kerrisk
        SEE ALSO: add fuse(4)

proc.5
    Dave Hansen
        Describe new ProtectionKey 'smaps' field
    Michael Kerrisk
        Add example ProtectionKey output for 'smaps' file
    Michael Kerrisk
        Add pointers to sched(7) for autogroup files
            sched(7) describes /proc/sys/kernel/sched_autogroup_enabled
            and /proc/PID/autogroup.
    Michael Kerrisk
        Add /proc/sys/fs/pipe-user-pages-{hard,soft} entries
    Michael Kerrisk
        Improve description of the KernelPageSize and MMUPageSize 'smaps' fields
    Michael Kerrisk
        Rework 'smaps' ProtectionKey text and add some details
    Michael Kerrisk
        Mention lslocks(8) in discussion of /proc/locks
    Michael Kerrisk
        Describe Shmem field of /proc/meminfo
    Michael Kerrisk
        Rework 'smaps' VmFlags text, and add kernel version and example output

proc.5
pipe.7
    Michael Kerrisk
        Move /proc/sys/fs/pipe-max-size content from proc(5) to pipe(7)

resolv.conf.5
    Carlos O'Donell  [Florian Weimer]
        Timeout does not map to resolver API calls

utmp.5
    Michael Kerrisk
        SEE ALSO: add users(1)

capabilities.7
    Michael Kerrisk
        CAP_SYS_ADMIN governs ptrace(2) PTRACE_SECCOMP_GET_FILTER
    Michael Kerrisk
        CAP_SYS_ADMIN allows privileged ioctl() operations on /dev/random

cgroups.7
    Michael Kerrisk
        Add details on 'cpu' CFS bandwidth control

credentials.7
    Michael Kerrisk
        SEE ALSO: add setpriv(1)
    Michael Kerrisk
        SEE ALSO: add shadow(5)

feature_test_macros.7
    Michael Kerrisk  [Zack Weinberg]
        Note that _REENTRANT and _THREAD_SAFE are now deprecated
    Michael Kerrisk
        Note that "cc -pthread" defines _REENTRANT

inotify.7
    Michael Kerrisk
        Note a subtlety of event generation when monitoring a directory

libc.7
    Michael Kerrisk
        Add a note on why glibc 2.x uses the soname libc.so.6
    Michael Kerrisk
        Add a few historical details on Linux libc4 and libc5
            Just for historical interest. Details taken from
            http://www.linux-m68k.org/faq/glibcinfo.html.

mdoc.7
    Michael Kerrisk
        Add a cross-reference to groff_mdoc(7)

mount_namespaces.7
    Michael Kerrisk
        SEE ALSO: add user_namespaces(7)

mount_namespaces.7
user_namespaces.7
    Michael Kerrisk
        Migrate subsection on mount restrictions to mount_namespaces(7)
            This section material in the user_namespaces(7) page was written
            before the creation of the mount_namespaces(7) manual page.
            Nowadays, this material properly belongs in the newer page.

netlink.7
    Dmitry V. Levin
        Document NETLINK_INET_DIAG rename to NETLINK_SOCK_DIAG
    Dmitry V. Levin
        Add references to sock_diag(7)

pid_namespaces.7
    Michael Kerrisk
        Refer to namespaces(7) for information about NS_GET_PARENT

pipe.7
    Michael Kerrisk, Vegard Nossum  [Vegard Nossum]
        Document /proc files controlling memory usage by pipes
            Document /proc/sys/fs/pipe-max-size and
            /proc/sys/fs/pipe-user-pages-{soft,hard}.
    Michael Kerrisk
        Document pre-Linux 4.9 bugs in pipe limit checking

sched.7
    Michael Kerrisk
        Add a new introductory paragraph describing the nice value
    Michael Kerrisk
        Add more precise details on CFS's treatment of the nice value
    Michael Kerrisk
        Mention RLIMIT_NICE in the discussion of the nice value
    Michael Kerrisk
        NOTES: mention cgroups CPU controller
    Michael Kerrisk
        Add introductory sentence mentioning CFS scheduler
    Michael Kerrisk
        Add nice(2), getpriority(2), and setpriority(2) to API list
    Michael Kerrisk
        Make it clearer that SCHED_OTHER is always scheduled below real-time
    Michael Kerrisk
        Give the page a more generic NAME
            The page isn't just about APIs.

standards.7
    Michael Kerrisk
        POSIX.1-2016 (POSIX.1-2008 TC2) has now been released

symlink.7
    Michael Kerrisk
        SEE ALSO: add namei(1)

uri.7
    Jakub Wilk
        Use "example.com" as example domain

user_namespaces.7
    Michael Kerrisk
        Add reference to namespaces(7) for NS_GET_USERNS operation
    Michael Kerrisk
        Add reference to namespaces(7) for NS_GET_PARENT operation


==================== Changes in man-pages-4.10 ====================

Released: 2017-03-13, Paris


Contributors
------------

The following people contributed patches/fixes or (noted in brackets
in the changelog below) reports, notes, and ideas that have been
incorporated in changes in this release:

Adam Martindale <adam.john.martindale@gmail.com>
Alex <psybin@riseup.net>
Anders Thulin <anders@thulin.name>
Andreas Gruenbacher <agruenba@redhat.com>
Brian Masney <masneyb@onstation.org>
Casey Schaufler <casey@schaufler-ca.com>
David Howells <dhowells@redhat.com>
Erik Kline <ekline@gmail.com>
Erik Roland van der Meer <ervdmeer@gmail.com>
Eugene Syromyatnikov <evgsyr@gmail.com>
Fabjan Sukalia <fsukalia@gmail.com>
Heinrich Schuchardt <xypron.glpk@gmx.de>
Helmut Eller <eller.helmut@gmail.com>
Hugo Guiroux <hugo.guiroux@gmail.com>
Ian Jackson <ijackson@chiark.greenend.org.uk>
Jakub Wilk <jwilk@jwilk.net>
Jann Horn <jannh@google.com>
Jan Ziak <0xe2.0x9a.0x9b@gmail.com>
John Wiersba <jrw32982@yahoo.com>
Jon Jensen <jon@endpoint.com>
Kai NODA <nodakai@gmail.com>
KASAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Keno Fischer <keno@juliacomputing.com>
Kent Fredic <kentfredric@gmail.com>
Krzysztof Kulakowski <krzysztof.kulakowski@intel.com>
Maik Zumstrull <maik@zumstrull.net>
Mat Martineau <mathew.j.martineau@linux.intel.com>
Michael Kerrisk <mtk.manpages@gmail.com>
Mike Frysinger <vapier@chromium.org>
Nadav Har'El  <nyh@math.technion.ac.il>
Namhyung Kim <namhyung@gmail.com>
Nicolas Biscos <nicolas.biscos+man7@gmail.com>
Omar Sandoval <osandov@osandov.com>
Paul Fee <paul.f.fee@gmail.com>
Reverend Homer <mk.43.ecko@gmail.com>
Rob Landley <rob@landley.net>
Sergey Polovko <sergey@polovko.me>
Steven Luo <steven@steven676.net>
Tadeusz Struk <tadeusz.struk@intel.com>
Vincent Bernat <vincent@bernat.im>
Vivenzio Pagliari <vivenzio.pagliari@nokia.com>
Wainer dos Santos Moschetta <wainersm@linux.vnet.ibm.com>
Willy Tarreau <w@1wt.eu>

Apologies if I missed anyone!


New and rewritten pages
-----------------------

add_key.2
    Michael Kerrisk  [Eugene Syromyatnikov, David Howells]
        Major improvements and additions
            The page has doubled in length.

ioctl_iflags.2
    Michael Kerrisk
        New page describing inode flags and ioctl() operations

ioctl_ns.2
    Michael Kerrisk
        New page created by splitting ioctl(2) operations out of namespaces(7)

keyctl.2
    Michael Kerrisk, Eugene Syromyatnikov  [David Howells, Mat Martineau]
         A vast number of additions and improvements
             The page has gone from somewhat over 100 lines to well over
             1000 lines and now more or less documents the complete interface
             provided by this system call.

getentropy.3
    Michael Kerrisk
        New page documenting getentropy(3)
            getentropy(3) is added to glibc in version 2.25.

keyrings.7
    David Howells
        New page (written by David Howells) adopted from keyutils
            Since this page documents kernel-user-space interfaces,
            it makes sense to have it as part of man-pages, rather
            than the keyutils package.
    Michael Kerrisk  [Eugene Syromyatnikov, David Howells]
        Very many additions and improvements
    Michael Kerrisk
        Document /proc/keys
    Michael Kerrisk
        Document /proc/sys/kernel/keys/persistent_keyring_expiry
    Michael Kerrisk
        Document /proc/key-users
    Michael Kerrisk
        Document /proc/sys/kernel/keys/gc_delay
    Michael Kerrisk
        Document /proc files that define key quotas

persistent-keyring.7
    Michael Kerrisk
        New page (written by David Howells) adopted from keyutils
            Since this page documents kernel-user-space interfaces,
            it makes sense to have it as part of man-pages, rather
            than the keyutils package.
    Michael Kerrisk
        Various clean-ups and additions

process-keyring.7
    Michael Kerrisk
        New page (written by David Howells) adopted from keyutils
            Since this page documents kernel-user-space interfaces,
            it makes sense to have it as part of man-pages, rather
            than the keyutils package.
    Michael Kerrisk
        Various additions and improvements

request_key.2
    Michael Kerrisk, Eugene Syromyatnikov  [David Howells]
        Very many additions and improvements
             The page is now three times its former length.

session-keyring.7
    Michael Kerrisk
        New page (written by David Howells) adopted from keyutils
            Since this page documents kernel-user-space interfaces,
            it makes sense to have it as part of man-pages, rather
            than the keyutils package.
    Michael Kerrisk
        Various reworking and additions

signal-safety.7
    Michael Kerrisk
        New page created by migrating the signal-safety discussion from
        signal(7). Along the way some more details got added.
    Michael Kerrisk  [KASAKI Motohiro]
        Note async-signal-safety problems caused by pthread_atfork()
            See https://bugzilla.kernel.org/show_bug.cgi?id=25292
    Michael Kerrisk  [KASAKI Motohiro]
        Note glibc deviations from POSIX requirements
            See https://bugzilla.kernel.org/show_bug.cgi?id=25292

thread-keyring.7
    Michael Kerrisk
        New page (written by David Howells) adopted from keyutils
            Since this page documents kernel-user-space interfaces,
            it makes sense to have it as part of man-pages, rather
            than the keyutils package.
    Michael Kerrisk
        Various rewordings and additions

user-keyring.7
    Michael Kerrisk
        New page (written by David Howells) adopted from keyutils
            Since this page documents kernel-user-space interfaces,
            it makes sense to have it as part of man-pages, rather
            than the keyutils package.
    Michael Kerrisk
        Various reworking and improvements

user-session-keyring.7
    Michael Kerrisk
        New page (written by David Howells) adopted from keyutils
            Since this page documents kernel-user-space interfaces,
            it makes sense to have it as part of man-pages, rather
            than the keyutils package.
    Michael Kerrisk
        Various rewordings and additions


Newly documented interfaces in existing pages
---------------------------------------------

bzero.3
    Michael Kerrisk
        Document explicit_bzero() (new in glibc 2.25)
            Also, reword the description of bzero somewhat.

proc.5
    Michael Kerrisk
        Document /proc/sys/vm/user_reserve_kbytes
    Michael Kerrisk
        Document /proc/sys/vm/admin_reserve_kbytes
    Michael Kerrisk
        Document /proc/sys/fs/mount-max
    Michael Kerrisk
        Document /proc/PID/status 'NoNewPrivs' field


New and changed links
---------------------

explicit_bzero.3
    Michael Kerrisk
        New link to bzero.3


Changes to individual pages
---------------------------

chmod.2
    Michael Kerrisk
        ERRORS: add EPERM error for immutable/append-only file

chown.2
    Michael Kerrisk
        ERRORS: add EPERM error for immutable/append-only file

chroot.2
    Michael Kerrisk
        SEE ALSO: add switch_root(8)

clock_getres.2
    Michael Kerrisk
        Note POSIX.1 requirements re relative time services and CLOCK_REALTIME

clone.2
    Michael Kerrisk
        clone() does not execute fork handlers

execve.2
    Michael Kerrisk
        Rework text describing when effective IDs aren't transformed by execve()
    Michael Kerrisk
        File capabilities can be ignored for the same reasons as set-UID/set-GID
    Michael Kerrisk
        The 'no_new_privs' bit inhibits transformations of the effective IDs

fork.2
    Michael Kerrisk
        cgroup PIDs controller may also be trigger for EAGAIN error

fsync.2
    Michael Kerrisk
        SEE ALSO: add posix_fadvise(2)

getrandom.2
    Michael Kerrisk
        Remove getentropy(3) details and defer to new getentropy(3) page
    Michael Kerrisk
        Starting with glibc 2.25, getrandom() is now declared in <sys/random.h>
    Michael Kerrisk
        glibc support was added in version 2.25

getrlimit.2
    Michael Kerrisk
        Document role of RLIMIT_NOFILE for FD passing over UNIX sockets

getxattr.2
listxattr.2
    Andreas Gruenbacher
        Document E2BIG errors

inotify_add_watch.2
    Michael Kerrisk
        Note "inode" as a synonym for "filesystem object"
            Consistent with clarifications just made in inotify(7).

ioctl.2
    Michael Kerrisk
        SEE ALSO: add ioctl_ns(2), ioctl_iflags(2)

ioctl_fat.2
    Brian Masney
        Correctly reference volume ID instead of volume label

kcmp.2
    Michael Kerrisk
        Mention the clone(2) flags relating to various kcmp() 'type' values
    Michael Kerrisk
        KCMP_FILE: note reasons why FDs may refer to same open file description

link.2
    Michael Kerrisk
        When using linkat() AT_EMPTY_PATH, 'olddirfd' must not be a directory
    Michael Kerrisk
        ERRORS: add EPERM for immutable/append-only files
    Michael Kerrisk
        Note limits where EMLINK is encountered on ext4 and Btrfs

listxattr.2
    Michael Kerrisk
        Eliminate extra E2BIG error text
            Andreas' patch added a second description of E2BIG that
            was (mostly) more detailed than the existing text. Combine
            the two texts.

lseek.2
    Michael Kerrisk
        O_APPEND overrides the effect of lseek() when doing file writes
    Michael Kerrisk
        Remove ancient info about whence values and return values on old systems
    Michael Kerrisk
        Remove slightly bogus advice about race conditions
            The page already (by now) contains a reference to open(2)
            for a discussion of open file descriptions. Leave it at that,
            since the reader can then deduce how things work.

madvise.2
    Michael Kerrisk
        Note that madvise() is generally about improving performance

mbind.2
    Krzysztof Kulakowski  [Michael Kerrisk]
        Update MPOL_BIND description
            The behavior of MPOL_BIND changed in Linux 2.6.26.

mincore.2
    Michael Kerrisk
        SEE ALSO: add madvise(2), posix_fadvise(2), posix_madvise(3)

mlock.2
    Michael Kerrisk
        Note pre-4.9 bug in RLIMIT_MEMLOCK accounting for overlapping locks
    Michael Kerrisk
        SEE ALSO: add mincore(2)

mmap.2
    Michael Kerrisk
        mincore(2) can be used to discover which pages of a mapping are resident

mount.2
    Michael Kerrisk  [Rob Landley]
        Refer to mount_namespaces(7) for details of default propagation type

nanosleep.2
    Michael Kerrisk
        Describe "creeping sleep" problem
            nanosleep() has a problem if used in a program that catches
            signals and those signals are delivered at a very high rate.
            Describe the problem, and note that clock_nanosleep(2)
            provides a solution.
    Michael Kerrisk
        BUGS: explicitly note that the Linux 2.4 bug was fixed in Linux 2.6

open.2
    Michael Kerrisk
        Make it clear that O_APPEND implies atomicity
    Michael Kerrisk
        Clarify distinction between file creation flags and file status flags
    Michael Kerrisk
        Note ambiguity of ELOOP error when using O_NOFOLLOW
    Michael Kerrisk
        Restructure O_NOFOLLOW text for easier parsing
    Michael Kerrisk
        Clarify that O_NOFOLLOW is now in POSIX

poll.2
select.2
    Nicolas Biscos
        Add a reference to the sigset discussion in sigprocmask(2)
            A little while back, I added a note to sigprocmask.2 that
            discussed the difference between the libc's and the kernel's
            sigset_t structures.  I added that note, because I saw this being
            done wrong in a tool tracing system calls (causing subtle bugs).
            As it turns out, the same bugs existed for ppoll and pselect, for
            the same reason. I'm hoping by adding the reference here, future
            writers of similar tools will find that discussion and not make
            the same mistake.

posix_fadvise.2
    Michael Kerrisk
        Mention /proc/sys/vm/drop_caches
            It may be helpful for the reader of this page to know about
            /proc/sys/vm/drop_caches.
    Michael Kerrisk
        Reorganize some text
            Details for various flags were hidden under NOTES.
            Move them to DESCRIPTION, to make the details more
            obvious.
    Michael Kerrisk
        One can use open(2) + mmap(2) + mincore(2) as a 'fincore'
            Note that open(2) + mmap(2) + mincore(2) can be used to get a view
            of which pages of a file are currently cached.
    Michael Kerrisk  [Maik Zumstrull]
        Note that POSIX_FADV_DONTNEED *may* try to write back dirty pages
    Michael Kerrisk
        SEE ALSO: mincore(2)

prctl.2
    Michael Kerrisk
        Clarify that the ambient capability set is per-thread
    Keno Fischer
        Be more precise in what causes dumpable to reset
    Michael Kerrisk
        The no_new_privs setting is per-thread (not per-process)
    Michael Kerrisk
        Mention /proc/PID/status 'NoNewPrivs' field
    Michael Kerrisk
        Add reference to seccomp(2) in discussion of PR_SET_NO_NEW_PRIVS

ptrace.2
    Omar Sandoval
        Clarify description of PTRACE_O_EXITKILL

read.2
    Michael Kerrisk  [Kai NODA]
        Rework text in DESCRIPTION that talks about limits for 'count'
            See https://bugzilla.kernel.org/show_bug.cgi?id=86061
    Michael Kerrisk  [Steven Luo]
        Remove crufty text about EINTR and partial read
            Remove bogus text saying that POSIX permits partial read
            to return -1/EINTR on interrupt by a signal handler.
            That statement already ceased to be true in SUSv1 (1995)!

            See https://bugzilla.kernel.org/show_bug.cgi?id=193111

readv.2
    Michael Kerrisk
        Remove generic advice about mixing stdio and syscalls on same file
            There is nothing specific to readv()/writev() about this advice.

recv.2
    Michael Kerrisk  [Vincent Bernat]
        Remove duplicate paragraph
            man-pages-1.34 included changes that duplicated an existing
            paragraph. Remove that duplicate.
    Michael Kerrisk
        SEE ALSO: add ip(7), ipv6(7), tcp(7), udp(7), unix(7)

remap_file_pages.2
    Michael Kerrisk
        remap_file_pages() has been replaced by a slower in-kernel emulation

send.2
    Michael Kerrisk
        SEE ALSO: add ipv6(7), socket(7), unix(7)

setxattr.2
    Michael Kerrisk
        ERRORS: add EPERM for immutable/append-only files

signalfd.2
    Michael Kerrisk
        signalfd() doesn't play well with helper programs spawned by libraries
            See https://lwn.net/Articles/415684/.
    Michael Kerrisk
        signalfd can't be used to receive synchronously generated signals
            Signals such as the SIGSEGV that results from an invalid
            memory access can be caught only with a handler.

stat.2
    Michael Kerrisk
        EXAMPLE: extend program to also show ID of the containing device
    Michael Kerrisk
        NOTES: mention fstatat() AT_NO_AUTOMOUNT in discussion of automounting

statfs.2
    Namhyung Kim
        Add more filesystem types
            Add missing magic numbers from /usr/include/linux/magic.h

syscall.2
    Mike Frysinger
        Add endian details with 64-bit splitting
            Architectures that split 64-bit values across register pairs
            usually do so according to their C ABI calling convention (which
            means endianness).  Add some notes to that effect, and change the
            readahead example to show a little endian example (since that is
            way more common than big endian).

            Also start a new list of syscalls that this issue does not apply
            to.
    Mike Frysinger
        Note parisc handling of aligned register pairs
            While parisc would normally have the same behavior as ARM/PowerPC,
            they decide to write shim syscall stubs to unpack/realign rather
            than expose the padding to userspace.

tkill.2
    Jann Horn
        Document EAGAIN error for real-time signals

truncate.2
    Michael Kerrisk
        Note use of ftruncate() for POSIX shared memory objects

unlink.2
    Michael Kerrisk
        ERRORS: add EPERM error for immutable/read-only files

vfork.2
    Michael Kerrisk
        Explain why the child should not call exit(3)
    Michael Kerrisk
        Another reason to use vfork() is to avoid overcommitting memory
    Michael Kerrisk
        Note some caveats re the use of vfork()
            Inspired by Rich Felker's post at http://ewontfix.com/7/.
            See also https://sourceware.org/bugzilla/show_bug.cgi?id=14749 and
            See also https://sourceware.org/bugzilla/show_bug.cgi?id=14750.
    Michael Kerrisk
        SEE ALSO: add _exit(2)

write.2
    Michael Kerrisk  [Kai NODA]
        Alert the reader that there is a limit on 'count'
            See https://bugzilla.kernel.org/show_bug.cgi?id=86061

aio_suspend.3
    Michael Kerrisk
        Note that the glibc implementation is not async-signal-safe
            See https://sourceware.org/bugzilla/show_bug.cgi?id=13172

backtrace.3
    Michael Kerrisk
        SEE ALSO: add addr2line(1) and gdb(1)

bcmp.3
bcopy.3
bzero.3
memccpy.3
memchr.3
memcmp.3
memcpy.3
memfrob.3
memmem.3
memmove.3
memset.3
    Michael Kerrisk
        SEE ALSO: add bstring(3)

exec.3
    Michael Kerrisk
        execl() and execle() were not async-signal-safe before glibc 2.24

fopen.3
    Michael Kerrisk  [Helmut Eller]
        Describe freopen() behavior for NULL pathname argument
            See https://bugzilla.kernel.org/show_bug.cgi?id=191261
    Michael Kerrisk
        Note the open(2) flags that correspond to the 'mode' argument
    Michael Kerrisk
        Change argument name: 'path' to 'pathname'
            For consistency with open(2).
    Michael Kerrisk
        Add subsection headings for each function

fts.3
    Michael Kerrisk
        Use better argument name for fts_children() and fts_set()
    Michael Kerrisk
        Fix minor error in FTSENT structure definition
    Michael Kerrisk
        Improve explanation of 'fts_errno'
    Michael Kerrisk
        Give a hint that there are further fields in the FTSENT structure
    Michael Kerrisk
        Clarify meaning of zero as 'instr' value for fts_set()

ftw.3
    Michael Kerrisk
        Correctly handle use of stat info for FTW_NS in example program
    Michael Kerrisk
        Clarify that stat buffer is undefined for FTW_NS

getline.3
    Michael Kerrisk
        EXAMPLE: better error handling
    Michael Kerrisk  [Kent Fredic]
        EXAMPLE: handle null bytes in input
    Jann Horn
        Document ENOMEM error case
            see the error handling in libio/iogetdelim.c
    Michael Kerrisk
        EXAMPLE: specify file to be opened as command-line argument
    Michael Kerrisk
        Use better variable name in example program

getmntent.3
    Michael Kerrisk  [Anders Thulin]
        Prefer '\\' as the escape to get a backslash
            See https://bugzilla.kernel.org/show_bug.cgi?id=191611

getopt.3
    Michael Kerrisk
        Reword discussion of error handling and reporting
            The existing description was hard to understand. Break
            it into a bullet list that separates out the details
            in a manner that is easier to parse.
    Michael Kerrisk
        Correct details of use of <stdio.h> to get getopt() declaration
    Michael Kerrisk  [John Wiersba]
        Remove some redundant text

mq_open.3
    Michael Kerrisk  [Adam Martindale]
        Include definition of the 'mq_attr' structure in this man page
            Make the reader's life a little easier by saving them from
            having to refer to mq_getattr(3).

mq_send.3
    Michael Kerrisk  [Adam Martindale]
        Refer to mq_overview(7) for details on range of message priority

__ppc_set_ppr_med.3
    Wainer dos Santos Moschetta
        Note need for _ARCH_PWR8 macro
            The _ARCH_PWR8 macro must be defined to get the
             __ppc_set_ppr_very_low() and __ppc_set_ppr_med_high()
            definitions.

printf.3
    Michael Kerrisk
        Document nonstandard 'Z' modifier
    Michael Kerrisk
        Document 'q' length modifier
    Michael Kerrisk  [Erik Roland van der Meer]
        Fix a small bug in example code
            Move the second call to va_end(ap) to above the if-block that
            precedes it, so that the va_list 'ap' will be cleaned up in
            all cases.
    Michael Kerrisk  [Nadav Har'El]
        As a nonstandard extension, GNU treats 'll' and 'L' as synonyms
            See https://bugzilla.kernel.org/show_bug.cgi?id=190341.
    Michael Kerrisk
        Add references to setlocale(3) in discussions of locales
    Michael Kerrisk
        SEE ALSO: remove bogus self reference (dprintf(3))

random.3
    Michael Kerrisk
        Relocate information of "optimal" value of initstate() 'n' argument
            The information was a bit hidden in NOTES.

random_r.3
    Michael Kerrisk  [Jan Ziak]
        'buf.state' must be initialized to NULL before calling initstate_r()
            See https://bugzilla.kernel.org/show_bug.cgi?id=192801.
    Michael Kerrisk
        Add some usage notes for setstate_r()
    Michael Kerrisk
        Note that 'buf' records a pointer to 'statebuf'
            See https://sourceware.org/bugzilla/show_bug.cgi?id=3662.
    Michael Kerrisk
        Add BUGS section pointing out the weirdness of the initstate_r() API

resolver.3
    Michael Kerrisk
        RES_AAONLY, RES_PRIMARY, RES_NOCHECKNAME, RES_KEEPTSIG are deprecated
            These options were never implemented; since glibc 2.25, they
            are deprecated.
    Michael Kerrisk
        The RES_NOIP6DOTINT is removed in glibc 2.25
    Michael Kerrisk
        Note that RES_BLAST was unimplemented and is now deprecated
    Michael Kerrisk
        RES_USE_INET6 is deprecated since glibc 2.25
    Michael Kerrisk
        RES_USEBSTRING was removed in glibc 2.25

resolver.3
resolv.conf.5
    Michael Kerrisk
        Note that RES_USEBSTRING defaults to off

scandir.3
    Michael Kerrisk  [Ian Jackson]
        Fix errors in example program
            See http://bugs.debian.org/848231.
    Michael Kerrisk
        Improve logic of the example program

scanf.3
    Michael Kerrisk
        Document the quote (') modifier for decimal conversions

sem_post.3
setjmp.3
    Michael Kerrisk
        SEE ALSO: add signal-safety(7)

sem_wait.3
    Michael Kerrisk  [Fabjan Sukalia]
        Remove statement that SA_RESTART does not cause restarting
            This has not been true since Linux 2.6.22. The description
            of EINTR maintains a reference to signal(7), which explains
            the historical details.

            See https://bugzilla.kernel.org/show_bug.cgi?id=192071

sleep.3
    Michael Kerrisk  [Mike Frysiner]
        Note that sleep() is implemented via nanosleep(2)
            See https://bugzilla.kernel.org/show_bug.cgi?id=73371.
    Michael Kerrisk  [Mike Frysinger]
        Note that sleep() sleeps for a real-time number of seconds
            See https://bugzilla.kernel.org/show_bug.cgi?id=73371.
    Michael Kerrisk
        Convert BUGS text to "Portability notes" subsection
            The existing text is not a bug, as such.
    Michael Kerrisk
        DESCRIPTION: minor reworking

strerror.3
    Heinrich Schuchardt
        Indicate reasonable buffer size for strerror_r() and strerror_l()
            Add a hint which buffer size is needed for
            strerror_r() and strerror_l().

strverscmp.3
    Michael Kerrisk  [Vivenzio Pagliari]
        Fix comparison error in example program

system.3
    Michael Kerrisk
        In the glibc implementation, fork handlers are not executed by system()

random.4
    Michael Kerrisk  [Jon Jensen]
        Note that entropy_avail will be a number in the range 0..4096

core.5
    Michael Kerrisk
        Clarify that dumping program's initial CWD is root directory
    Michael Kerrisk
        The target of core dump piping can also be a script

filesystems.5
    Michael Kerrisk
        SEE ALSO: add btrfs(5), nfs(5), tmpfs(5)

intro.5
    Michael Kerrisk
        Document the reality that by now Section 5 also covers filesystems
            There are by now, from various filesystem projects, various
            pages in Section 5 that document different filesystems.
            Change intro(5) to reflect that.

            Documented after following: http://bugs.debian.org/847998

proc.5
    Mike Frysinger  [Michael Kerrisk]
        Clarify /proc/pid/environ behavior
            /proc/pid/environ reflects process environment at
            *start* of program execution; it is set at time of execve(2)
    Michael Kerrisk
        Add reference to slabinfo(5) in discussion of /proc/meminfo 'Slab' field
    Michael Kerrisk
        Add entries for "keys" files that refer reader to keyrings(7)
    Michael Kerrisk
        Remove duplicate /proc/[pid]/seccomp entry
    Michael Kerrisk
        Mention other system calls that create 'anon_inode' file descriptors
            Mention a few other system calls that create file descriptors
            that display an 'anon_inode' symlink in /proc/PID/fd
    Michael Kerrisk
        Add some detail on overcommit_memory value 1
    Michael Kerrisk
        Add reference to vdso(7) in discussion of /proc/PID/maps

resolv.conf.5
    Michael Kerrisk
        ip6-bytestring was removed in glibc 2.25
    Michael Kerrisk
        The ipc-dotint and no-ip6-dotint options were removed in glibc 2.25
    Michael Kerrisk
        The 'inet6' option is deprecated since glibc 2.25

slabinfo.5
    Michael Kerrisk
        SEE ALSO: add slabtop(1)

capabilities.7
    Michael Kerrisk  [Casey Schaufler]
        Add subsection with notes to kernel developers
            Provide some notes to kernel developers considering how to choose
            which capability should govern a new kernel feature.
    Michael Kerrisk
        Further enhance the recommendation against new uses of CAP_SYS_ADMIN
    Michael Kerrisk
        Explicitly point from CAP_SYS_ADMIN to "Notes for kernel developers"
    Michael Kerrisk
        Add another case for CAP_DAC_READ_SEARCH
    Michael Kerrisk
        Refer to execve(2) for the reasons that file capabilities may be ignored
    Michael Kerrisk
        Document a new use of CAP_SYS_RESOURCE
    Michael Kerrisk
        Add some more operations governed by CAP_SYS_ADMIN
    Michael Kerrisk
        Adjust references to chattr(1) to point to ioctl_iflags(2)

environ.7
    Michael Kerrisk
        Mention prctl(2) PR_SET_MM_ENV_START and PR_SET_MM_ENV_END operations

inotify.7
    Michael Kerrisk
        Point out that inotify monitoring is inode based

ip.7
    Michael Kerrisk
        SEE ALSO: add ip(8)

man.7
uri.7
    Jakub Wilk
        Use "www.kernel.org" in example URLs
            Apparently www.kernelnotes.org is now a spam site.

mount_namespaces.7
    Michael Kerrisk  [Rob Landley]
        Rework the discussion of defaults for mount propagation types
            Add rather more detail. In particular, note the cases where the
            default propagation type is MS_PRIVATE vs MS_SHARED.

namespaces.7
    Michael Kerrisk
        EXAMPLE: fix an error in shell session
    Michael Kerrisk
        EXAMPLE: rename the example program
            Use a more generic name, since this program may be expanded
            in various ways in the future.
    Michael Kerrisk
        SEE ALSO: add ip-netns(8)
    Michael Kerrisk
        Remove content split out into ioctl_ns(2)

netlink.7
    Michael Kerrisk
        NETLINK_IP6_FW went away in Linux 3.5
    Michael Kerrisk
        NETLINK_W1 went away in Linux 2.6.18
    Michael Kerrisk
        Add NETLINK_SCSITRANSPORT to list
    Michael Kerrisk
        Add NETLINK_RDMA to list
    Michael Kerrisk
        NETLINK_FIREWALL was removed in Linux 3.5
    Michael Kerrisk
        NETLINK_NFLOG was removed in Linux 3.17
    Jakub Wilk
        Update libnl homepage URL
            The original URL is 404.

pid_namespaces.7
user_namespaces.7
    Michael Kerrisk
        Adjust references to namespaces(7) to ioctl_ns(2)

pid_namespaces.7
    Keno Fischer
        CLONE_SIGHAND|CLONE_VM|CLONE_NEWPID is no longer disallowed

pipe.7
    Michael Kerrisk
        Since Linux 4.9, pipe-max-size is ceiling for the default pipe capacity
    Michael Kerrisk
        Clarify that default pipe capacity is 16 pages
            The statement that the default pipe capacity is 65536 bytes
            is accurate only on systems where the page size is 4096B.
            See the use of PIPE_DEF_BUFFERS in the kernel source.

random.7
    Michael Kerrisk
        Mention getentropy(3)
    Michael Kerrisk
        SEE ALSO: add getentropy(3)
    Michael Kerrisk
        SEE ALSO: add getauxval(3)
            A small hint to the reader that some random bytes arrive
            in the auxiliary vector.

signal.7
    Michael Kerrisk
        SIGSYS: add reference to seccomp(2)
    Michael Kerrisk
        Change description of SIGSYS to "Bad system call"
            This is the more typical definition.
    Michael Kerrisk
        SIGPIPE: add reference to pipe(7)
    Michael Kerrisk
        SIGXFSZ: add reference to setrlimit(2)
    Michael Kerrisk
        Add a name for SIGEMT
    Michael Kerrisk
        SIGXCPU: add reference to setrlimit(2)
    Michael Kerrisk
        Migrated signal-safety discussion to new signal-safet(7) page

unix.7
    Michael Kerrisk  [Sergey Polovko]
        Since Linux 3.4, UNIX domain sockets support MSG_TRUNC
            This was correctly noted in recv(2), but the unix(7) page
            was not correspondingly updated for the Linux 3.4 change.
    Michael Kerrisk  [Willy Tarreau]
        Document ETOOMANYREFS for SCM_RIGHTS send exceeding RLIMIT_NOFILE limit

user_namespaces.7
    Michael Kerrisk
        Change page cross reference: keyctl(2) ==> keyrings(7)

ld.so.8
    Michael Kerrisk
        LD_BIND_NOT has effect only for function symbols
    Michael Kerrisk
        Describe use of LD_DEBUG with LD_BIND_NOT
    Michael Kerrisk
        In secure mode, LD_AUDIT restricts the libraries that it will load
    Michael Kerrisk
        LD_AUDIT understands $ORIGIN, $LIB, and $PLATFORM

