AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-22 02:40:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

* sysdeps/ia64/fpu/libm_error.c (__libm_error_support): Don't abort.

Browse Source 
2005-08-17  Robert Love  <rml@novell.com>

	* sysdeps/unix/sysv/linux/sys/inotify.h: Add IN_MOVE_SELF event.

2005-08-19  Bruno Haible  <bruno@clisp.org>

	* intl/localealias.c (read_alias_file): In case of failure, close the
	file descriptor and sort the array before returning.

2005-08-19  Ulrich Drepper  <drepper@redhat.com>

	* malloc/Makefile: Link libmemusage.so with ld.so.
	* malloc/memusage.c: Use atomic operations for all counter and size
	 computations.  Handle thread stacks.
	* sysdeps/generic/memusage.h: Define memusage_cntr_t and
	memusage_size_t.
	* sysdeps/i386/i686/memusage.h: New file.
	* include/atomic.h: Define atomic_max and atomic_min.

	* debug/tst-chk1.c: Add tests for mbstowcs and wcstombs.
This commit is contained in:
Ulrich Drepper 2005-08-20 01:22:05 +00:00
parent 2a81f17880
commit d6c7294ed6
9 changed files with 234 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
ChangeLog
View File

@ -1,3 +1,28 @@
2005-08-19 H.J. Lu <hongjiu.lu@intel.com>
* sysdeps/ia64/fpu/libm_error.c (__libm_error_support): Don't abort.
2005-08-17 Robert Love <rml@novell.com>
* sysdeps/unix/sysv/linux/sys/inotify.h: Add IN_MOVE_SELF event.
2005-08-19 Bruno Haible <bruno@clisp.org>
* intl/localealias.c (read_alias_file): In case of failure, close the
file descriptor and sort the array before returning.
2005-08-19 Ulrich Drepper <drepper@redhat.com>
* malloc/Makefile: Link libmemusage.so with ld.so.
* malloc/memusage.c: Use atomic operations for all counter and size
computations. Handle thread stacks.
* sysdeps/generic/memusage.h: Define memusage_cntr_t and
memusage_size_t.
* sysdeps/i386/i686/memusage.h: New file.
* include/atomic.h: Define atomic_max and atomic_min.
* debug/tst-chk1.c: Add tests for mbstowcs and wcstombs.
2005-08-17 Paul Eggert <eggert@cs.ucla.edu>
[BZ #1207]

41
include/atomic.h
View File

@ -1,5 +1,5 @@
/* Internal macros for atomic operations for GNU C Library.
Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
@ -108,7 +108,7 @@
__typeof (*(mem)) __value = (newvalue); \
\
do \
__oldval = (*__memp); \
__oldval = *__memp; \
while (__builtin_expect (atomic_compare_and_exchange_bool_acq (__memp, \
__value, \
__oldval),\
@ -130,7 +130,7 @@
__typeof (*(mem)) __value = (value); \
\
do \
__oldval = (*__memp); \
__oldval = *__memp; \
while (__builtin_expect (atomic_compare_and_exchange_bool_acq (__memp, \
__oldval \
+ __value,\
@ -141,6 +141,41 @@
#endif
#ifndef atomic_max
# define atomic_max(mem, value) \
do { \
__typeof (*(mem)) __oldval; \
__typeof (mem) __memp = (mem); \
__typeof (*(mem)) __value = (value); \
do { \
__oldval = *__memp; \
if (__oldval >= __value) \
break; \
} while (__builtin_expect (atomic_compare_and_exchange_bool_acq (__memp, \
__value, \
__oldval),\
0)); \
} while (0)
#endif
#ifndef atomic_min
# define atomic_min(mem, value) \
do { \
__typeof (*(mem)) __oldval; \
__typeof (mem) __memp = (mem); \
__typeof (*(mem)) __value = (value); \
do { \
__oldval = *__memp; \
if (__oldval <= __value) \
break; \
} while (__builtin_expect (atomic_compare_and_exchange_bool_acq (__memp, \
__value, \
__oldval),\
0)); \
} while (0)
#endif
#ifndef atomic_add
# define atomic_add(mem, value) (void) atomic_exchange_and_add ((mem), (value))
#endif

7
intl/localealias.c
View File

@ -1,5 +1,5 @@
/* Handle aliases for locale names.
Copyright (C) 1995-2002, 2003 Free Software Foundation, Inc.
Copyright (C) 1995-2002, 2003, 2005 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
@ -295,7 +295,7 @@ read_alias_file (fname, fname_len)
if (nmap >= maxmap)
if (__builtin_expect (extend_alias_table (), 0))
return added;
goto out;
alias_len = strlen (alias) + 1;
value_len = strlen (value) + 1;
@ -308,7 +308,7 @@ read_alias_file (fname, fname_len)
? alias_len + value_len : 1024));
char *new_pool = (char *) realloc (string_space, new_size);
if (new_pool == NULL)
return added;
goto out;
if (__builtin_expect (string_space != new_pool, 0))
{
@ -349,6 +349,7 @@ read_alias_file (fname, fname_len)
while (strchr (buf, '\n') == NULL);
}
out:
/* Should we test for ferror()? I think we have to silently ignore
errors. --drepper */
fclose (fp);

2
malloc/Makefile
View File

@ -140,7 +140,7 @@ $(objpfx)memusage: memusage.sh
# The implementation uses `dlsym'
$(objpfx)libmemusage.so: $(common-objpfx)dlfcn/libdl.so
$(objpfx)libmemusage.so: $(common-objpfx)dlfcn/libdl.so $(elfobjdir)/ld.so
# Extra dependencies
$(foreach o,$(all-object-suffixes),$(objpfx)malloc$(o)): arena.c hooks.c

223
malloc/memusage.c
View File

@ -1,5 +1,5 @@
/* Profile heap and stack memory usage of running program.
Copyright (C) 1998-2002, 2004 Free Software Foundation, Inc.
Copyright (C) 1998-2002, 2004, 2005 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
@ -18,6 +18,7 @@
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#include <atomic.h>
#include <dlfcn.h>
#include <errno.h>
#include <fcntl.h>
@ -69,24 +70,22 @@ struct header
#define MAGIC 0xfeedbeaf
static unsigned long int calls[idx_last];
static unsigned long int failed[idx_last];
static unsigned long long int total[idx_last];
static unsigned long long int grand_total;
static unsigned long int histogram[65536 / 16];
static unsigned long int large;
static unsigned long int calls_total;
static unsigned long int inplace;
static unsigned long int decreasing;
static unsigned long int inplace_mremap;
static unsigned long int decreasing_mremap;
static long int current_use[2];
static long int peak_use[3];
static uintptr_t start_sp;
static memusage_cntr_t calls[idx_last];
static memusage_cntr_t failed[idx_last];
static memusage_size_t total[idx_last];
static memusage_size_t grand_total;
static memusage_cntr_t histogram[65536 / 16];
static memusage_cntr_t large;
static memusage_cntr_t calls_total;
static memusage_cntr_t inplace;
static memusage_cntr_t decreasing;
static memusage_cntr_t inplace_mremap;
static memusage_cntr_t decreasing_mremap;
static memusage_size_t current_heap;
static memusage_size_t peak_use[3];
static __thread uintptr_t start_sp;
/* A few macros to make the source more readable. */
#define current_heap current_use[0]
#define current_stack current_use[1]
#define peak_heap peak_use[0]
#define peak_stack peak_use[1]
#define peak_total peak_use[2]
@ -109,8 +108,8 @@ struct entry
uint32_t time_high;
};
static struct entry buffer[DEFAULT_BUFFER_SIZE];
static size_t buffer_cnt;
static struct entry buffer[2 * DEFAULT_BUFFER_SIZE];
static uatomic32_t buffer_cnt;
static struct entry first;
@ -118,8 +117,6 @@ static struct entry first;
static void
update_data (struct header *result, size_t len, size_t old_len)
{
long int total_use;
if (result != NULL)
{
/* Record the information we need and mark the block using a
@ -129,38 +126,60 @@ update_data (struct header *result, size_t len, size_t old_len)
}
/* Compute current heap usage and compare it with the maximum value. */
current_heap += len - old_len;
if (current_heap > peak_heap)
peak_heap = current_heap;
memusage_size_t heap
= atomic_exchange_and_add (&current_heap, len - old_len) + len - old_len;
atomic_max (&peak_heap, heap);
/* Compute current stack usage and compare it with the maximum value. */
/* Compute current stack usage and compare it with the maximum
value. The base stack pointer might not be set if this is not
the main thread and it is the first call to any of these
functions. */
if (__builtin_expect (!start_sp, 0))
start_sp = GETSP ();
uintptr_t sp = GETSP ();
#ifdef STACK_GROWS_UPWARD
current_stack = GETSP () - start_sp;
/* This can happen in threads where we didn't catch the thread's
stack early enough. */
if (__builtin_expect (sp < start_sp, 0))
start_sp = sp;
size_t current_stack = sp - start_sp;
#else
current_stack = start_sp - GETSP ();
/* This can happen in threads where we didn't catch the thread's
stack early enough. */
if (__builtin_expect (sp > start_sp, 0))
start_sp = sp;
size_t current_stack = start_sp - sp;
#endif
if (current_stack > peak_stack)
peak_stack = current_stack;
atomic_max (&peak_stack, current_stack);
/* Add up heap and stack usage and compare it with the maximum value. */
total_use = current_heap + current_stack;
if (total_use > peak_total)
peak_total = total_use;
atomic_max (&peak_total, heap + current_stack);
/* Store the value only if we are writing to a file. */
if (fd != -1)
{
buffer[buffer_cnt].heap = current_heap;
buffer[buffer_cnt].stack = current_stack;
GETTIME (buffer[buffer_cnt].time_low, buffer[buffer_cnt].time_high);
++buffer_cnt;
uatomic32_t idx = atomic_exchange_and_add (&buffer_cnt, 1);
if (idx >= 2 * buffer_size)
{
/* We try to reset the counter to the correct range. If
this fails because of another thread increasing the
counter it does not matter since that thread will take
care of the correction. */
unsigned int reset = idx - 2 * buffer_size;
atomic_compare_and_exchange_val_acq (&buffer_size, reset, idx);
idx = reset;
}
buffer[idx].heap = current_heap;
buffer[idx].stack = current_stack;
GETTIME (buffer[idx].time_low, buffer[idx].time_high);
/* Write out buffer if it is full. */
if (buffer_cnt == buffer_size)
{
write (fd, buffer, buffer_cnt * sizeof (struct entry));
buffer_cnt = 0;
}
if (idx + 1 == buffer_size)
write (fd, buffer, buffer_size * sizeof (struct entry));
else if (idx + 1 == 2 * buffer_size)
write (fd, &buffer[buffer_size], buffer_size * sizeof (struct entry));
}
}
@ -317,24 +336,24 @@ malloc (size_t len)
return (*mallocp) (len);
/* Keep track of number of calls. */
++calls[idx_malloc];
atomic_increment (&calls[idx_malloc]);
/* Keep track of total memory consumption for `malloc'. */
total[idx_malloc] += len;
atomic_add (&total[idx_malloc], len);
/* Keep track of total memory requirement. */
grand_total += len;
atomic_add (&grand_total, len);
/* Remember the size of the request. */
if (len < 65536)
++histogram[len / 16];
atomic_increment (&histogram[len / 16]);
else
++large;
atomic_increment (&large);
/* Total number of calls of any of the functions. */
++calls_total;
atomic_increment (&calls_total);
/* Do the real work. */
result = (struct header *) (*mallocp) (len + sizeof (struct header));
if (result == NULL)
{
++failed[idx_malloc];
atomic_increment (&failed[idx_malloc]);
return NULL;
}
@ -383,36 +402,36 @@ realloc (void *old, size_t len)
}
/* Keep track of number of calls. */
++calls[idx_realloc];
atomic_increment (&calls[idx_realloc]);
if (len > old_len)
{
/* Keep track of total memory consumption for `realloc'. */
total[idx_realloc] += len - old_len;
atomic_add (&total[idx_realloc], len - old_len);
/* Keep track of total memory requirement. */
grand_total += len - old_len;
atomic_add (&grand_total, len - old_len);
}
/* Remember the size of the request. */
if (len < 65536)
++histogram[len / 16];
atomic_increment (&histogram[len / 16]);
else
++large;
atomic_increment (&large);
/* Total number of calls of any of the functions. */
++calls_total;
atomic_increment (&calls_total);
/* Do the real work. */
result = (struct header *) (*reallocp) (real, len + sizeof (struct header));
if (result == NULL)
{
++failed[idx_realloc];
atomic_increment (&failed[idx_realloc]);
return NULL;
}
/* Record whether the reduction/increase happened in place. */
if (real == result)
++inplace;
atomic_increment (&inplace);
/* Was the buffer increased? */
if (old_len > len)
++decreasing;
atomic_increment (&decreasing);
/* Update the allocation data and write out the records if necessary. */
update_data (result, len, old_len);
@ -443,16 +462,16 @@ calloc (size_t n, size_t len)
return (*callocp) (n, len);
/* Keep track of number of calls. */
++calls[idx_calloc];
atomic_increment (&calls[idx_calloc]);
/* Keep track of total memory consumption for `calloc'. */
total[idx_calloc] += size;
atomic_add (&total[idx_calloc], size);
/* Keep track of total memory requirement. */
grand_total += size;
atomic_add (&grand_total, size);
/* Remember the size of the request. */
if (size < 65536)
++histogram[size / 16];
atomic_increment (&histogram[size / 16]);
else
++large;
atomic_increment (&large);
/* Total number of calls of any of the functions. */
++calls_total;
@ -460,7 +479,7 @@ calloc (size_t n, size_t len)
result = (struct header *) (*mallocp) (size + sizeof (struct header));
if (result == NULL)
{
++failed[idx_calloc];
atomic_increment (&failed[idx_calloc]);
return NULL;
}
@ -497,7 +516,7 @@ free (void *ptr)
/* `free (NULL)' has no effect. */
if (ptr == NULL)
{
++calls[idx_free];
atomic_increment (&calls[idx_free]);
return;
}
@ -511,9 +530,9 @@ free (void *ptr)
}
/* Keep track of number of calls. */
++calls[idx_free];
atomic_increment (&calls[idx_free]);
/* Keep track of total memory freed using `free'. */
total[idx_free] += real->length;
atomic_add (&total[idx_free], real->length);
/* Update the allocation data and write out the records if necessary. */
update_data (NULL, 0, real->length);
@ -547,22 +566,22 @@ mmap (void *start, size_t len, int prot, int flags, int fd, off_t offset)
? idx_mmap_a : prot & PROT_WRITE ? idx_mmap_w : idx_mmap_r);
/* Keep track of number of calls. */
++calls[idx];
atomic_increment (&calls[idx]);
/* Keep track of total memory consumption for `malloc'. */
total[idx] += len;
atomic_add (&total[idx], len);
/* Keep track of total memory requirement. */
grand_total += len;
atomic_add (&grand_total, len);
/* Remember the size of the request. */
if (len < 65536)
++histogram[len / 16];
atomic_increment (&histogram[len / 16]);
else
++large;
atomic_increment (&large);
/* Total number of calls of any of the functions. */
++calls_total;
atomic_increment (&calls_total);
/* Check for failures. */
if (result == NULL)
++failed[idx];
atomic_increment (&failed[idx]);
else if (idx == idx_mmap_w)
/* Update the allocation data and write out the records if
necessary. Note the first parameter is NULL which means
@ -599,22 +618,22 @@ mmap64 (void *start, size_t len, int prot, int flags, int fd, off64_t offset)
? idx_mmap_a : prot & PROT_WRITE ? idx_mmap_w : idx_mmap_r);
/* Keep track of number of calls. */
++calls[idx];
atomic_increment (&calls[idx]);
/* Keep track of total memory consumption for `malloc'. */
total[idx] += len;
atomic_add (&total[idx], len);
/* Keep track of total memory requirement. */
grand_total += len;
atomic_add (&grand_total, len);
/* Remember the size of the request. */
if (len < 65536)
++histogram[len / 16];
atomic_increment (&histogram[len / 16]);
else
++large;
atomic_increment (&large);
/* Total number of calls of any of the functions. */
++calls_total;
atomic_increment (&calls_total);
/* Check for failures. */
if (result == NULL)
++failed[idx];
atomic_increment (&failed[idx]);
else if (idx == idx_mmap_w)
/* Update the allocation data and write out the records if
necessary. Note the first parameter is NULL which means
@ -648,33 +667,33 @@ mremap (void *start, size_t old_len, size_t len, int flags)
if (!not_me && trace_mmap)
{
/* Keep track of number of calls. */
++calls[idx_mremap];
atomic_increment (&calls[idx_mremap]);
if (len > old_len)
{
/* Keep track of total memory consumption for `malloc'. */
total[idx_mremap] += len - old_len;
atomic_add (&total[idx_mremap], len - old_len);
/* Keep track of total memory requirement. */
grand_total += len - old_len;
atomic_add (&grand_total, len - old_len);
}
/* Remember the size of the request. */
if (len < 65536)
++histogram[len / 16];
atomic_increment (&histogram[len / 16]);
else
++large;
atomic_increment (&large);
/* Total number of calls of any of the functions. */
++calls_total;
atomic_increment (&calls_total);
/* Check for failures. */
if (result == NULL)
++failed[idx_mremap];
atomic_increment (&failed[idx_mremap]);
else
{
/* Record whether the reduction/increase happened in place. */
if (start == result)
++inplace_mremap;
atomic_increment (&inplace_mremap);
/* Was the buffer increased? */
if (old_len > len)
++decreasing_mremap;
atomic_increment (&decreasing_mremap);
/* Update the allocation data and write out the records if
necessary. Note the first parameter is NULL which means
@ -708,19 +727,19 @@ munmap (void *start, size_t len)
if (!not_me && trace_mmap)
{
/* Keep track of number of calls. */
++calls[idx_munmap];
atomic_increment (&calls[idx_munmap]);
if (__builtin_expect (result == 0, 1))
{
/* Keep track of total memory freed using `free'. */
total[idx_munmap] += len;
atomic_add (&total[idx_munmap], len);
/* Update the allocation data and write out the records if
necessary. */
update_data (NULL, 0, len);
}
else
++failed[idx_munmap];
atomic_increment (&failed[idx_munmap]);
}
return result;
@ -772,16 +791,16 @@ dest (void)
\e[00;34mrealloc|\e[0m %10lu %12llu %s%12lu\e[00;00m (in place: %ld, dec: %ld)\n\
\e[00;34m calloc|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\
\e[00;34m free|\e[0m %10lu %12llu\n",
grand_total, (unsigned long int) peak_heap,
(unsigned long long int) grand_total, (unsigned long int) peak_heap,
(unsigned long int) peak_stack,
calls[idx_malloc], total[idx_malloc],
calls[idx_malloc], (unsigned long long int) total[idx_malloc],
failed[idx_malloc] ? "\e[01;41m" : "", failed[idx_malloc],
calls[idx_realloc], total[idx_realloc],
calls[idx_realloc], (unsigned long long int) total[idx_realloc],
failed[idx_realloc] ? "\e[01;41m" : "", failed[idx_realloc],
inplace, decreasing,
calls[idx_calloc], total[idx_calloc],
calls[idx_calloc], (unsigned long long int) total[idx_calloc],
failed[idx_calloc] ? "\e[01;41m" : "", failed[idx_calloc],
calls[idx_free], total[idx_free]);
calls[idx_free], (unsigned long long int) total[idx_free]);
if (trace_mmap)
fprintf (stderr, "\
@ -790,16 +809,16 @@ dest (void)
\e[00;34mmmap(a)|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\
\e[00;34m mremap|\e[0m %10lu %12llu %s%12lu\e[00;00m (in place: %ld, dec: %ld)\n\
\e[00;34m munmap|\e[0m %10lu %12llu %s%12lu\e[00;00m\n",
calls[idx_mmap_r], total[idx_mmap_r],
calls[idx_mmap_r], (unsigned long long int) total[idx_mmap_r],
failed[idx_mmap_r] ? "\e[01;41m" : "", failed[idx_mmap_r],
calls[idx_mmap_w], total[idx_mmap_w],
calls[idx_mmap_w], (unsigned long long int) total[idx_mmap_w],
failed[idx_mmap_w] ? "\e[01;41m" : "", failed[idx_mmap_w],
calls[idx_mmap_a], total[idx_mmap_a],
calls[idx_mmap_a], (unsigned long long int) total[idx_mmap_a],
failed[idx_mmap_a] ? "\e[01;41m" : "", failed[idx_mmap_a],
calls[idx_mremap], total[idx_mremap],
calls[idx_mremap], (unsigned long long int) total[idx_mremap],
failed[idx_mremap] ? "\e[01;41m" : "", failed[idx_mremap],
inplace_mremap, decreasing_mremap,
calls[idx_munmap], total[idx_munmap],
calls[idx_munmap], (unsigned long long int) total[idx_munmap],
failed[idx_munmap] ? "\e[01;41m" : "", failed[idx_munmap]);
/* Write out a histoogram of the sizes of the allocations. */

18
sysdeps/generic/memusage.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000 Free Software Foundation, Inc.
/* Copyright (C) 2000, 2005 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
@ -17,6 +17,9 @@
02111-1307 USA. */
#include <limits.h>
#include <atomic.h>
#ifndef GETSP
# warning "GETSP is not defined for this architecture."
# define GETSP 0
@ -33,3 +36,16 @@
high = usecs >> 32; \
}
#endif
#if LONG_BIT == 32
# define memusage_cntr_t uatomic32_t
#else
# define memusage_cntr_t uatomic64_t
#endif
#ifndef memusage_size_t
# if LONG_BIT == 32
# define memusage_size_t uatomic32_t
# else
# define memusage_size_t uatomic64_t
# endif
#endif

22
sysdeps/i386/i686/memusage.h Normal file
View File

@ -0,0 +1,22 @@
/* Copyright (C) 2000, 2005 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
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#define GETSP() ({ register uintptr_t stack_ptr asm ("esp"); stack_ptr; })
#define GETTIME(low,high) asm ("rdtsc" : "=a" (low), "=d" (high))
#include <sysdeps/generic/memusage.h>

8
sysdeps/ia64/fpu/libm_error.c
View File

@ -81,8 +81,8 @@
// 12/13/04: Corrected POSIX behavior for exp2_overflow, exp2_underflow,
// exp10_overflow, exp10_underflow. Added ISOC to set errno for
// exp10_underflow.
// 12/14/04: Corrected POSIX behavior for nextafter_overflow,
// nextafter_underflow, nexttoward_overflow, nexttoward_underflow.
// 12/14/04: Corrected POSIX behavior for nextafter_overflow,
// nextafter_underflow, nexttoward_overflow, nexttoward_underflow.
// Added ISOC to set errno for nextafter and nexttoward underflow.
// 12/15/04: Corrected POSIX behavior for exp, exp2, and exp10 underflow.
// 03/31/05: Added missing ALIGNIT statement to 6 float constants.
@ -674,7 +674,7 @@ else if(_LIB_VERSIONIMF==_ISOC_)
ERRNO_DOMAIN; break;
}
default:
abort();
break;
}
return;
}
@ -1374,7 +1374,7 @@ switch(input_tag)
ERRNO_RANGE; break;
}
default:
abort();
break;
}
return;
/* _POSIX_ */

3
sysdeps/unix/sysv/linux/sys/inotify.h
View File

@ -47,6 +47,7 @@ struct inotify_event
#define IN_CREATE 0x00000100 /* Subfile was created. */
#define IN_DELETE 0x00000200 /* Subfile was deleted. */
#define IN_DELETE_SELF 0x00000400 /* Self was deleted. */
#define IN_MOVE_SELF 0x00000800 /* Self was moved. */
/* Events sent by the kernel. */
#define IN_UNMOUNT 0x00002000 /* Backing fs was unmounted. */
@ -61,7 +62,7 @@ struct inotify_event
#define IN_ALL_EVENTS (IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE \
| IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM \
| IN_MOVED_TO | IN_CREATE | IN_DELETE \
| IN_DELETE_SELF)
| IN_DELETE_SELF | IN_MOVE_SELF)
__BEGIN_DECLS