+1998-07-17 Ulrich Drepper <drepper@cygnus.com>
+
+ * debug/catchsegv.sh: Fix several stupid bugs.
+
+ * shlib-versions: Define version for libSegFault.
+ * debug/Makefile: Replace shared lib version number while rewriting.
+
+1998-07-17 Mark Kettenis <kettenis@phys.uva.nl>
+
+ * sysdeps/mach/hurd/dl-sysdep.c (__mmap): Add sanity check.
+ Suggested by Roland McGrath.
+
+1998-07-15 Andreas Jaeger <aj@arthur.rhein-neckar.de>
+
+ * timezone/Makefile: Remove '-L (leapseconds)' for testdata
+ generation to control environment.
+
+1998-07-17 09:21 Ulrich Drepper <drepper@cygnus.com>
+
+ * sysdeps/unix/sysv/sysv4/solaris2/bits/signum.h: Define SIG_HOLD.
+ Patch by John Tobey <jtobey@banta-im.com>.
+
+ * manual/llio.texi: Document readv/writev and mmap functions.
+ Patch by Michael Deutschmann <michael@talamasca.wkpowerlink.com>.
+
+1998-07-16 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
+
+ * manual/Makefile (texis): Depend on texis.awk.
+ (nonexamples): Filter out add-on chapters.
+ (chapters.% top-menu.%): Depend on libc-texinfo.sh.
+ (stamp-summary): Depend on $(texis) except summary.texi.
+ ($(inst_infodir)/libc.info): Simplify command.
+ * manual/libc-texinfo.sh: Cleaned up to use less temporary files.
+ Fix the generation of the detailed node listing to make it
+ complete again.
+ * manual/math.texi: Fix signature of lgamma_r.
+
1998-07-16 23:06 Ulrich Drepper <drepper@cygnus.com>
* debug/Makefile (distribute): Add sigcontextinfo.h.
$(objpfx)catchsegv: catchsegv.sh $(common-objpfx)soversions.mk \
$(common-objpfx)config.make
- sed 's/@VERSION@/$(version)/;s/@SLIB@/$(slibdir)/' $< > $@.new
+ sed -e 's|@VERSION@|$(version)|' -e 's|@SLIB@|$(slibdir)|' \
+ -e 's|@SOVER@|$(libSegFault.so-version)|' $< > $@.new
chmod 555 $@.new
mv -f $@.new $@
args="$*"
if test $# -eq 0; then
- case "$args" in
+ case "$prog" in
--h | --he | --hel | --help)
echo 'Usage: catchsegv PROGRAM ARGS...'
echo ' --help print this help, then exit'
esac
fi
-LD_PRELOAD="${LD_PRELOAD:+${LD_PRELOAD}:}@SLIB@/libSegFault.so"
+LD_PRELOAD="${LD_PRELOAD:+${LD_PRELOAD}:}@SLIB@/libSegFault.so@SOVER@"
export LD_PRELOAD
SEGFAULT_USE_ALTSTACK=1
export SEGFAULT_USE_ALTSTACK
-SEGFAULT_OUTPUT_NAME="$prog.segv.$$"
+SEGFAULT_OUTPUT_NAME="${TMPDIR:-/tmp}/`basename $prog`.segv.$$"
export SEGFAULT_OUTPUT_NAME
$prog $args
exval=$?
unset LD_PRELOAD
-# Check for an segmentation fault.
+# Check for an segmentation error.
if test $exval -eq 139; then
# We caught a segmentation error. The output is in the file with the
# name we have in SEGFAULT_OUTPUT_NAME. In the output the names of
read line; echo "$line"
while read line; do
case "$line" in
- [*) addr="`echo $line | sed 's/^[\(.*\)]$/\1/'`"
- complete="`addr2line -f -e $prog $addr 2>/dev/null|`"
- if $? -eq 0; then
- echo "`echo $complete|sed 'N;s/\(.*\)\n\(.*\)/\2(\1)/;'`$line"
+ [*) addr="`echo $line | sed 's/^\[\(.*\)\]$/\1/'`"
+ complete="`addr2line -f -e $prog $addr 2>/dev/null`"
+ if test $? -eq 0; then
+ echo "`echo $complete|sed 's/\(.*\) \(.*\)/\2(\1)/;'`$line"
else
echo "$line"
fi
*.toc *.aux *.log *.tmp
*.cp *.cps *.fn *.fns *.vr *.vrs *.tp *.tps *.ky *.kys *.pg *.pgs
-chapters chapters-incl1 chapters-incl2 summary.texi stamp-*
+texis top-menu.texi chapters.texi summary.texi stamp-*
distinfo dir-add.texinfo
mkinstalldirs = $(..)scripts/mkinstalldirs
chapters = $(addsuffix .texi, \
- intro errno memory ctype string mbyte locale message search \
- pattern io stdio llio filesys pipe socket terminal math \
- arith time setjmp signal startup process job nss users \
- sysinfo conf)
-add-chapters = $(wildcard $(patsubst %, ../%.texi, \
- $(join $(add-ons:=/),$(add-ons))))
+ intro errno memory ctype string mbyte locale \
+ message search pattern io stdio llio filesys \
+ pipe socket terminal math arith time setjmp \
+ signal startup process job nss users sysinfo conf)
+add-chapters = $(wildcard $(foreach d, $(add-ons), ../$d/$d.texi))
appendices = lang.texi header.texi install.texi maint.texi contrib.texi
-include texis
-texis: $(chapters) $(add-chapters) $(appendices) lgpl.texinfo
- $(AWK) -f texis.awk $^ > $@.T
+texis: texis.awk $(chapters) $(add-chapters) $(appendices) lgpl.texinfo
+ $(AWK) -f $^ > $@.T
mv -f $@.T $@
-nonexamples = $(filter-out %.c.texi, $(texis))
+nonexamples = $(filter-out $(add-chapters) %.c.texi, $(texis))
examples = $(filter %.c.texi, $(texis))
# Kludge: implicit rule so Make knows the one command does it all.
-chapters.% top-menu.%: $(texis)
- AWK=$(AWK) $(SHELL) libc-texinfo.sh \
- '$(chapters)' '$(add-chapters)' '$(appendices)'
+chapters.% top-menu.%: libc-texinfo.sh $(texis)
+ AWK=$(AWK) $(SHELL) $< '$(chapters)' '$(add-chapters)' '$(appendices)'
libc.dvi libc.info: chapters.texi top-menu.texi
libc.dvi: texinfo.tex
# Generate the summary from the Texinfo source files for each chapter.
summary.texi: stamp-summary ;
-stamp-summary: summary.awk $(chapters) $(chapters-incl)
- $(AWK) -f $^ \
- | sort -df +1 -2 | tr '\014' '\012' > summary-tmp
+stamp-summary: summary.awk $(filter-out summary.texi, $(texis))
+ $(AWK) -f $^ | sort -df +1 -2 | tr '\014' '\012' > summary-tmp
$(move-if-change) summary-tmp summary.texi
touch $@
$(TEXI2DVI) $<
# Distribution.
-minimal-dist = summary.awk texis.awk libc-texinfo.sh libc.texinfo \
- $(filter-out summary.texi, $(nonexamples)) \
+minimal-dist = summary.awk texis.awk libc-texinfo.sh libc.texinfo \
+ $(filter-out summary.texi, $(nonexamples)) \
$(patsubst %.c.texi,examples/%.c, $(examples))
doc-only-dist = Makefile COPYING.LIB
$(inst_infodir)/libc.info: libc.info installdirs
for file in $<*; do \
- name=`basename $$file`; \
- $(INSTALL_DATA) $$file \
- `echo $@ | sed "s,$<\$$,$$name,"`; \
+ $(INSTALL_DATA) $$file $(@D)/$$file; \
done
installdirs:
# Create libc.texinfo from the chapter files.
-grep '^@node.*Top' $1 | cut -d, -f-2 |
- sed 's/, /:/; s/:@node /:/; s/ /_/g; s/:/ /g' >cnodes.$$
-
-$AWK '{ file[$2] = $1; nnode[$2] = $3 }
-END { for(x in file)
- if(file[x] != "")
- print file[x] ":" x, file[nnode[x]] ":" nnode[x] }' \
- cnodes.$$ | tsort | sed 's/_/ /g; $d' >corder.$$
-
-[ -z "$2" ] || grep '^@node.*Top' `echo $2 /dev/null | tr ' ' '\n' | sort` |
- cut -d, -f1 | sed 's/@node //' >xorder.$$
-
-grep '^@node.*Top' $3 | cut -d, -f-2 |
- sed 's/, /:/; s/:@node /:/; s/ /_/g; s/:/ /g' >anodes.$$
-
-$AWK '{ file[$2] = $1; nnode[$2] = $3 }
-END { for(x in file)
- if(file[x] != "")
- print file[x] ":" x, file[nnode[x]] ":" nnode[x] }' \
- anodes.$$ | tsort | sed 's/_/ /g; $d' >aorder.$$
-
-IFS=:
-
->incl.$$
->smenu.$$
->lmenu.$$
-
-while read file node; do
- echo "@include $file" >>incl.$$
- echo "* $node:: `sed -n 's/^@c %MENU% //p' $file`" >>smenu.$$
- lmenu=`sed -n '/^@menu/,/^@end menu/p; /^@end menu/q' $file |
- sed '/^@menu/d; /^@end menu/d'`
- [ -z "$lmenu" ] || (
- echo; echo "$node"; echo
- echo "$lmenu"
- ) >>lmenu.$$
-done <corder.$$
-
-if [ -f xorder.$$ ]; then
-
- (echo; echo 'Add-ons'; echo) >>smenu.$$
-
- while read file node; do
- echo "@include $file" >>incl.$$
- echo "* $node:: `sed -n 's/^@c %MENU% //p' $file`" >>smenu.$$
- lmenu=`sed -n '/^@menu/,/^@end menu/p; /^@end menu/q' $file |
- sed '/^@menu/d; /^@end menu/d'`
- [ -z "$lmenu" ] || (
- echo; echo "$node"; echo
- echo "$lmenu"
- ) >>lmenu.$$
- done <xorder.$$
-fi
+trap "rm -f *.$$; exit 1" 1 2 15
+
+exec 3>incl.$$ 4>smenu.$$ 5>lmenu.$$
+
+build_menu () {
+ while IFS=: read file node; do
+ echo "@include $file" >&3
+ echo "* $node:: `sed -n 's/^@c %MENU% //p' $file`" >&4
+ $AWK 'BEGIN { do_menu = 0 }
+ /^@node / { sub(/^@node /, ""); sub(/,.*$/, ""); node = $0 }
+ /^@menu/ { printf "\n%s\n\n", node; do_menu = 1; next }
+ /^@end menu/ { do_menu = 0 }
+ do_menu { print }' $file >&5
+ done
+}
-(echo; echo 'Appendices'; echo) >>smenu.$$
-
-while read file node; do
- echo "@include $file" >>incl.$$
- echo "* $node:: `sed -n 's/^@c %MENU% //p' $file`" >>smenu.$$
- lmenu=`sed -n '/^@menu/,/^@end menu/p; /^@end menu/q' $file |
- sed '/^@menu/d; /^@end menu/d'`
- [ -z "$lmenu" ] || (
- echo; echo "$node"; echo
- echo "$lmenu"
- ) >>lmenu.$$
-done <aorder.$$
-
-$AWK '
-BEGIN { FS=":" }
-
-/^\*/ {
- printf("%-32s", $1 "::");
- x = split($3, word, " ");
- hpos = 34;
- for(i = 1; i <= x; i++) {
- hpos += length(word[i]) + 1;
- if(hpos > 78) {
- printf("\n%34s", "");
- hpos = 35 + length(word[i]);
- }
- printf(" %s", word[i]);
- }
- print ".";
+collect_nodes () {
+ grep '^@node.*Top' "$@" /dev/null | cut -d, -f-2 |
+ sed 's/, /:/; s/:@node /:/; s/ /_/g; s/:/ /g' |
+ $AWK '{ file[$2] = $1; nnode[$2] = $3 }
+ END { for (x in file)
+ if (file[x] != "")
+ print file[x] ":" x, file[nnode[x]] ":" nnode[x] }' |
+ tsort | sed 's/_/ /g; $d'
}
-!/^\*/ { print; }
-' smenu.$$ >smenux.$$
+collect_nodes $1 | build_menu
+
+if [ -n "$2" ]; then
+
+ { echo; echo 'Add-ons'; echo; } >&4
+
+ grep '^@node.*Top' `echo $2 /dev/null | tr ' ' '\n' | sort` |
+ cut -d, -f1 | sed 's/@node //' | build_menu
+
+fi
+
+{ echo; echo 'Appendices'; echo; } >&4
+
+collect_nodes $3 | build_menu
+
+exec 3>&- 4>&- 5>&-
mv -f incl.$$ chapters.texi
-(echo '@menu'
- cat smenux.$$
+{
+ echo '@menu'
+ $AWK -F: '
+ /^\*/ {
+ printf("%-32s", $1 "::");
+ x = split($3, word, " ");
+ hpos = 34;
+ for (i = 1; i <= x; i++) {
+ hpos += length(word[i]) + 1;
+ if (hpos > 78) {
+ printf("\n%34s", "");
+ hpos = 35 + length(word[i]);
+ }
+ printf(" %s", word[i]);
+ }
+ print ".";
+ }
+
+ !/^\*/ { print; }
+ ' smenu.$$
cat <<EOF
* Copying:: The GNU Library General Public License says
how you can copy and share the GNU C Library.
--- The Detailed Node Listing ---
EOF
cat lmenu.$$
- echo '@end menu' ) >top-menu.texi.$$
+ echo '@end menu'; } >top-menu.texi.$$
mv -f top-menu.texi.$$ top-menu.texi
rm -f *.$$
or vice-versa.
* Stream/Descriptor Precautions:: Precautions needed if you use both
descriptors and streams.
+* Scatter-Gather:: Fast I/O to discontinous buffers.
+* Memory-mapped I/O:: Using files like memory.
* Waiting for I/O:: How to check for input or output
on multiple file descriptors.
* Synchronizing I/O:: Making sure all I/O actions completed.
file locking.
* Interrupt Input:: Getting an asynchronous signal when
input arrives.
+* IOCTLs:: Generic I/O Control operations.
@end menu
@xref{File Status Flags}, for the parameters available.
The normal return value from @code{open} is a non-negative integer file
-descriptor. In the case of an error, a value of @code{-1} is returned
+descriptor. In the case of an error, a value of @math{-1} is returned
instead. In addition to the usual file name errors (@pxref{File
Name Errors}), the following @code{errno} error conditions are defined
for this function:
protected using cancelation handlers.
@c ref pthread_cleanup_push / pthread_cleanup_pop
-The normal return value from @code{close} is @code{0}; a value of @code{-1}
+The normal return value from @code{close} is @math{0}; a value of @math{-1}
is returned in case of failure. The following @code{errno} error
conditions are defined for this function:
tell whether end-of-file was reached. But if you did reach the end, the
next read will return zero.
-In case of an error, @code{read} returns @code{-1}. The following
+In case of an error, @code{read} returns @math{-1}. The following
@code{errno} error conditions are defined for this function:
@table @code
You can use the @code{O_FSYNC} open mode to make @code{write} always
store the data to disk before returning; @pxref{Operating Modes}.
-In the case of an error, @code{write} returns @code{-1}. The following
+In the case of an error, @code{write} returns @math{-1}. The following
@code{errno} error conditions are defined for this function:
@table @code
@cindex holes in files
If the file position cannot be changed, or the operation is in some way
-invalid, @code{lseek} returns a value of @code{-1}. The following
+invalid, @code{lseek} returns a value of @math{-1}. The following
@code{errno} error conditions are defined for this function:
@table @code
This function returns the file descriptor associated with the stream
@var{stream}. If an error is detected (for example, if the @var{stream}
is not valid) or if @var{stream} does not do I/O to a file,
-@code{fileno} returns @code{-1}.
+@code{fileno} returns @math{-1}.
@end deftypefun
@cindex standard file descriptors
streams for that terminal before setting the modes. @xref{Terminal
Modes}.
+@node Scatter-Gather
+@section Fast Scatter-Gather I/O
+@cindex scatter-gather
+
+Some applications may need to read or write data to multiple buffers,
+which are seperated in memory. Although this can be done easily enough
+with multiple calls to @code{read} and @code{write}, it is inefficent
+because there is overhead associated with each kernel call.
+
+Instead, many platforms provide special high-speed primitives to perform
+these @dfn{scatter-gather} operations in a single kernel call. The GNU C
+library will provide an emulation on any system that lacks these
+primitives, so they are not a portability threat. They are defined in
+@code{sys/uio.h}.
+
+These functions are controlled with arrays of @code{iovec} structures,
+which describe the location and size of each buffer.
+
+@deftp {Data Type} {struct iovec}
+
+The @code{iovec} structure describes a buffer. It contains two fields:
+
+@table @code
+
+@item void *iov_base
+Contains the address of a buffer.
+
+@item size_t iov_len
+Contains the length of the buffer.
+
+@end table
+@end deftp
+
+@deftypefun ssize_t readv (int @var{filedes}, const struct iovec *@var{vector}, int @var{count})
+
+The @code{readv} function reads data from @var{filedes} and scatters it
+into the buffers described in @var{vector}, which is taken to be
+@var{count} structures long. As each buffer is filled, data is sent to the
+next.
+
+Note that @code{readv} is not guaranteed to fill all the buffers.
+It may stop at any point, for the same reasons @code{read} would.
+
+The return value is a count of bytes (@emph{not} buffers) read, @math{0}
+indicating end-of-file, or @math{-1} indicating an error. The possible
+errors are the same as in @code{read}.
+
+@end deftypefun
+
+@deftypefun ssize_t writev (int @var{filedes}, const struct iovec *@var{vector}, int @var{count})
+
+The @code{writev} function gathers data from the buffers described in
+@var{vector}, which is taken to be @var{count} structures long, and writes
+them to @code{filedes}. As each buffer is written, it moves on to the
+next.
+
+Like @code{readv}, @code{writev} may stop midstream under the same
+conditions @code{write} would.
+
+The return value is a count of bytes written, or @math{-1} indicating an
+error. The possible errors are the same as in @code{write}.
+
+@end deftypefun
+
+@c Note - I haven't read this anywhere. I surmised it from my knowledge
+@c of computer science. Thus, there could be subtleties I'm missing.
+
+Note that if the buffers are small (under about 1kB), high-level streams
+may be easier to use than these functions. However, @code{readv} and
+@code{writev} are more efficient when the individual buffers themselves
+(as opposed to the total output), are large. In that case, a high-level
+stream would not be able to cache the data effectively.
+
+@node Memory-mapped I/O
+@section Memory-mapped I/O
+
+On modern operating systems, it is possible to @dfn{mmap} (pronounced
+``em-map'') a file to a region of memory. When this is done, the file can
+be accessed just like an array in the program.
+
+This is more efficent than @code{read} or @code{write}, as only regions
+of the file a program actually accesses are loaded. Accesses to
+not-yet-loaded parts of the mmapped region are handled in the same way as
+swapped out pages.
+
+Since mmapped pages can be stored back to their file when physical memory
+is low, it is possible to mmap files orders of magnitude larger than both
+the physical memory @emph{and} swap space. The only limit is address
+space. The theoretical limit is 4GB on a 32-bit machine - however, the
+actual limit will be smaller since some areas will be reserved for other
+purposes.
+
+Memory mapping only works on entire pages of memory. Thus, addresses
+for mapping must be page-aligned, and length values will be rounded up.
+To determine the size of a page the machine uses one should use
+
+@smallexample
+size_t page_size = (size_t) sysconf (_SC_PAGESIZE);
+@end smallexample
+
+These functions are declared in @file{sys/mman.h}.
+
+@deftypefun {void *} mmap (void *@var{address}, size_t @var{length},int @var{protect}, int @var{flags}, int @var{filedes}, off_t @var{offset})
+
+The @code{mmap} function creates a new mapping, connected to bytes
+(@var{offset}) to (@var{offset} + @var{length}) in the file open on
+@var{filedes}.
+
+@var{address} gives a preferred starting address for the mapping.
+@code{NULL} expresses no preference. Any previous mapping at that
+address is automatically removed. The address you give may still be
+changed, unless you use the @code{MAP_FIXED} flag.
+
+@vindex PROT_READ
+@vindex PROT_WRITE
+@vindex PROT_EXEC
+@var{protect} contains flags that control what kind of access is
+permitted. They include @code{PROT_READ}, @code{PROT_WRITE}, and
+@code{PROT_EXEC}, which permit reading, writing, and execution,
+respectively. Inappropriate access will cause a segfault (@pxref{Program
+Error Signals}).
+
+Note that most hardware designs cannot support write permission without
+read permission, and many do not distinguish read and execute permission.
+Thus, you may recieve wider permissions than you ask for, and mappings of
+write-only files may be denied even if you do not use @code{PROT_READ}.
+
+@var{flags} contains flags that control the nature of the map.
+One of @code{MAP_SHARED} or @code{MAP_PRIVATE} must be specified.
+
+They include:
+
+@vtable @code
+@item MAP_PRIVATE
+This specifies that writes to the region should never be written back
+to the attached file. Instead, a copy is made for the process, and the
+region will be swapped normally if memory runs low. No other process will
+see the changes.
+
+Since private mappings effectively revert to ordinary memory
+when written to, you must have enough virtual memory for a copy of
+the entire mmapped region if you use this mode with @code{PROT_WRITE}.
+
+@item MAP_SHARED
+This specifies that writes to the region will be written back to the
+file. Changes made will be shared immediately with other processes
+mmaping the same file.
+
+Note that actual writing may take place at any time. You need to use
+@code{msync}, described below, if it is important that other processes
+using conventional I/O get a consistent view of the file.
+
+@item MAP_FIXED
+This forces the system to use the exact mapping address specified in
+@var{address} and fail if it can't.
+
+@c One of these is official - the other is obviously an obsolete synonym
+@c Which is which?
+@item MAP_ANONYMOUS
+@itemx MAP_ANON
+This flag tells the system to create an anonymous mapping, not connected
+to a file. @var{filedes} and @var{off} are ignored, and the region is
+initialized with zeros.
+
+Anonymous maps are used as the basic primitive to extend the heap on some
+systems. They are also useful to share data between multiple tasks
+without creating a file.
+
+On some systems using private anonymous mmaps is more efficent than using
+@code{malloc} for large blocks. This is not an issue with the GNU C library,
+as the included @code{malloc} automatically uses @code{mmap} where appropriate.
+
+@c Linux has some other MAP_ options, which I have not discussed here.
+@c MAP_DENYWRITE, MAP_EXECUTABLE and MAP_GROWSDOWN don't seem applicable to
+@c user programs (and I don't understand the last two). MAP_LOCKED does
+@c not appear to be implemented.
+
+@end vtable
+
+@code{mmap} returns the address of the new mapping, or @math{-1} for an
+error.
+
+Possible errors include:
+
+@table @code
+
+@item EINVAL
+
+Either @var{address} was unusable, or inconsistent @var{flags} were
+given.
+
+@item EACCES
+
+@var{filedes} was not open for the type of access specified in @var{protect}.
+
+@item ENOMEM
+
+Either there is not enough memory for the operation, or the process is
+out of address space.
+
+@item ENODEV
+
+This file is of a type that doesn't support mapping.
+
+@item ENOEXEC
+
+The file is on a filesystem that doesn't support mapping.
+
+@c On Linux, EAGAIN will appear if the file has a conflicting mandatory lock.
+@c However mandatory locks are not discussed in this manual.
+@c
+@c Similarly, ETXTBSY will occur if the MAP_DENYWRITE flag (not documented
+@c here) is used and the file is already open for writing.
+
+@end table
+
+@end deftypefun
+
+@deftypefun int munmap (void *@var{addr}, size_t @var{length})
+
+@code{munmap} removes any memory maps from (@var{addr}) to (@var{addr} +
+@var{length}). @var{length} should be the length of the mapping.
+
+It is safe to un-map multiple mappings in one command, or include unmapped
+space in the range. It is also possible to unmap only part of an existing
+mapping, however only entire pages can be removed. If @var{length} is not
+an even number of pages, it will be rounded up.
+
+It returns @math{0} for success and @math{-1} for an error.
+
+One error is possible:
+
+@table @code
+
+@item EINVAL
+The memory range given was outside the user mmap range, or wasn't page
+aligned.
+
+@end table
+
+@end deftypefun
+
+@deftypefun int msync (void *@var{address}, size_t @var{length}, int @var{flags})
+
+When using shared mappings, the kernel can write the file at any time
+before the mapping is removed. To be certain data has actually been
+written to the file and will be accessable to non-memory-mapped I/O, it
+is neccessary to use this function.
+
+It operates on the region @var{address} to (@var{address} + @var{length}).
+It may be used on part of a mapping or multiple mappings, however the
+region given should not contain any unmapped space.
+
+@var{flags} can contain some options:
+
+@vtable @code
+
+@item MS_SYNC
+
+This flag makes sure the data is actually written @emph{to disk}.
+Normally @code{msync} only makes sure that accesses to a file with
+conventional I/O reflect the recent changes.
+
+@item MS_ASYNC
+
+This tells @code{msync} to begin the synchronization, but not to wait for
+it to complete.
+
+@c Linux also has MS_INVALIDATE, which I don't understand.
+
+@end vtable
+
+@code{msync} returns @math{0} for success and @math{-1} for
+error. Errors include:
+
+@table @code
+
+@item EINVAL
+An invalid region was given, or the @var{flags} were invalid.
+
+@item EFAULT
+There is no existing mapping in at least part of the given region.
+
+@end table
+
+@end deftypefun
+
+@deftypefun {void *} mremap (void *@var{address}, size_t @var{length}, size_t @var{new_length}, int @var{flag})
+
+This function can be used to change the size of an existing memory
+area. @var{address} and @var{length} must cover a region entirely mapped
+in the same @code{mmap} statement. A new mapping with the same
+characteristics will be returned, but a with the length @var{new_length}
+instead.
+
+One option is possible, @code{MREMAP_MAYMOVE}. If it is given in
+@var{flags}, the system may remove the existing mapping and create a new
+one of the desired length in another location.
+
+The address of the resulting mapping is returned, or @math{-1}. Possible
+error codes include:
+
+This function is only available on a few systems. Except for performing
+optional optimizations one should not rely on this function.
+@table @code
+
+@item EFAULT
+There is no existing mapping in at least part of the original region, or
+the region covers two or more distinct mappings.
+
+@item EINVAL
+The address given is misaligned or inappropriate.
+
+@item EAGAIN
+The region has pages locked, and if extended it would exceed the
+process's resource limit for locked pages. @xref{Limits on Resources}.
+
+@item ENOMEM
+The region is private writable, and insufficent virtual memory is
+available to extend it. Also, this error will occur if
+@code{MREMAP_MAYMOVE} is not given and the extension would collide with
+another mapped region.
+
+@end table
+@end deftypefun
+
+Not all file descriptors may be mapped. Sockets, pipes, and most devices
+only allow sequential access and do not fit into the mapping abstraction.
+In addition, some regular files may not be mmapable, and older kernels may
+not support mapping at all. Thus, programs using @code{mmap} should
+have a fallback method to use should it fail. @xref{Mmap,,,standards,GNU
+Coding Standards}.
+
+@c XXX madvice documentation missing
+
@node Waiting for I/O
@section Waiting for Input or Output
@cindex waiting for input or output
than or equal to this value.
The return value from @code{fcntl} with this command is normally the value
-of the new file descriptor. A return value of @code{-1} indicates an
+of the new file descriptor. A return value of @math{-1} indicates an
error. The following @code{errno} error conditions are defined for
this command:
nonnegative number which can be interpreted as the bitwise OR of the
individual flags (except that currently there is only one flag to use).
-In case of an error, @code{fcntl} returns @code{-1}. The following
+In case of an error, @code{fcntl} returns @math{-1}. The following
@code{errno} error conditions are defined for this command:
@table @code
@end smallexample
The normal return value from @code{fcntl} with this command is an
-unspecified value other than @code{-1}, which indicates an error.
+unspecified value other than @math{-1}, which indicates an error.
The flags and error conditions are the same as for the @code{F_GETFD}
command.
@end deftypevr
you can mask off other bits in the returned flags with @code{O_ACCMODE}
to compare them.
-In case of an error, @code{fcntl} returns @code{-1}. The following
+In case of an error, @code{fcntl} returns @math{-1}. The following
@code{errno} error conditions are defined for this command:
@table @code
whether the file descriptor was opened for reading or writing.
The normal return value from @code{fcntl} with this command is an
-unspecified value other than @code{-1}, which indicates an error. The
+unspecified value other than @math{-1}, which indicates an error. The
error conditions are the same as for the @code{F_GETFL} command.
@end deftypevr
update the @code{l_type} to a value of @code{F_UNLCK}.
The normal return value from @code{fcntl} with this command is an
-unspecified value other than @code{-1}, which is reserved to indicate an
+unspecified value other than @math{-1}, which is reserved to indicate an
error. The following @code{errno} error conditions are defined for
this command:
by specifying a lock type of @code{F_UNLCK}.
If the lock cannot be set, @code{fcntl} returns immediately with a value
-of @code{-1}. This function does not block waiting for other processes
+of @math{-1}. This function does not block waiting for other processes
to release locks. If @code{fcntl} succeeds, it return a value other
-than @code{-1}.
+than @math{-1}.
The following @code{errno} error conditions are defined for this
function:
The @var{pid} argument should be a process ID. You can also pass a
negative number whose absolute value is a process group ID.
-The return value from @code{fcntl} with this command is @code{-1}
+The return value from @code{fcntl} with this command is @math{-1}
in case of error and some other value if successful. The following
@code{errno} error conditions are defined for this command:
@end deftypevr
@c ??? This section could use an example program.
+
+@node IOCTLs
+@section Generic I/O Control operations
+@cindex generic i/o control operations
+@cindex IOCTLs
+
+The GNU system can handle most input/output operations on many different
+devices and objects in terms of a few file primitives - @code{read},
+@code{write} and @code{lseek}. However, most devices also have a few
+peculiar operations which do not fit into this model. Such as:
+
+@itemize @bullet
+
+@item
+Changing the character font used on a terminal.
+
+@item
+Telling a magnetic tape system to rewind or fast forward. (Since they
+cannot move in byte increments, @code{lseek} is inapplicable).
+
+@item
+Ejecting a disk from a drive.
+
+@item
+Playing an audio track from a CD-ROM drive.
+
+@item
+Maintaining routing tables for a network.
+
+@end itemize
+
+Although some such objects such as sockets and terminals
+@footnote{Actually, the terminal-specific functions are implemented with
+IOCTLs on many platforms.} have special functions of their own, it would
+not be practical to create functions for all these cases.
+
+Instead these minor operations, known as @dfn{IOCTL}s, are assigned code
+numbers and multiplexed through the @code{ioctl} function, defined in
+@code{sys/ioctl.h}. The code numbers themselves are defined in many
+different headers.
+
+@deftypefun int ioctl (int @var{filedes}, int @var{command}, @dots{})
+
+The @code{ioctl} function performs the generic I/O operation
+@var{command} on @var{filedes}.
+
+A third argument is usually present, either a single number or a pointer
+to a structure. The meaning of this argument, the returned value, and
+any error codes depends upon the command used. Often @math{-1} is
+returned for a failure.
+
+@end deftypefun
+
+On some systems, IOCTLs used by different devices share the same numbers.
+Thus, although use of an inappropriate IOCTL @emph{usually} only produces
+an error, you should not attempt to use device-specific IOCTLs on an
+unknown device.
+
+Most IOCTLs are OS-specific and/or only used in special system utilities,
+and are thus beyond the scope of this document. For an example of the use
+of an IOCTL, @xref{Out-of-Band Data}.
@comment math.h
@comment XPG
-@deftypefun double lgamma_r (double @var{x})
-@deftypefunx float lgammaf_r (float @var{x})
-@deftypefunx {long double} lgammal_r (long double @var{x})
+@deftypefun double lgamma_r (double @var{x}, int *@var{signp})
+@deftypefunx float lgammaf_r (float @var{x}, int *@var{signp})
+@deftypefunx {long double} lgammal_r (long double @var{x}, int *@var{signp})
@code{lgamma_r} is just like @code{lgamma}, but it stores the sign of
the intermediate result in the variable pointed to by @var{signp}
instead of in the @var{signgam} global.
* Roadmap to the Manual:: Overview of the remaining chapters in
this manual.
+Standards and Portability
+
+* ISO C:: The international standard for the C
+ programming language.
+* POSIX:: The ISO/IEC 9945 (aka IEEE 1003) standards
+ for operating systems.
+* Berkeley Unix:: BSD and SunOS.
+* SVID:: The System V Interface Description.
+* XPG:: The X/Open Portability Guide.
+
+Using the Library
+
+* Header Files:: How to include the header files in your
+ programs.
+* Macro Definitions:: Some functions in the library may really
+ be implemented as macros.
+* Reserved Names:: The C standard reserves some names for
+ the library, and some for users.
+* Feature Test Macros:: How to control what names are defined.
+
Error Reporting
* Checking for Errors:: How errors are reported by library functions.
* Relocating Allocator:: Waste less memory, if you can tolerate
automatic relocation of the blocks you get.
+Unconstrained Allocation
+
+* Basic Allocation:: Simple use of @code{malloc}.
+* Malloc Examples:: Examples of @code{malloc}. @code{xmalloc}.
+* Freeing after Malloc:: Use @code{free} to free a block you
+ got with @code{malloc}.
+* Changing Block Size:: Use @code{realloc} to make a block
+ bigger or smaller.
+* Allocating Cleared Space:: Use @code{calloc} to allocate a
+ block and clear it.
+* Efficiency and Malloc:: Efficiency considerations in use of
+ these functions.
+* Aligned Memory Blocks:: Allocating specially aligned memory:
+ @code{memalign} and @code{valloc}.
+* Malloc Tunable Parameters:: Use @code{mallopt} to adjust allocation
+ parameters.
+* Heap Consistency Checking:: Automatic checking for errors.
+* Hooks for Malloc:: You can use these hooks for debugging
+ programs that use @code{malloc}.
+* Statistics of Malloc:: Getting information about how much
+ memory your program is using.
+* Summary of Malloc:: Summary of @code{malloc} and related functions.
+
+Allocation Debugging
+
+* Tracing malloc:: How to install the tracing functionality.
+* Using the Memory Debugger:: Example programs excerpts.
+* Tips for the Memory Debugger:: Some more or less clever ideas.
+* Interpreting the traces:: What do all these lines mean?
+
+Obstacks
+
+* Creating Obstacks:: How to declare an obstack in your program.
+* Preparing for Obstacks:: Preparations needed before you can
+ use obstacks.
+* Allocation in an Obstack:: Allocating objects in an obstack.
+* Freeing Obstack Objects:: Freeing objects in an obstack.
+* Obstack Functions:: The obstack functions are both
+ functions and macros.
+* Growing Objects:: Making an object bigger by stages.
+* Extra Fast Growing:: Extra-high-efficiency (though more
+ complicated) growing objects.
+* Status of an Obstack:: Inquiries about the status of an obstack.
+* Obstacks Data Alignment:: Controlling alignment of objects in obstacks.
+* Obstack Chunks:: How obstacks obtain and release chunks;
+ efficiency considerations.
+* Summary of Obstacks::
+
+Variable Size Automatic
+
+* Alloca Example:: Example of using @code{alloca}.
+* Advantages of Alloca:: Reasons to use @code{alloca}.
+* Disadvantages of Alloca:: Reasons to avoid @code{alloca}.
+* GNU C Variable-Size Arrays:: Only in GNU C, here is an alternative
+ method of allocating dynamically and
+ freeing automatically.
+
+Relocating Allocator
+
+* Relocator Concepts:: How to understand relocating allocation.
+* Using Relocator:: Functions for relocating allocation.
+
Character Handling
* Classification of Characters:: Testing whether characters are
* Encode Binary Data:: Encoding and Decoding of Binary Data.
* Argz and Envz Vectors:: Null-separated string vectors.
+Argz and Envz Vectors
+
+* Argz Functions:: Operations on argz vectors.
+* Envz Functions:: Additional operations on environment vectors.
+
Extended Characters
* Extended Char Intro:: Multibyte codes versus wide characters.
* Numeric Formatting:: How to format numbers according to the
chosen locale.
+Numeric Formatting
+
+* General Numeric:: Parameters for formatting numbers and
+ currency amounts.
+* Currency Symbol:: How to print the symbol that identifies an
+ amount of money (e.g. @samp{$}).
+* Sign of Money Amount:: How to print the (positive or negative) sign
+ for a monetary amount, if one exists.
+
Message Translation
* Message catalogs a la X/Open:: The @code{catgets} family of functions.
* The Uniforum approach:: The @code{gettext} family of functions.
+Message catalogs a la X/Open
+
+* The catgets Functions:: The @code{catgets} function family.
+* The message catalog files:: Format of the message catalog files.
+* The gencat program:: How to generate message catalogs files which
+ can be used by the functions.
+* Common Usage:: How to use the @code{catgets} interface.
+
+The Uniforum approach
+
+* Message catalogs with gettext:: The @code{gettext} family of functions.
+* Helper programs for gettext:: Programs to handle message catalogs
+ for @code{gettext}.
+
+Message catalogs with gettext
+
+* Translation with gettext:: What has to be done to translate a message.
+* Locating gettext catalog:: How to determine which catalog to be used.
+* Using gettextized software:: The possibilities of the user to influence
+ the way @code{gettext} works.
+
Searching and Sorting
* Comparison Functions:: Defining how to compare two objects.
arithmetic, and wildcards.
This is what the shell does with shell commands.
+Globbing
+
+* Calling Glob:: Basic use of @code{glob}.
+* Flags for Globbing:: Flags that enable various options in @code{glob}.
+* More Flags for Globbing:: GNU specific extensions to @code{glob}.
+
+Regular Expressions
+
+* POSIX Regexp Compilation:: Using @code{regcomp} to prepare to match.
+* Flags for POSIX Regexps:: Syntax variations for @code{regcomp}.
+* Matching POSIX Regexps:: Using @code{regexec} to match the compiled
+ pattern that you get from @code{regcomp}.
+* Regexp Subexpressions:: Finding which parts of the string were matched.
+* Subexpression Complications:: Find points of which parts were matched.
+* Regexp Cleanup:: Freeing storage; reporting errors.
+
+Word Expansion
+
+* Expansion Stages:: What word expansion does to a string.
+* Calling Wordexp:: How to call @code{wordexp}.
+* Flags for Wordexp:: Options you can enable in @code{wordexp}.
+* Wordexp Example:: A sample program that does word expansion.
+
I/O Overview
* I/O Concepts:: Some basic information and terminology.
* File Names:: How to refer to a file.
+I/O Concepts
+
+* Streams and File Descriptors:: The GNU Library provides two ways
+ to access the contents of files.
+* File Position:: The number of bytes from the
+ beginning of the file.
+
+File Names
+
+* Directories:: Directories contain entries for files.
+* File Name Resolution:: A file name specifies how to look up a file.
+* File Name Errors:: Error conditions relating to file names.
+* File Name Portability:: File name portability and syntax issues.
+
I/O on Streams
* Streams:: About the data type representing a stream.
to an open file.
* Formatted Messages:: Print strictly formatted messages.
+Unreading
+
+* Unreading Idea:: An explanation of unreading with pictures.
+* How Unread:: How to call @code{ungetc} to do unreading.
+
+Formatted Output
+
+* Formatted Output Basics:: Some examples to get you started.
+* Output Conversion Syntax:: General syntax of conversion
+ specifications.
+* Table of Output Conversions:: Summary of output conversions and
+ what they do.
+* Integer Conversions:: Details about formatting of integers.
+* Floating-Point Conversions:: Details about formatting of
+ floating-point numbers.
+* Other Output Conversions:: Details about formatting of strings,
+ characters, pointers, and the like.
+* Formatted Output Functions:: Descriptions of the actual functions.
+* Dynamic Output:: Functions that allocate memory for the output.
+* Variable Arguments Output:: @code{vprintf} and friends.
+* Parsing a Template String:: What kinds of args does a given template
+ call for?
+* Example of Parsing:: Sample program using @code{parse_printf_format}.
+
+Customizing Printf
+
+* Registering New Conversions:: Using @code{register_printf_function}
+ to register a new output conversion.
+* Conversion Specifier Options:: The handler must be able to get
+ the options specified in the
+ template when it is called.
+* Defining the Output Handler:: Defining the handler and arginfo
+ functions that are passed as arguments
+ to @code{register_printf_function}.
+* Printf Extension Example:: How to define a @code{printf}
+ handler function.
+* Predefined Printf Handlers:: Predefined @code{printf} handlers.
+
+Formatted Input
+
+* Formatted Input Basics:: Some basics to get you started.
+* Input Conversion Syntax:: Syntax of conversion specifications.
+* Table of Input Conversions:: Summary of input conversions and what they do.
+* Numeric Input Conversions:: Details of conversions for reading numbers.
+* String Input Conversions:: Details of conversions for reading strings.
+* Dynamic String Input:: String conversions that @code{malloc} the buffer.
+* Other Input Conversions:: Details of miscellaneous other conversions.
+* Formatted Input Functions:: Descriptions of the actual functions.
+* Variable Arguments Input:: @code{vscanf} and friends.
+
+Stream Buffering
+
+* Buffering Concepts:: Terminology is defined here.
+* Flushing Buffers:: How to ensure that output buffers are flushed.
+* Controlling Buffering:: How to specify what kind of buffering to use.
+
+Other Kinds of Streams
+
+* String Streams:: Streams that get data from or put data in
+ a string or memory buffer.
+* Obstack Streams:: Streams that store data in an obstack.
+* Custom Streams:: Defining your own streams with an arbitrary
+ input data source and/or output data sink.
+
+Custom Streams
+
+* Streams and Cookies:: The @dfn{cookie} records where to fetch or
+ store data that is read or written.
+* Hook Functions:: How you should define the four @dfn{hook
+ functions} that a custom stream needs.
+
+Formatted Messages
+
+* Printing Formatted Messages:: The @code{fmtmsg} function.
+* Adding Severity Classes:: Add more severity classes.
+* Example:: How to use @code{fmtmsg} and @code{addseverity}.
+
Low-Level I/O
* Opening and Closing Files:: How to open and close file
or vice-versa.
* Stream/Descriptor Precautions:: Precautions needed if you use both
descriptors and streams.
+* Scatter-Gather:: Fast I/O to discontinous buffers.
+* Memory-mapped I/O:: Using files like memory.
* Waiting for I/O:: How to check for input or output
on multiple file descriptors.
* Synchronizing I/O:: Making sure all I/O actions completed.
file locking.
* Interrupt Input:: Getting an asynchronous signal when
input arrives.
+* IOCTLs:: Generic I/O Control operations.
+
+Stream/Descriptor Precautions
+
+* Linked Channels:: Dealing with channels sharing a file position.
+* Independent Channels:: Dealing with separately opened, unlinked channels.
+* Cleaning Streams:: Cleaning a stream makes it safe to use
+ another channel.
+
+Asynchronous I/O
+
+* Asynchronous Reads/Writes:: Asynchronous Read and Write Operations.
+* Status of AIO Operations:: Getting the Status of AIO Operations.
+* Synchronizing AIO Operations:: Getting into a consistent state.
+* Cancel AIO Operations:: Cancelation of AIO Operations.
+* Configuration of AIO:: How to optimize the AIO implementation.
+
+File Status Flags
+
+* Access Modes:: Whether the descriptor can read or write.
+* Open-time Flags:: Details of @code{open}.
+* Operating Modes:: Special modes to control I/O operations.
+* Getting File Status Flags:: Fetching and changing these flags.
File System Interface
* Making Special Files:: How to create special files.
* Temporary Files:: Naming and creating temporary files.
+Accessing Directories
+
+* Directory Entries:: Format of one directory entry.
+* Opening a Directory:: How to open a directory stream.
+* Reading/Closing Directory:: How to read directory entries from the stream.
+* Simple Directory Lister:: A very simple directory listing program.
+* Random Access Directory:: Rereading part of the directory
+ already read with the same stream.
+* Scanning Directory Content:: Get entries for user selected subset of
+ contents in given directory.
+* Simple Directory Lister Mark II:: Revised version of the program.
+
+File Attributes
+
+* Attribute Meanings:: The names of the file attributes,
+ and what their values mean.
+* Reading Attributes:: How to read the attributes of a file.
+* Testing File Type:: Distinguishing ordinary files,
+ directories, links...
+* File Owner:: How ownership for new files is determined,
+ and how to change it.
+* Permission Bits:: How information about a file's access
+ mode is stored.
+* Access Permission:: How the system decides who can access a file.
+* Setting Permissions:: How permissions for new files are assigned,
+ and how to change them.
+* Testing File Access:: How to find out if your process can
+ access a file.
+* File Times:: About the time attributes of a file.
+
Pipes and FIFOs
* Creating a Pipe:: Making a pipe with the @code{pipe} function.
* Socket Options:: Miscellaneous low-level socket options.
* Networks Database:: Accessing the database of network names.
+Socket Addresses
+
+* Address Formats:: About @code{struct sockaddr}.
+* Setting Address:: Binding an address to a socket.
+* Reading Address:: Reading the address of a socket.
+
+Local Namespace
+
+* Concepts: Local Namespace Concepts. What you need to understand.
+* Details: Local Namespace Details. Address format, symbolic names, etc.
+* Example: Local Socket Example. Example of creating a socket.
+
+Internet Namespace
+
+* Internet Address Formats:: How socket addresses are specified in the
+ Internet namespace.
+* Host Addresses:: All about host addresses of internet host.
+* Protocols Database:: Referring to protocols by name.
+* Ports:: Internet port numbers.
+* Services Database:: Ports may have symbolic names.
+* Byte Order:: Different hosts may use different byte
+ ordering conventions; you need to
+ canonicalize host address and port number.
+* Inet Example:: Putting it all together.
+
+Host Addresses
+
+* Abstract Host Addresses:: What a host number consists of.
+* Data type: Host Address Data Type. Data type for a host number.
+* Functions: Host Address Functions. Functions to operate on them.
+* Names: Host Names. Translating host names to host numbers.
+
+Open/Close Sockets
+
+* Creating a Socket:: How to open a socket.
+* Closing a Socket:: How to close a socket.
+* Socket Pairs:: These are created like pipes.
+
+Connections
+
+* Connecting:: What the client program must do.
+* Listening:: How a server program waits for requests.
+* Accepting Connections:: What the server does when it gets a request.
+* Who is Connected:: Getting the address of the
+ other side of a connection.
+* Transferring Data:: How to send and receive data.
+* Byte Stream Example:: An example program: a client for communicating
+ over a byte stream socket in the Internet namespace.
+* Server Example:: A corresponding server program.
+* Out-of-Band Data:: This is an advanced feature.
+
+Transferring Data
+
+* Sending Data:: Sending data with @code{send}.
+* Receiving Data:: Reading data with @code{recv}.
+* Socket Data Options:: Using @code{send} and @code{recv}.
+
+Datagrams
+
+* Sending Datagrams:: Sending packets on a datagram socket.
+* Receiving Datagrams:: Receiving packets on a datagram socket.
+* Datagram Example:: An example program: packets sent over a
+ datagram socket in the local namespace.
+* Example Receiver:: Another program, that receives those packets.
+
+Inetd
+
+* Inetd Servers::
+* Configuring Inetd::
+
+Socket Options
+
+* Socket Option Functions:: The basic functions for setting and getting
+ socket options.
+* Socket-Level Options:: Details of the options at the socket level.
+
Low-Level Terminal Interface
* Is It a Terminal:: How to determine if a file is a terminal
* Noncanon Example:: How to read single characters without echo.
* Pseudo-Terminals:: How to open a pseudo-terminal.
+Terminal Modes
+
+* Mode Data Types:: The data type @code{struct termios} and
+ related types.
+* Mode Functions:: Functions to read and set the terminal
+ attributes.
+* Setting Modes:: The right way to set terminal attributes
+ reliably.
+* Input Modes:: Flags controlling low-level input handling.
+* Output Modes:: Flags controlling low-level output handling.
+* Control Modes:: Flags controlling serial port behavior.
+* Local Modes:: Flags controlling high-level input handling.
+* Line Speed:: How to read and set the terminal line speed.
+* Special Characters:: Characters that have special effects,
+ and how to change them.
+* Noncanonical Input:: Controlling how long to wait for input.
+
+Special Characters
+
+* Editing Characters:: Special characters that terminate lines and
+ delete text, and other editing functions.
+* Signal Characters:: Special characters that send or raise signals
+ to or for certain classes of processes.
+* Start/Stop Characters:: Special characters that suspend or resume
+ suspended output.
+* Other Special:: Other special characters for BSD systems:
+ they can discard output, and print status.
+
+Pseudo-Terminals
+
+* Allocation:: Allocating a pseudo terminal.
+* Pseudo-Terminal Pairs:: How to open both sides of a
+ pseudo-terminal in a single operation.
+
Mathematics
* Mathematical Constants:: Precise numeric values for often-used
numbers.
* FP Function Optimizations:: Fast code or small code.
+Pseudo-Random Numbers
+
+* ISO Random:: @code{rand} and friends.
+* BSD Random:: @code{random} and friends.
+* SVID Random:: @code{drand48} and friends.
+
Arithmetic
* Floating Point Numbers:: Basic concepts. IEEE 754.
* Parsing of Numbers:: Converting strings to numbers.
* System V Number Conversion:: An archaic way to convert numbers to strings.
+Floating Point Errors
+
+* FP Exceptions:: IEEE 754 math exceptions and how to detect them.
+* Infinity and NaN:: Special values returned by calculations.
+* Status bit operations:: Checking for exceptions after the fact.
+* Math Error Reporting:: How the math functions report errors.
+
+Arithmetic Functions
+
+* Absolute Value:: Absolute values of integers and floats.
+* Normalization Functions:: Extracting exponents and putting them back.
+* Rounding Functions:: Rounding floats to integers.
+* Remainder Functions:: Remainders on division, precisely defined.
+* FP Bit Twiddling:: Sign bit adjustment. Adding epsilon.
+* FP Comparison Functions:: Comparisons without risk of exceptions.
+* Misc FP Arithmetic:: Max, min, positive difference, multiply-add.
+
+Parsing of Numbers
+
+* Parsing of Integers:: Functions for conversion of integer values.
+* Parsing of Floats:: Functions for conversion of floating-point
+ values.
+
Date and Time
* Processor Time:: Measures processor time used by a program.
* Limits on Resources:: Specifying limits on resource usage.
* Priority:: Reading or setting process run priority.
+Processor Time
+
+* Basic CPU Time:: The @code{clock} function.
+* Detailed CPU Time:: The @code{times} function.
+
+Calendar Time
+
+* Simple Calendar Time:: Facilities for manipulating calendar time.
+* High-Resolution Calendar:: A time representation with greater precision.
+* Broken-down Time:: Facilities for manipulating local time.
+* Formatting Date and Time:: Converting times to strings.
+* TZ Variable:: How users specify the time zone.
+* Time Zone Functions:: Functions to examine or specify the time zone.
+* Time Functions Example:: An example program showing use of some of
+ the time functions.
+
Non-Local Exits
* Intro: Non-Local Intro. When and how to use these facilities.
* BSD Signal Handling:: Additional functions for backward
compatibility with BSD.
+Concepts of Signals
+
+* Kinds of Signals:: Some examples of what can cause a signal.
+* Signal Generation:: Concepts of why and how signals occur.
+* Delivery of Signal:: Concepts of what a signal does to the
+ process.
+
+Standard Signals
+
+* Program Error Signals:: Used to report serious program errors.
+* Termination Signals:: Used to interrupt and/or terminate the
+ program.
+* Alarm Signals:: Used to indicate expiration of timers.
+* Asynchronous I/O Signals:: Used to indicate input is available.
+* Job Control Signals:: Signals used to support job control.
+* Operation Error Signals:: Used to report operational system errors.
+* Miscellaneous Signals:: Miscellaneous Signals.
+* Signal Messages:: Printing a message describing a signal.
+
+Signal Actions
+
+* Basic Signal Handling:: The simple @code{signal} function.
+* Advanced Signal Handling:: The more powerful @code{sigaction} function.
+* Signal and Sigaction:: How those two functions interact.
+* Sigaction Function Example:: An example of using the sigaction function.
+* Flags for Sigaction:: Specifying options for signal handling.
+* Initial Signal Actions:: How programs inherit signal actions.
+
+Defining Handlers
+
+* Handler Returns:: Handlers that return normally, and what
+ this means.
+* Termination in Handler:: How handler functions terminate a program.
+* Longjmp in Handler:: Nonlocal transfer of control out of a
+ signal handler.
+* Signals in Handler:: What happens when signals arrive while
+ the handler is already occupied.
+* Merged Signals:: When a second signal arrives before the
+ first is handled.
+* Nonreentrancy:: Do not call any functions unless you know they
+ are reentrant with respect to signals.
+* Atomic Data Access:: A single handler can run in the middle of
+ reading or writing a single object.
+
+Atomic Data Access
+
+* Non-atomic Example:: A program illustrating interrupted access.
+* Types: Atomic Types. Data types that guarantee no interruption.
+* Usage: Atomic Usage. Proving that interruption is harmless.
+
+Generating Signals
+
+* Signaling Yourself:: A process can send a signal to itself.
+* Signaling Another Process:: Send a signal to another process.
+* Permission for kill:: Permission for using @code{kill}.
+* Kill Example:: Using @code{kill} for Communication.
+
+Blocking Signals
+
+* Why Block:: The purpose of blocking signals.
+* Signal Sets:: How to specify which signals to
+ block.
+* Process Signal Mask:: Blocking delivery of signals to your
+ process during normal execution.
+* Testing for Delivery:: Blocking to Test for Delivery of
+ a Signal.
+* Blocking for Handler:: Blocking additional signals while a
+ handler is being run.
+* Checking for Pending Signals:: Checking for Pending Signals
+* Remembering a Signal:: How you can get almost the same
+ effect as blocking a signal, by
+ handling it and setting a flag
+ to be tested later.
+
+Waiting for a Signal
+
+* Using Pause:: The simple way, using @code{pause}.
+* Pause Problems:: Why the simple way is often not very good.
+* Sigsuspend:: Reliably waiting for a specific signal.
+
+BSD Signal Handling
+
+* BSD Handler:: BSD Function to Establish a Handler.
+* Blocking in BSD:: BSD Functions for Blocking Signals.
+
Process Startup
* Program Arguments:: Parsing your program's command-line arguments.
* Program Termination:: How to cause a process to terminate and
return status information to its parent.
+Program Arguments
+
+* Argument Syntax:: By convention, options start with a hyphen.
+* Parsing Program Arguments:: Ways to parse program options and arguments.
+
+Parsing Program Arguments
+
+* Getopt:: Parsing program options using @code{getopt}.
+* Argp:: Parsing program options using @code{argp_parse}.
+* Suboptions:: Some programs need more detailed options.
+* Suboptions Example:: This shows how it could be done for @code{mount}.
+
+Environment Variables
+
+* Environment Access:: How to get and set the values of
+ environment variables.
+* Standard Environment:: These environment variables have
+ standard interpretations.
+
+Program Termination
+
+* Normal Termination:: If a program calls @code{exit}, a
+ process terminates normally.
+* Exit Status:: The @code{exit status} provides information
+ about why the process terminated.
+* Cleanups on Exit:: A process can run its own cleanup
+ functions upon normal termination.
+* Aborting a Program:: The @code{abort} function causes
+ abnormal program termination.
+* Termination Internals:: What happens when a process terminates.
+
Processes
* Running a Command:: The easy way to run another program.
* Implementing a Shell:: What a shell must do to implement job control.
* Functions for Job Control:: Functions to control process groups.
+Implementing a Shell
+
+* Data Structures:: Introduction to the sample shell.
+* Initializing the Shell:: What the shell must do to take
+ responsibility for job control.
+* Launching Jobs:: Creating jobs to execute commands.
+* Foreground and Background:: Putting a job in foreground of background.
+* Stopped and Terminated Jobs:: Reporting job status.
+* Continuing Stopped Jobs:: How to continue a stopped job in
+ the foreground or background.
+* Missing Pieces:: Other parts of the shell.
+
+Functions for Job Control
+
+* Identifying the Terminal:: Determining the controlling terminal's name.
+* Process Group Functions:: Functions for manipulating process groups.
+* Terminal Access Functions:: Functions for controlling terminal access.
+
Name Service Switch
* NSS Basics:: What is this NSS good for.
* NSS Module Internals:: How does it work internally.
* Extending NSS:: What to do to add services or databases.
+NSS Configuration File
+
+* Services in the NSS configuration:: Service names in the NSS configuration.
+* Actions in the NSS configuration:: React appropriately to the lookup result.
+* Notes on NSS Configuration File:: Things to take care about while
+ configuring NSS.
+
+NSS Module Internals
+
+* NSS Module Names:: Construction of the interface function of
+ the NSS modules.
+* NSS Modules Interface:: Programming interface in the NSS module
+ functions.
+
+Extending NSS
+
+* Adding another Service to NSS:: What is to do to add a new service.
+* NSS Module Function Internals:: Guidelines for writing new NSS
+ service functions.
+
Users and Groups
* User and Group IDs:: Each user has a unique numeric ID;
inquiry functions.
* Netgroup Database:: Functions for accessing the netgroup database.
+User Accounting Database
+
+* Manipulating the Database:: Scanning and modifying the user
+ accounting database.
+* XPG Functions:: A standardized way for doing the same thing.
+* Logging In and Out:: Functions from BSD that modify the user
+ accounting database.
+
+User Database
+
+* User Data Structure:: What each user record contains.
+* Lookup User:: How to look for a particular user.
+* Scanning All Users:: Scanning the list of all users, one by one.
+* Writing a User Entry:: How a program can rewrite a user's record.
+
+Group Database
+
+* Group Data Structure:: What each group record contains.
+* Lookup Group:: How to look for a particular group.
+* Scanning All Groups:: Scanning the list of all groups.
+
+Netgroup Database
+
+* Netgroup Data:: Data in the Netgroup database and where
+ it comes from.
+* Lookup Netgroup:: How to look for a particular netgroup.
+* Netgroup Membership:: How to test for netgroup membership.
+
System Information
* Host Identification:: Determining the name of the machine.
* String Parameters:: Getting the default search path.
+Sysconf
+
+* Sysconf Definition:: Detailed specifications of @code{sysconf}.
+* Constants for Sysconf:: The list of parameters @code{sysconf} can read.
+* Examples of Sysconf:: How to use @code{sysconf} and the parameter
+ macros properly together.
+
POSIX Threads
* Basic Thread Operations:: Creating, terminating, and waiting for threads.
* Important Data Types:: Data types for object sizes.
* Data Type Measurements:: Parameters of data type representations.
+Variadic Functions
+
+* Why Variadic:: Reasons for making functions take
+ variable arguments.
+* How Variadic:: How to define and call variadic functions.
+* Variadic Example:: A complete example.
+
+How Variadic
+
+* Variadic Prototypes:: How to make a prototype for a function
+ with variable arguments.
+* Receiving Arguments:: Steps you must follow to access the
+ optional argument values.
+* How Many Arguments:: How to decide whether there are more arguments.
+* Calling Variadics:: Things you need to know about calling
+ variable arguments functions.
+* Argument Macros:: Detailed specification of the macros
+ for accessing variable arguments.
+* Old Varargs:: The pre-ISO way of defining variadic functions.
+
+Data Type Measurements
+
+* Width of Type:: How many bits does an integer type hold?
+* Range of Type:: What are the largest and smallest values
+ that an integer type can hold?
+* Floating Type Macros:: Parameters that measure the floating point types.
+* Structure Measurement:: Getting measurements on structure types.
+
+Floating Type Macros
+
+* Floating Point Concepts:: Definitions of terminology.
+* Floating Point Parameters:: Details of specific macros.
+* IEEE Floating Point:: The measurements for one common
+ representation.
+
Installation
* Tools for Installation:: We recommend using these tools to build.
to the GNU C library.
* Porting:: How to port the GNU C library to
a new machine or operating system.
+
+Porting
+
+* Hierarchy Conventions:: The layout of the @file{sysdeps} hierarchy.
+* Porting to Unix:: Porting the library to an average
+ Unix-like system.
@end menu
# The real-time library from POSIX.1b.
.*-.*-.* librt=1
+
+# Preloading modules.
+.*-.*-.* libSegFault=1
#endif
#ifdef USE_IN_LIBIO
-# include <libo/iolibio.h>
+# include <libio/iolibio.h>
# define fflush(s) _IO_fflush (s)
#endif
/* This variable containts the lowest stack address ever used. */
void *__libc_stack_end;
unsigned long int _dl_hwcap_mask = HWCAP_IMPORTANT;
-
+
struct hurd_startup_data *_dl_hurd_data;
memobj_rd = MACH_PORT_NULL;
else
{
+ assert (!(flags & MAP_SHARED));
err = __io_map ((mach_port_t) fd, &memobj_rd, &memobj_wr);
if (err)
return (__ptr_t) __hurd_fail (err);
/* Signal number definitions. Solaris 2 version.
- Copyright (C) 1994, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1994, 1996, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#define SIG_ERR ((__sighandler_t) -1) /* Error return. */
#define SIG_DFL ((__sighandler_t) 0) /* Default action. */
#define SIG_IGN ((__sighandler_t) 1) /* Ignore signal. */
+#ifdef __USE_UNIX98
+# define SIG_HOLD ((__sighandler_t) 2) /* Add signal to hold mask. */
+#endif
/* Signals. */
CFLAGS-scheck.c = -Wno-strict-prototypes -DNOID
# We have to make sure the data for testing the tz functions is available.
+# Don't add leapseconds here since test-tz made checks that work only without
+# leapseconds.
testdata = $(objpfx)testdata
define build-testdata
-$(built-program-cmd) -d $(testdata) -L $(leapseconds) -y ./yearistype $<
+$(built-program-cmd) -d $(testdata) -y ./yearistype $<
endef
$(objpfx)test-tz.out: $(addprefix $(testdata)/, America/New_York Etc/UTC UTC)
projects / external / glibc.git / commitdiff