mirror/glibc
2
0
Fork 0
mirror of git://sourceware.org/git/glibc.git synced 2025-04-06 14:10:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

Forward port of rtkaio.

Browse Source
This commit is contained in:
Jakub Jelinek 2006-09-07 10:36:13 +00:00
parent bdae521809
commit 8021fca541
79 changed files with 1819 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
fedora/glibc.spec.in
View File

@ -8,7 +8,7 @@
%define buildxen 0
%define xenpackage 0
%endif
%define rtkaioarches noarch
%define rtkaioarches %{ix86} x86_64 ia64 ppc ppc64 s390 s390x
%define debuginfocommonarches %{ix86} alpha alphaev6 sparc sparcv9
%define _unpackaged_files_terminate_build 0
Summary: The GNU libc libraries.
@ -819,17 +819,12 @@ GXX="g++ -m64"
%endif
BuildFlags="$BuildFlags -DNDEBUG=1"
if gcc -v 2>&1 | grep -q 'gcc version 3.[0123]'; then
BuildFlags="$BuildFlags -finline-limit=2000"
fi
EnableKernel="--enable-kernel=%{enablekernel}"
echo "$BuildFlags" > BuildFlags
echo "$GCC" > Gcc
AddOns=`echo */configure | sed -e 's!/configure!!g;s!\(linuxthreads\|nptl\|rtkaio\)\( \|$\)!!g;s! \+$!!;s! !,!g;s!^!,!;/^,\*$/d'`
%ifarch %{rtkaioarches}
AddOns=,rtkaio$AddOns
%endif
echo "$AddOns" > AddOns
build_nptl()
{
@ -868,9 +863,7 @@ $GCC -static -L. -Os ../fedora/glibc_post_upgrade.c -o glibc_post_upgrade.%{_tar
cd ..
%install
BuildFlags=`cat BuildFlags`
GCC=`cat Gcc`
AddOns=`cat AddOns`
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT
@ -881,6 +874,12 @@ cd build-%{nptl_target_cpu}-linuxnptl && \
cd ..
%endif
%ifarch %{rtkaioarches}
mkdir -p $RPM_BUILD_ROOT/%{_lib}/rtkaio
cp -a rtkaio/librtkaio.so $RPM_BUILD_ROOT/%{_lib}/rtkaio/`basename $RPM_BUILD_ROOT/%{_lib}/librt-*.so | sed s/librt-/librtkaio-/`
ln -sf `basename $RPM_BUILD_ROOT/%{_lib}/librt-*.so | sed s/librt-/librtkaio-/` $RPM_BUILD_ROOT/%{_lib}/rtkaio/`basename $RPM_BUILD_ROOT/%{_lib}/librt.so.*`
%endif
%if %{buildxen}
%define nosegneg_subdir_base i686
%define nosegneg_subdir i686/nosegneg
@ -895,15 +894,15 @@ cp -a nptl/libpthread.so $RPM_BUILD_ROOT/%{_lib}/$SubDir/libpthread-%{version}.s
pushd $RPM_BUILD_ROOT/%{_lib}/$SubDir
ln -sf libpthread-*.so `basename $RPM_BUILD_ROOT/%{_lib}/libpthread.so.*`
popd
%ifarch %{rtkaioarches}
cp -a rtkaio/librtkaio.so $RPM_BUILD_ROOT/%{_lib}/$SubDir/`basename $RPM_BUILD_ROOT/%{_lib}/librt-*.so | sed s/librt-/librtkaio-/`
ln -sf `basename $RPM_BUILD_ROOT/%{_lib}/librt-*.so | sed s/librt-/librtkaio-/` $RPM_BUILD_ROOT/%{_lib}/$SubDir/`basename $RPM_BUILD_ROOT/%{_lib}/librt.so.*`
%else
cp -a rt/librt.so $RPM_BUILD_ROOT/%{_lib}/$SubDir/`basename $RPM_BUILD_ROOT/%{_lib}/librt-*.so`
ln -sf `basename $RPM_BUILD_ROOT/%{_lib}/librt-*.so` $RPM_BUILD_ROOT/%{_lib}/$SubDir/`basename $RPM_BUILD_ROOT/%{_lib}/librt.so.*`
%endif
cp -a nptl_db/libthread_db.so $RPM_BUILD_ROOT/%{_lib}/$SubDir/`basename $RPM_BUILD_ROOT/%{_lib}/libthread_db-*.so`
ln -sf `basename $RPM_BUILD_ROOT/%{_lib}/libthread_db-*.so` $RPM_BUILD_ROOT/%{_lib}/$SubDir/`basename $RPM_BUILD_ROOT/%{_lib}/libthread_db.so.*`
%ifarch %{rtkaioarches}
mkdir -p $RPM_BUILD_ROOT/%{_lib}/rtkaio/$SubDir
cp -a rtkaio/librtkaio.so $RPM_BUILD_ROOT/%{_lib}/rtkaio/$SubDir/`basename $RPM_BUILD_ROOT/%{_lib}/librt-*.so | sed s/librt-/librtkaio-/`
ln -sf `basename $RPM_BUILD_ROOT/%{_lib}/librt-*.so | sed s/librt-/librtkaio-/` $RPM_BUILD_ROOT/%{_lib}/rtkaio/$SubDir/`basename $RPM_BUILD_ROOT/%{_lib}/librt.so.*`
%endif
cd ..
%endif
@ -1362,9 +1361,16 @@ rm -f *.filelist*
%files -f rpm.filelist
%defattr(-,root,root)
%ifarch %{rtkaioarches}
%dir /%{_lib}/rtkaio
%endif
%if %{buildxen} && !%{xenpackage}
%dir /%{_lib}/%{nosegneg_subdir_base}
%dir /%{_lib}/%{nosegneg_subdir}
%ifarch %{rtkaioarches}
%dir /%{_lib}/rtkaio/%{nosegneg_subdir_base}
%dir /%{_lib}/rtkaio/%{nosegneg_subdir}
%endif
%endif
%ifarch s390x
%dir /lib
@ -1451,6 +1457,8 @@ rm -f *.filelist*
* Thu Sep 7 2006 Jakub Jelinek <jakub@redhat.com> 2.4.90-30
- fix or_IN February name (#204730)
- fix pthread_create called from cancellation handlers (BZ#3124)
- add librtkaio, to use it add /%{lib}/rtkaio to your
LD_LIBRARY_PATH or /etc/ld.so.conf
* Tue Sep 5 2006 Jakub Jelinek <jakub@redhat.com> 2.4.90-29
- randomize resolver query ids before use instead after use (#205113)

146
rtkaio/ChangeLog
View File

@ -1,3 +1,149 @@
2006-09-07 Jakub Jelinek <jakub@redhat.com>
* Makefile: Use $(..) in place of ../.
(tests): Add tst-aio{8,9,10}, tst-cpuclock{1,2}, tst-cputimer{1,2,3}
and tst-clock2.
(CPPFLAGS-librtkaio): Append -I$(..)rt.
* Versions.def (librtkaio): Add GLIBC_2.4 version.
* sysdeps/unix/sysv/linux/kaio_misc.c (wait_for_kernel_requests)
[!DONT_NEED_AIO_MISC_COND]: Don't use condvar, use AIO_MISC_WAIT.
* sysdeps/unix/sysv/linux/kaio_misc.h [HAVE_FORCED_UNWIND]
(DONT_NEED_AIO_MISC_COND, AIO_MISC_NOTIFY, AIO_MISC_WAIT): Define.
(struct waitlist) [DONT_NEED_AIO_MISC_COND]: Remove cond.
* sysdeps/unix/sysv/linux/kaio_suspend.c (struct clparam)
[DONT_NEED_AIO_MISC_COND]: Remove cond.
(cleanup) [DONT_NEED_AIO_MISC_COND]: Lock __aio_requests_mutex on
entry. Don't destroy param->cond.
(aio_suspend): Fail if nent is negative.
(aio_suspend) [DONT_NEED_AIO_MISC_COND]: Don't use cond, use
AIO_MISC_WAIT.
* sysdeps/unix/sysv/linux/klio_listio.c (lio_listio): Renamed to...
(lio_listio_internal): ... this. Don't use cond, but AIO_MISC_WAIT,
if DONT_NEED_AIO_MISC_COND. Remove mode parameter check. Only set
sigevent type to SIGEV_NONE if LIO_NO_INDIVIDUAL_EVENT is set.
(__lio_listio_21): New function. Compatiblity version which sets
LIO_NO_INDIVIDUAL_EVENT before calling lio_listio_internal.
(__lio_listio_item_notify): New function.
* sysdeps/unix/sysv/linux/klio_listio64.c: Define __lio_listio_21 and
__lio_listio_item_notify macros.
* aio.h: Removed.
* configure.in: New file
* configure: Regenerated.
* sysdeps/rtkaio/kaio_cancel.c: Moved to...
* kaio_cancel.c: ... here. New file.
* sysdeps/rtkaio/kaio_error.c: Moved to...
* kaio_error.c: ... here. New file.
* sysdeps/rtkaio/kaio_fsync.c: Moved to...
* kaio_fsync.c: ... here. New file.
* sysdeps/rtkaio/kaio_misc.c: Moved to...
* kaio_misc.c: ... here. New file.
* sysdeps/rtkaio/kaio_notify.c: Moved to...
* kaio_notify.c: ... here. New file.
* sysdeps/rtkaio/kaio_read.c: Moved to...
* kaio_read.c: ... here. New file.
* sysdeps/rtkaio/kaio_read64.c: Moved to...
* kaio_read64.c: ... here. New file.
* sysdeps/rtkaio/kaio_return.c: Moved to...
* kaio_return.c: ... here. New file.
* sysdeps/rtkaio/kaio_sigqueue.c: Moved to...
* kaio_sigqueue.c: ... here. New file.
* sysdeps/rtkaio/kaio_suspend.c: Moved to...
* kaio_suspend.c: ... here. New file.
* sysdeps/rtkaio/kaio_write.c: Moved to...
* kaio_write.c: ... here. New file.
* sysdeps/rtkaio/kaio_write64.c: Moved to...
* kaio_write64.c: ... here. New file.
* sysdeps/rtkaio/klio_listio.c: Moved to...
* klio_listio.c: ... here. New file.
* sysdeps/rtkaio/klio_listio64.c: Moved to...
* klio_listio64.c: ... here. New file.
* sysdeps/pthread/Versions: New file.
* tst-aio8.c: New file.
* tst-aio9.c: New file.
* tst-aio10.c: New file.
* tst-clock2.c: New file.
* tst-cpuclock1.c: New file.
* tst-cpuclock2.c: New file.
* tst-cputimer1.c: New file.
* tst-cputimer2.c: New file.
* tst-cputimer3.c: New file.
* sysdeps/unix/sysv/linux/sparc/Makefile: New file.
* sysdeps/unix/sysv/linux/sparc/rtkaio-sysdep.c: New file.
* sysdeps/unix/sysv/linux/sparc/sparc64/Versions: New file.
* sysdeps/mips/Makefile: Removed.
* sysdeps/unix/mips/rtkaio-sysdep.S: Removed.
* sysdeps/unix/sysv/linux/hppa/Versions: Removed.
* sysdeps/unix/sysv/linux/hppa/kaio_cancel.c: Removed.
2006-07-19 Jakub Jelinek <jakub@redhat.com>
* sysdeps/unix/sysv/linux/kaio_misc.c: Include atomic.h.
(kernel_callback): Ensure __return_value is updated before
__error_code is set.
2006-05-11 Jakub Jelinek <jakub@redhat.com>
* Makefile (tests): Add tst-mqueue{8,9}, tst-timer5 and
tst-aiod{,64,2,3,4,5}.
(LDFLAGS-rtkaio.so): Add -Wl,--enable-new-dtags,-z,nodelete.
* sysdeps/unix/sysv/linux/kaio_misc.h: Include signal.h and
sysdep.h.
(aio_start_notify_thread, aio_create_helper_thread): Define
for !BROKEN_THREAD_SIGNALS.
(__aio_start_notify_thread, __aio_create_helper_thread): New
functions for !BROKEN_THREAD_SIGNALS.
* sysdeps/unix/sysv/linux/kaio_misc.c: Include sys/sysmacros.h.
(aio_create_helper_thread): Define if not yet defined.
(__aio_create_helper_thread): New function.
(__aio_wait_for_events): Pass 1 rather than 0 as min_nr to
io_getevents.
(handle_kernel_aio): Likewise.
(__aio_create_kernel_thread): Use aio_create_helper_thread.
(__aio_enqueue_user_request): Likewise.
(handle_fildes_io): Likewise. Remove noreturn attribute,
return NULL instead of calling pthread_exit (NULL).
(__aio_enqueue_request_ctx): Call fcntl and fxstat64 to avoid using
kaio on non-O_DIRECT non-/dev/raw* filedescriptors. For LIO_SYNC
and LIO_DSYNC also set kctx to KCTX_NONE.
* sysdeps/unix/sysv/linux/kaio_suspend.c (aio_suspend): Don't start
handle_kernel_aio thread if ktotal is zero.
* sysdeps/pthread/Makefile (tests): Add tst-mqueue8x.
(CFLAGS-tst-mqueue8x.c): Add -fexceptions.
* Versions.def (librtkaio): Add GLIBC_2.3.4 version.
* kaio_mq_close.c: New file.
* kaio_mq_getattr.c: New file.
* kaio_mq_notify.c: New file.
* kaio_mq_open.c: New file.
* kaio_mq_receive.c: New file.
* kaio_mq_send.c: New file.
* kaio_mq_setattr.c: New file.
* kaio_mq_timedreceive.c: New file.
* kaio_mq_timedsend.c: New file.
* kaio_mq_unlink.c: New file.
* sysdeps/pthread/tst-mqueue8x.c: New file.
* sysdeps/unix/sysv/linux/syscalls.list: New file.
* tst-mqueue8.c: New file.
* tst-mqueue9.c: New file.
* tst-timer5.c: New file.
* tst-aiod.h: New file.
* tst-aiod.c: New test.
* tst-aiod64.c: New test.
* tst-aiod2.c: New test.
* tst-aiod3.c: New test.
* tst-aiod4.c: New test.
* tst-aiod5.c: New test.
* sysdeps/mips/Makefile: New file.
* sysdeps/unix/alpha/Makefile: New file.
* sysdeps/unix/alpha/rtkaio-sysdep.S: New file.
* sysdeps/unix/mips/rtkaio-sysdep.S: New file.
* sysdeps/unix/sysv/linux/Makefile: New file.
* sysdeps/unix/sysv/linux/s390/Makefile: New file.
* sysdeps/unix/sysv/linux/s390/rtkaio-sysdep.S: New file.
* sysdeps/unix/sysv/linux/powerpc/Makefile: New file.
* sysdeps/unix/sysv/linux/powerpc/rtkaio-sysdep.c: New file.
* sysdeps/unix/sysv/linux/ia64/Makefile: New file.
* sysdeps/unix/sysv/linux/ia64/rtkaio-sysdep.S: New file.
2004-04-17 Jakub Jelinek <jakub@redhat.com>
* rt/Makefile (mq-routines): Set.

21
rtkaio/Makefile
View File

@ -1,4 +1,4 @@
# Copyright (C) 2003, 2004 Free Software Foundation, Inc.
# Copyright (C) 2003, 2004, 2006 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
@ -41,13 +41,19 @@ librtkaio-routines = $(patsubst %,k%,$(aio-routines)) \
tests := tst-shm tst-clock tst-clock_nanosleep tst-timer tst-timer2 \
tst-aio tst-aio64 tst-aio2 tst-aio3 tst-aio4 tst-aio5 tst-aio6 \
tst-aio7 tst-mqueue1 tst-mqueue2 tst-mqueue3 tst-mqueue4 \
tst-mqueue5 tst-mqueue6 tst-mqueue7 tst-timer3 tst-timer4
tst-aio7 tst-aio8 tst-aio9 tst-aio10 \
tst-mqueue1 tst-mqueue2 tst-mqueue3 tst-mqueue4 \
tst-mqueue5 tst-mqueue6 tst-mqueue7 tst-mqueue8 tst-mqueue9 \
tst-timer3 tst-timer4 tst-timer5 \
tst-cpuclock1 tst-cpuclock2 \
tst-cputimer1 tst-cputimer2 tst-cputimer3 \
tst-clock2 \
tst-aiod tst-aiod64 tst-aiod2 tst-aiod3 tst-aiod4 tst-aiod5
extra-libs := librtkaio
extra-libs-others := $(extra-libs)
include ../Makeconfig
include $(..)Makeconfig
ifeq (yesyes,$(build-shared)$(elf))
generated += librt.so$(librt.so-version)
@ -55,14 +61,15 @@ generated += librt.so$(librt.so-version)
$(objpfx)librt.so$(librt.so-version): $(objpfx)librtkaio.so; $(make-link)
endif
include ../Rules
include $(..)Rules
CFLAGS-kaio_suspend.c = -fexceptions
CFLAGS-kaio_clock_nanosleep.c = -fexceptions -fasynchronous-unwind-tables
CFLAGS-kaio_librt-cancellation.c = -fasynchronous-unwind-tables
LDFLAGS-rtkaio.so = -Wl,-soname=lib$(libprefix)rt.so$(librt.so-version)
CPPFLAGS-librtkaio += -DIS_IN_librt=1
LDFLAGS-rtkaio.so = -Wl,-soname=lib$(libprefix)rt.so$(librt.so-version) \
-Wl,--enable-new-dtags,-z,nodelete
CPPFLAGS-librtkaio += -DIS_IN_librt=1 -I$(..)rt
rpath-dirs := $(patsubst rt,rtkaio,$(rpath-dirs))

2
rtkaio/Versions.def
View File

@ -3,4 +3,6 @@ librtkaio {
GLIBC_2.2
GLIBC_2.3
GLIBC_2.3.3
GLIBC_2.3.4
GLIBC_2.4
}

1
rtkaio/aio.h
View File

@ -1 +0,0 @@
#include <rt/aio.h>

8
rtkaio/configure vendored
View File

@ -1,4 +1,4 @@
# This is only to keep the GNU C library configure mechanism happy.
#
# Perhaps some day we need a real configuration script for different
# kernel versions or so.
# This file is generated from configure.in by Autoconf. DO NOT EDIT!
libc_add_on_canonical=
libc_add_on_subdirs=.

5
rtkaio/configure.in Normal file
View File

@ -0,0 +1,5 @@
dnl glibc configure fragment for rtkaio add-on
GLIBC_PROVIDES dnl See aclocal.m4 in the top level source directory.
libc_add_on_canonical=
libc_add_on_subdirs=.

0
rtkaio/sysdeps/rtkaio/kaio_cancel.c → rtkaio/kaio_cancel.c
View File

1
rtkaio/kaio_error.c Normal file
View File

@ -0,0 +1 @@
#include <aio_error.c>

0
rtkaio/sysdeps/rtkaio/kaio_fsync.c → rtkaio/kaio_fsync.c
View File

0
rtkaio/sysdeps/rtkaio/kaio_misc.c → rtkaio/kaio_misc.c
View File

1
rtkaio/kaio_mq_close.c Normal file
View File

@ -0,0 +1 @@
#include <mq_close.c>

1
rtkaio/kaio_mq_getattr.c Normal file
View File

@ -0,0 +1 @@
#include <mq_getattr.c>

1
rtkaio/kaio_mq_notify.c Normal file
View File

@ -0,0 +1 @@
#include <mq_notify.c>

1
rtkaio/kaio_mq_open.c Normal file
View File

@ -0,0 +1 @@
#include <mq_open.c>

1
rtkaio/kaio_mq_receive.c Normal file
View File

@ -0,0 +1 @@
#include <mq_receive.c>

1
rtkaio/kaio_mq_send.c Normal file
View File

@ -0,0 +1 @@
#include <mq_send.c>

1
rtkaio/kaio_mq_setattr.c Normal file
View File

@ -0,0 +1 @@
#include <mq_setattr.c>

1
rtkaio/kaio_mq_timedreceive.c Normal file
View File

@ -0,0 +1 @@
#include <mq_timedreceive.c>

1
rtkaio/kaio_mq_timedsend.c Normal file
View File

@ -0,0 +1 @@
#include <mq_timedsend.c>

1
rtkaio/kaio_mq_unlink.c Normal file
View File

@ -0,0 +1 @@
#include <mq_unlink.c>

0
rtkaio/sysdeps/rtkaio/kaio_notify.c → rtkaio/kaio_notify.c
View File

0
rtkaio/sysdeps/rtkaio/kaio_read.c → rtkaio/kaio_read.c
View File

0
rtkaio/sysdeps/rtkaio/kaio_read64.c → rtkaio/kaio_read64.c
View File

1
rtkaio/kaio_return.c Normal file
View File

@ -0,0 +1 @@
#include <aio_return.c>

0
rtkaio/sysdeps/rtkaio/kaio_sigqueue.c → rtkaio/kaio_sigqueue.c
View File

0
rtkaio/sysdeps/rtkaio/kaio_suspend.c → rtkaio/kaio_suspend.c
View File

0
rtkaio/sysdeps/rtkaio/kaio_write.c → rtkaio/kaio_write.c
View File

0
rtkaio/sysdeps/rtkaio/kaio_write64.c → rtkaio/kaio_write64.c
View File

0
rtkaio/sysdeps/rtkaio/klio_listio.c → rtkaio/klio_listio.c
View File

0
rtkaio/sysdeps/rtkaio/klio_listio64.c → rtkaio/klio_listio64.c
View File

5
rtkaio/sysdeps/pthread/Makefile
View File

@ -14,6 +14,11 @@ $(objpfx)tst-timer: $(objpfx)librtkaio.so $(shared-thread-library)
else
$(objpfx)tst-timer: $(objpfx)librtkaio.a $(static-thread-library)
endif
ifeq ($(have-forced-unwind),yes)
tests += tst-mqueue8x
CFLAGS-tst-mqueue8x.c += -fexceptions
endif
endif
endif

7
rtkaio/sysdeps/pthread/Versions Normal file
View File

@ -0,0 +1,7 @@
%ifdef HAVE_FORCED_UNWIND
librtkaio {
GLIBC_2.4 {
lio_listio; lio_listio64;
}
}
%endif

1
rtkaio/sysdeps/pthread/tst-mqueue8x.c Normal file
View File

@ -0,0 +1 @@
#include_next <tst-mqueue8x.c>

1
rtkaio/sysdeps/rtkaio/kaio_error.c
View File

@ -1 +0,0 @@
#include <rt/aio_error.c>

1
rtkaio/sysdeps/rtkaio/kaio_return.c
View File

@ -1 +0,0 @@
#include <rt/aio_return.c>

3
rtkaio/sysdeps/unix/alpha/Makefile Normal file
View File

@ -0,0 +1,3 @@
ifeq ($(subdir),rtkaio)
librtkaio-sysdep_routines += rtkaio-sysdep
endif

1
rtkaio/sysdeps/unix/alpha/rtkaio-sysdep.S Normal file
View File

@ -0,0 +1 @@
#include <rt-sysdep.S>

4
rtkaio/sysdeps/unix/sysv/linux/Makefile Normal file
View File

@ -0,0 +1,4 @@
ifeq ($(subdir),rtkaio)
CFLAGS-kaio_mq_send.c += -fexceptions
CFLAGS-kaio_mq_receive.c += -fexceptions
endif

6
rtkaio/sysdeps/unix/sysv/linux/hppa/Versions
View File

@ -1,6 +0,0 @@
librtkaio {
GLIBC_2.3 {
# AIO functions.
aio_cancel; aio_cancel64;
}
}

33
rtkaio/sysdeps/unix/sysv/linux/hppa/kaio_cancel.c
View File

@ -1,33 +0,0 @@
#include <shlib-compat.h>
#define aio_cancel64 XXX
#include <aio.h>
#undef aio_cancel64
#include <errno.h>
extern __typeof (aio_cancel) __new_aio_cancel;
extern __typeof (aio_cancel) __old_aio_cancel;
#define aio_cancel __new_aio_cancel
#include <sysdeps/unix/sysv/linux/kaio_cancel.c>
#undef aio_cancel
strong_alias (__new_aio_cancel, __new_aio_cancel64);
versioned_symbol (librt, __new_aio_cancel, aio_cancel, GLIBC_2_3);
versioned_symbol (librt, __new_aio_cancel64, aio_cancel64, GLIBC_2_3);
#if SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_3)
#undef ECANCELED
#define aio_cancel __old_aio_cancel
#define ECANCELED 125
#include <sysdeps/unix/sysv/linux/kaio_cancel.c>
#undef aio_cancel
strong_alias (__old_aio_cancel, __old_aio_cancel64);
compat_symbol (librt, __old_aio_cancel, aio_cancel, GLIBC_2_1);
compat_symbol (librt, __old_aio_cancel64, aio_cancel64, GLIBC_2_1);
#endif

3
rtkaio/sysdeps/unix/sysv/linux/ia64/Makefile Normal file
View File

@ -0,0 +1,3 @@
ifeq ($(subdir),rtkaio)
librtkaio-routines += rtkaio-sysdep
endif

1
rtkaio/sysdeps/unix/sysv/linux/ia64/rtkaio-sysdep.S Normal file
View File

@ -0,0 +1 @@
#include <rt-sysdep.S>

2
rtkaio/sysdeps/unix/sysv/linux/kaio_cancel.c
View File

@ -1,5 +1,5 @@
/* Cancel requests associated with given file descriptor.
Copyright (C) 1997, 1998, 2000, 2002, 2003 Free Software Foundation, Inc.
Copyright (C) 1997, 1998, 2000, 2002, 2003, 2005 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.

2
rtkaio/sysdeps/unix/sysv/linux/kaio_error.c
View File

@ -31,7 +31,7 @@
#include <kaio_misc.h>
#ifndef USE_KAIO
#include <rt/aio_error.c>
#include <aio_error.c>
#else
#include <errno.h>

90
rtkaio/sysdeps/unix/sysv/linux/kaio_misc.c
View File

@ -1,5 +1,5 @@
/* Handle general operations.
Copyright (C) 1997,1998,1999,2000,2001,2002,2003
Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2006
Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
@ -27,6 +27,7 @@
#include <aio.h>
#include <assert.h>
#include <atomic.h>
#include <errno.h>
#include <limits.h>
#include <pthread.h>
@ -34,6 +35,28 @@
#include <unistd.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/sysmacros.h>
#ifndef aio_create_helper_thread
# define aio_create_helper_thread __aio_create_helper_thread
extern inline int
__aio_create_helper_thread (pthread_t *threadp, void *(*tf) (void *), void *arg)
{
pthread_attr_t attr;
/* Make sure the thread is created detached. */
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
int ret = pthread_create (threadp, &attr, tf, arg);
(void) pthread_attr_destroy (&attr);
return ret;
}
#endif
static void add_request_to_runlist (struct requestlist *newrequest)
internal_function;
@ -359,14 +382,16 @@ static void
kernel_callback (kctx_t ctx, struct kiocb *kiocb, long res, long res2)
{
struct requestlist *req = (struct requestlist *)kiocb;
long errcode = 0;
req->aiocbp->aiocb.__error_code = 0;
req->aiocbp->aiocb.__return_value = res;
if (res < 0 && res > -1000)
{
req->aiocbp->aiocb.__error_code = -res;
req->aiocbp->aiocb.__return_value = -1;
errcode = -res;
res = -1;
}
req->aiocbp->aiocb.__return_value = res;
atomic_write_barrier ();
req->aiocbp->aiocb.__error_code = errcode;
__aio_notify (req);
assert (req->running == allocated);
req->running = done;
@ -421,7 +446,7 @@ __aio_wait_for_events (kctx_t kctx, const struct timespec *timespec)
ts.tv_nsec = 0;
do
{
ret = INTERNAL_SYSCALL (io_getevents, err, 5, kctx, 0, 10, ev,
ret = INTERNAL_SYSCALL (io_getevents, err, 5, kctx, 1, 10, ev,
timespec);
if (INTERNAL_SYSCALL_ERROR_P (ret, err) || ret == 0)
break;
@ -453,16 +478,11 @@ internal_function
__aio_create_kernel_thread (void)
{
pthread_t thid;
pthread_attr_t attr;
if (__kernel_thread_started)
return 0;
/* Make sure the thread is created detached. */
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
if (pthread_create (&thid, &attr, handle_kernel_aio, NULL) != 0)
if (aio_create_helper_thread (&thid, handle_kernel_aio, NULL) != 0)
return -1;
__kernel_thread_started = 1;
return 0;
@ -477,7 +497,7 @@ handle_kernel_aio (void *arg __attribute__((unused)))
for (;;)
{
ret = INTERNAL_SYSCALL (io_getevents, err, 5, __aio_kioctx, 0, 10, ev,
ret = INTERNAL_SYSCALL (io_getevents, err, 5, __aio_kioctx, 1, 10, ev,
NULL);
if (INTERNAL_SYSCALL_ERROR_P (ret, err) || ret == 0)
continue;
@ -593,16 +613,11 @@ __aio_enqueue_user_request (struct requestlist *newp)
if (nthreads < optim.aio_threads && idle_thread_count == 0)
{
pthread_t thid;
pthread_attr_t attr;
/* Make sure the thread is created detached. */
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
running = newp->running = allocated;
/* Now try to start a thread. */
if (pthread_create (&thid, &attr, handle_fildes_io, newp) == 0)
if (aio_create_helper_thread (&thid, handle_fildes_io, newp) == 0)
/* We managed to enqueue the request. All errors which can
happen now can be recognized by calls to `aio_return' and
`aio_error'. */
@ -653,6 +668,7 @@ __aio_enqueue_request_ctx (aiocb_union *aiocbp, int operation, kctx_t kctx)
aiocbp->aiocb.aio_reqprio = 0;
/* FIXME: Kernel doesn't support sync yet. */
operation &= ~LIO_KTHREAD;
kctx = KCTX_NONE;
}
else if (aiocbp->aiocb.aio_reqprio < 0
|| aiocbp->aiocb.aio_reqprio > AIO_PRIO_DELTA_MAX)
@ -664,6 +680,23 @@ __aio_enqueue_request_ctx (aiocb_union *aiocbp, int operation, kctx_t kctx)
return NULL;
}
if ((operation & LIO_KTHREAD) || kctx != KCTX_NONE)
{
/* io_* is only really asynchronous for O_DIRECT or /dev/raw*. */
int fl = __fcntl (aiocbp->aiocb.aio_fildes, F_GETFL);
if (fl < 0 || (fl & O_DIRECT) == 0)
{
struct stat64 st;
if (__fxstat64 (_STAT_VER, aiocbp->aiocb.aio_fildes, &st) < 0
|| ! S_ISCHR (st.st_mode)
|| major (st.st_rdev) != 162)
{
operation &= ~LIO_KTHREAD;
kctx = KCTX_NONE;
}
}
}
/* Compute priority for this request. */
pthread_getschedparam (pthread_self (), &policy, &param);
prio = param.sched_priority - aiocbp->aiocb.aio_reqprio;
@ -799,7 +832,9 @@ wait_for_kernel_requests (int fildes)
return -1;
}
#ifndef DONT_NEED_AIO_MISC_COND
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
#endif
struct waitlist waitlist[nent];
int cnt = 0;
@ -807,7 +842,10 @@ wait_for_kernel_requests (int fildes)
{
if (kreq->running == allocated)
{
#ifndef DONT_NEED_AIO_MISC_COND
waitlist[cnt].cond = &cond;
#endif
waitlist[cnt].result = NULL;
waitlist[cnt].next = kreq->waiting;
waitlist[cnt].counterp = &nent;
waitlist[cnt].sigevp = NULL;
@ -819,11 +857,15 @@ wait_for_kernel_requests (int fildes)
kreq = kreq->next_prio;
}
#ifdef DONT_NEED_AIO_MISC_COND
AIO_MISC_WAIT (ret, nent, NULL, 0);
#else
do
pthread_cond_wait (&cond, &__aio_requests_mutex);
while (nent);
pthread_cond_destroy (&cond);
#endif
}
pthread_mutex_unlock (&__aio_requests_mutex);
@ -832,7 +874,6 @@ wait_for_kernel_requests (int fildes)
static void *
__attribute__ ((noreturn))
handle_fildes_io (void *arg)
{
pthread_t self = pthread_self ();
@ -1026,16 +1067,11 @@ handle_fildes_io (void *arg)
else if (nthreads < optim.aio_threads)
{
pthread_t thid;
pthread_attr_t attr;
/* Make sure the thread is created detached. */
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
/* Now try to start a thread. If we fail, no big deal,
because we know that there is at least one thread (us)
that is working on AIO operations. */
if (pthread_create (&thid, &attr, handle_fildes_io, NULL)
if (aio_create_helper_thread (&thid, handle_fildes_io, NULL)
== 0)
++nthreads;
}
@ -1047,7 +1083,7 @@ handle_fildes_io (void *arg)
}
while (runp != NULL);
pthread_exit (NULL);
return NULL;
}

114
rtkaio/sysdeps/unix/sysv/linux/kaio_misc.h
View File

@ -1,4 +1,5 @@
/* Copyright (C) 1997,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
/* Copyright (C) 1997,1999,2000,2001,2002,2003,2006
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
@ -34,6 +35,68 @@
#include <aio.h>
#include <pthread.h>
#include <stdint.h>
#include <signal.h>
#include <sysdep.h>
#include <limits.h>
#ifdef HAVE_FORCED_UNWIND
/* We define a special synchronization primitive for AIO. POSIX
conditional variables would be ideal but the pthread_cond_*wait
operations do not return on EINTR. This is a requirement for
correct aio_suspend and lio_listio implementations. */
#include <assert.h>
#include <pthreadP.h>
#include <lowlevellock.h>
# define DONT_NEED_AIO_MISC_COND 1
# define AIO_MISC_NOTIFY(waitlist) \
do { \
if (*waitlist->counterp > 0 && --*waitlist->counterp == 0) \
lll_futex_wake (waitlist->counterp, 1); \
} while (0)
# define AIO_MISC_WAIT(result, futex, timeout, cancel) \
do { \
volatile int *futexaddr = &futex; \
int oldval = futex; \
\
if (oldval != 0) \
{ \
pthread_mutex_unlock (&__aio_requests_mutex); \
\
int oldtype; \
if (cancel) \
oldtype = LIBC_CANCEL_ASYNC (); \
\
int status; \
do \
{ \
status = lll_futex_timed_wait (futexaddr, oldval, timeout); \
if (status != -EWOULDBLOCK) \
break; \
\
oldval = *futexaddr; \
} \
while (oldval != 0); \
\
if (cancel) \
LIBC_CANCEL_RESET (oldtype); \
\
if (status == -EINTR) \
result = EINTR; \
else if (status == -ETIMEDOUT) \
result = EAGAIN; \
else \
assert (status == 0 || status == -EWOULDBLOCK); \
\
pthread_mutex_lock (&__aio_requests_mutex); \
} \
} while (0)
#endif
typedef unsigned long kctx_t;
#define KCTX_NONE ~0UL
@ -95,7 +158,12 @@ struct waitlist
{
struct waitlist *next;
/* The next two fields is used in synchronous io_listio' operations. */
#ifndef DONT_NEED_AIO_MISC_COND
pthread_cond_t *cond;
#endif
int *result;
volatile int *counterp;
/* The next field is used in asynchronous `lio_listio' operations. */
struct sigevent *sigevp;
@ -212,5 +280,49 @@ extern int __aio_create_kernel_thread (void)
extern int __have_no_kernel_aio attribute_hidden;
extern int __kernel_thread_started attribute_hidden;
#ifndef BROKEN_THREAD_SIGNALS
# define aio_start_notify_thread __aio_start_notify_thread
# define aio_create_helper_thread __aio_create_helper_thread
extern inline void
__aio_start_notify_thread (void)
{
sigset_t ss;
sigemptyset (&ss);
INTERNAL_SYSCALL_DECL (err);
INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_SETMASK, &ss, NULL, _NSIG / 8);
}
extern inline int
__aio_create_helper_thread (pthread_t *threadp, void *(*tf) (void *), void *arg)
{
pthread_attr_t attr;
/* Make sure the thread is created detached. */
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
/* The helper thread needs only very little resources. */
(void) pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN);
/* Block all signals in the helper thread. To do this thoroughly we
temporarily have to block all signals here. */
sigset_t ss;
sigset_t oss;
sigfillset (&ss);
INTERNAL_SYSCALL_DECL (err);
INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_SETMASK, &ss, &oss, _NSIG / 8);
int ret = pthread_create (threadp, &attr, tf, arg);
/* Restore the signal mask. */
INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_SETMASK, &oss, NULL,
_NSIG / 8);
(void) pthread_attr_destroy (&attr);
return ret;
}
#endif
#endif
#endif /* aio_misc.h */

2
rtkaio/sysdeps/unix/sysv/linux/kaio_return.c
View File

@ -32,7 +32,7 @@
#include <kaio_misc.h>
#ifndef USE_KAIO
#include <rt/aio_return.c>
#include <aio_return.c>
#else
#include <errno.h>

50
rtkaio/sysdeps/unix/sysv/linux/kaio_suspend.c
View File

@ -1,5 +1,6 @@
/* Suspend until termination of a requests.
Copyright (C) 1997,1998,1999,2000,2002,2003 Free Software Foundation, Inc.
Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2006
Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
@ -37,8 +38,10 @@
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
#include <stdlib.h>
#include <sys/time.h>
#include <bits/libc-lock.h>
#include <sysdep-cancel.h>
@ -48,7 +51,9 @@ struct clparam
const struct aiocb *const *list;
struct waitlist *waitlist;
struct requestlist **requestlist;
#ifndef DONT_NEED_AIO_MISC_COND
pthread_cond_t *cond;
#endif
int nent;
};
@ -56,6 +61,12 @@ struct clparam
static void
cleanup (void *arg)
{
#ifdef DONT_NEED_AIO_MISC_COND
/* Acquire the mutex. If pthread_cond_*wait is used this would
happen implicitly. */
pthread_mutex_lock (&__aio_requests_mutex);
#endif
const struct clparam *param = (const struct clparam *) arg;
/* Now remove the entry in the waiting list for all requests
@ -79,8 +90,10 @@ cleanup (void *arg)
*listp = (*listp)->next;
}
#ifndef DONT_NEED_AIO_MISC_COND
/* Release the conditional variable. */
(void) pthread_cond_destroy (param->cond);
#endif
/* Release the mutex. */
pthread_mutex_unlock (&__aio_requests_mutex);
@ -93,11 +106,20 @@ aio_suspend (list, nent, timeout)
int nent;
const struct timespec *timeout;
{
if (__builtin_expect (nent < 0, 0))
{
__set_errno (EINVAL);
return -1;
}
struct waitlist waitlist[nent];
struct requestlist *requestlist[nent];
#ifndef DONT_NEED_AIO_MISC_COND
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
#endif
int cnt;
int result = 0;
int cntr = 1;
int total = 0, ktotal = 0;
/* Request the mutex. */
@ -114,9 +136,12 @@ aio_suspend (list, nent, timeout)
if (requestlist[cnt] != NULL)
{
#ifndef DONT_NEED_AIO_MISC_COND
waitlist[cnt].cond = &cond;
#endif
waitlist[cnt].result = NULL;
waitlist[cnt].next = requestlist[cnt]->waiting;
waitlist[cnt].counterp = &total;
waitlist[cnt].counterp = &cntr;
waitlist[cnt].sigevp = NULL;
#ifdef BROKEN_THREAD_SIGNALS
waitlist[cnt].caller_pid = 0; /* Not needed. */
@ -144,13 +169,15 @@ aio_suspend (list, nent, timeout)
.list = list,
.waitlist = waitlist,
.requestlist = requestlist,
#ifndef DONT_NEED_AIO_MISC_COND
.cond = &cond,
#endif
.nent = nent
};
pthread_cleanup_push (cleanup, &clparam);
if (!__kernel_thread_started)
if (!__kernel_thread_started && ktotal)
{
/* If the kernel aio thread was not started yet all requests
are served by the kernel and there are no other threads running,
@ -160,7 +187,7 @@ aio_suspend (list, nent, timeout)
{
if (timeout == NULL)
{
while (total == ktotal)
while (cntr == 1)
__aio_wait_for_events (__aio_kioctx, NULL);
}
else
@ -180,7 +207,7 @@ aio_suspend (list, nent, timeout)
for (;;)
{
result = __aio_wait_for_events (__aio_kioctx, timeout);
if (total < ktotal)
if (cntr < 1)
break;
if (result == ETIMEDOUT)
break;
@ -201,7 +228,7 @@ aio_suspend (list, nent, timeout)
timeout = &ts;
}
if (total < ktotal)
if (cntr < 1)
result = 0;
else
result = ETIMEDOUT;
@ -219,6 +246,10 @@ aio_suspend (list, nent, timeout)
if (total == 0)
/* Suspending was handled above. */
;
#ifdef DONT_NEED_AIO_MISC_COND
else
AIO_MISC_WAIT (result, cntr, timeout, 1);
#else
else if (timeout == NULL)
result = pthread_cond_wait (&cond, &__aio_requests_mutex);
else
@ -240,6 +271,7 @@ aio_suspend (list, nent, timeout)
result = pthread_cond_timedwait (&cond, &__aio_requests_mutex,
&abstime);
}
#endif
pthread_cleanup_pop (0);
}
@ -263,19 +295,23 @@ aio_suspend (list, nent, timeout)
*listp = (*listp)->next;
}
#ifndef DONT_NEED_AIO_MISC_COND
/* Release the conditional variable. */
if (__builtin_expect (pthread_cond_destroy (&cond) != 0, 0))
/* This must never happen. */
abort ();
#endif
if (result != 0)
{
/* An error occurred. Possibly it's EINTR. We have to translate
#ifndef DONT_NEED_AIO_MISC_COND
/* An error occurred. Possibly it's ETIMEDOUT. We have to translate
the timeout error report of `pthread_cond_timedwait' to the
form expected from `aio_suspend'. */
if (result == ETIMEDOUT)
__set_errno (EAGAIN);
else
#endif
__set_errno (result);
result = -1;

125
rtkaio/sysdeps/unix/sysv/linux/klio_listio.c
View File

@ -1,5 +1,5 @@
/* Enqueue and list of read or write requests.
Copyright (C) 1997,1998,1999,2000,2001,2002,2003
Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2005,2006
Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
@ -25,16 +25,19 @@
#include <lio_listio.c>
#else
#ifndef lio_listio
#include <aio.h>
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#ifndef lio_listio
#define LIO_OPCODE_BASE 0
#endif
#include <shlib-compat.h>
/* We need this special structure to handle asynchronous I/O. */
struct async_waitlist
{
@ -43,12 +46,23 @@ struct async_waitlist
struct waitlist list[0];
};
int
lio_listio (mode, list, nent, sig)
int mode;
struct aiocb *const list[];
int nent;
struct sigevent *sig;
/* The code in glibc 2.1 to glibc 2.4 issued only one event when all
requests submitted with lio_listio finished. The existing practice
is to issue events for the individual requests as well. This is
what the new code does. */
#if SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_4)
# define LIO_MODE(mode) ((mode) & 127)
# define NO_INDIVIDUAL_EVENT_P(mode) ((mode) & 128)
#else
# define LIO_MODE(mode) mode
# define NO_INDIVIDUAL_EVENT_P(mode) 0
#endif
static int
lio_listio_internal (int mode, struct aiocb *const list[], int nent,
struct sigevent *sig)
{
struct sigevent defsigev;
struct requestlist *requests[nent];
@ -57,13 +71,6 @@ lio_listio (mode, list, nent, sig)
int result = 0, op = 0;
kctx_t kctx = KCTX_NONE;
/* Check arguments. */
if (mode != LIO_WAIT && mode != LIO_NOWAIT)
{
__set_errno (EINVAL);
return -1;
}
if (sig == NULL)
{
defsigev.sigev_notify = SIGEV_NONE;
@ -73,7 +80,7 @@ lio_listio (mode, list, nent, sig)
/* Request the mutex. */
pthread_mutex_lock (&__aio_requests_mutex);
if (mode == LIO_WAIT && ! __have_no_kernel_aio && nent > 0)
if (LIO_MODE (mode) == LIO_WAIT && ! __have_no_kernel_aio && nent > 0)
{
int res;
INTERNAL_SYSCALL_DECL (err);
@ -90,7 +97,7 @@ lio_listio (mode, list, nent, sig)
__have_no_kernel_aio = 1;
}
}
else if (mode == LIO_NOWAIT)
else if (LIO_MODE (mode) == LIO_NOWAIT)
{
op = LIO_KTHREAD;
if (sig->sigev_notify != SIGEV_NONE)
@ -103,7 +110,8 @@ lio_listio (mode, list, nent, sig)
for (cnt = 0; cnt < nent; ++cnt)
if (list[cnt] != NULL && list[cnt]->aio_lio_opcode != LIO_NOP)
{
list[cnt]->aio_sigevent.sigev_notify = SIGEV_NONE;
if (NO_INDIVIDUAL_EVENT_P (mode))
list[cnt]->aio_sigevent.sigev_notify = SIGEV_NONE;
requests[cnt]
= __aio_enqueue_request_ctx ((aiocb_union *) list[cnt],
list[cnt]->aio_lio_opcode | op,
@ -136,7 +144,7 @@ lio_listio (mode, list, nent, sig)
locked forever. */
pthread_mutex_unlock (&__aio_requests_mutex);
if (mode == LIO_NOWAIT)
if (LIO_MODE (mode) == LIO_NOWAIT)
{
#ifdef BROKEN_THREAD_SIGNALS
__aio_notify_only (sig,
@ -148,11 +156,13 @@ lio_listio (mode, list, nent, sig)
return result;
}
else if (mode == LIO_WAIT)
else if (LIO_MODE (mode) == LIO_WAIT)
{
#ifndef DONT_NEED_AIO_MISC_COND
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct waitlist waitlist[nent];
int oldstate;
#endif
struct waitlist waitlist[nent];
volatile int ktotal = 0;
total = 0;
@ -173,7 +183,10 @@ lio_listio (mode, list, nent, sig)
waitlist[cnt].counterp = &total;
++total;
}
#ifndef DONT_NEED_AIO_MISC_COND
waitlist[cnt].cond = &cond;
#endif
waitlist[cnt].result = &result;
waitlist[cnt].next = requests[cnt]->waiting;
waitlist[cnt].sigevp = NULL;
#ifdef BROKEN_THREAD_SIGNALS
@ -183,29 +196,40 @@ lio_listio (mode, list, nent, sig)
}
}
/* Since `pthread_cond_wait'/`pthread_cond_timedwait' are cancelation
points we must be careful. We added entries to the waiting lists
which we must remove. So defer cancelation for now. */
pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate);
while (ktotal > 0)
__aio_wait_for_events (kctx, NULL);
#ifdef DONT_NEED_AIO_MISC_COND
AIO_MISC_WAIT (result, total, NULL, 0);
#else
/* Since `pthread_cond_wait'/`pthread_cond_timedwait' are cancellation
points we must be careful. We added entries to the waiting lists
which we must remove. So defer cancellation for now. */
pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate);
while (total > 0)
pthread_cond_wait (&cond, &__aio_requests_mutex);
/* Now it's time to restore the cancelation state. */
/* Now it's time to restore the cancellation state. */
pthread_setcancelstate (oldstate, NULL);
/* Release the conditional variable. */
if (pthread_cond_destroy (&cond) != 0)
/* This must never happen. */
abort ();
#endif
if (kctx != KCTX_NONE)
{
INTERNAL_SYSCALL_DECL (err);
INTERNAL_SYSCALL (io_destroy, err, 1, kctx);
}
/* Release the conditional variable. */
if (pthread_cond_destroy (&cond) != 0)
/* This must never happen. */
abort ();
/* If any of the I/O requests failed, return -1 and set errno. */
if (result != 0)
{
__set_errno (result == EINTR ? EINTR : EIO);
result = -1;
}
}
else if (sig->sigev_notify != SIGEV_NONE)
{
@ -234,7 +258,10 @@ lio_listio (mode, list, nent, sig)
if (requests[cnt] != NULL
&& list[cnt]->aio_lio_opcode != LIO_NOP)
{
#ifndef DONT_NEED_AIO_MISC_COND
waitlist->list[cnt].cond = NULL;
#endif
waitlist->list[cnt].result = NULL;
waitlist->list[cnt].next = requests[cnt]->waiting;
waitlist->list[cnt].counterp = &waitlist->counter;
waitlist->list[cnt].sigevp = &waitlist->sigev;
@ -256,4 +283,40 @@ lio_listio (mode, list, nent, sig)
return result;
}
#if SHLIB_COMPAT (librt, GLIBC_2_1, GLIBC_2_4)
int
attribute_compat_text_section
__lio_listio_21 (int mode, struct aiocb *const list[], int nent,
struct sigevent *sig)
{
/* Check arguments. */
if (mode != LIO_WAIT && mode != LIO_NOWAIT)
{
__set_errno (EINVAL);
return -1;
}
return lio_listio_internal (mode | LIO_NO_INDIVIDUAL_EVENT, list, nent, sig);
}
compat_symbol (librt, __lio_listio_21, lio_listio, GLIBC_2_1);
#endif
int
__lio_listio_item_notify (int mode, struct aiocb *const list[], int nent,
struct sigevent *sig)
{
/* Check arguments. */
if (mode != LIO_WAIT && mode != LIO_NOWAIT)
{
__set_errno (EINVAL);
return -1;
}
return lio_listio_internal (mode, list, nent, sig);
}
versioned_symbol (librt, __lio_listio_item_notify, lio_listio, GLIBC_2_4);
#endif

4
rtkaio/sysdeps/unix/sysv/linux/klio_listio64.c
View File

@ -1,5 +1,5 @@
/* Enqueue and list of read or write requests, 64bit offset version.
Copyright (C) 1997, 1998, 1999, 2003 Free Software Foundation, Inc.
Copyright (C) 1997, 1998, 1999, 2003, 2006 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
@ -31,6 +31,8 @@
#include <unistd.h>
#define lio_listio lio_listio64
#define __lio_listio_21 __lio_listio64_21
#define __lio_listio_item_notify __lio_listio64_item_notify
#define aiocb aiocb64
#define LIO_OPCODE_BASE 128
#include <klio_listio.c>

3
rtkaio/sysdeps/unix/sysv/linux/powerpc/Makefile Normal file
View File

@ -0,0 +1,3 @@
ifeq ($(subdir),rtkaio)
librtkaio-routines += rtkaio-sysdep
endif

1
rtkaio/sysdeps/unix/sysv/linux/powerpc/rtkaio-sysdep.c Normal file
View File

@ -0,0 +1 @@
#include <rt-sysdep.c>

3
rtkaio/sysdeps/unix/sysv/linux/s390/Makefile Normal file
View File

@ -0,0 +1,3 @@
ifeq ($(subdir),rtkaio)
librtkaio-routines += rtkaio-sysdep
endif

1
rtkaio/sysdeps/unix/sysv/linux/s390/rtkaio-sysdep.S Normal file
View File

@ -0,0 +1 @@
#include <rt-sysdep.S>

3
rtkaio/sysdeps/unix/sysv/linux/sparc/Makefile Normal file
View File

@ -0,0 +1,3 @@
ifeq ($(subdir),rtkaio)
librtkaio-routines += rtkaio-sysdep
endif

1
rtkaio/sysdeps/unix/sysv/linux/sparc/rtkaio-sysdep.c Normal file
View File

@ -0,0 +1 @@
#include <rt-sysdep.c>

9
rtkaio/sysdeps/unix/sysv/linux/sparc/sparc64/Versions Normal file
View File

@ -0,0 +1,9 @@
%ifdef HAVE_FORCED_UNWIND
librtkaio {
GLIBC_2.3.3 {
# Changed timer_t.
timer_create; timer_delete; timer_getoverrun; timer_gettime;
timer_settime;
}
}
%endif

5
rtkaio/sysdeps/unix/sysv/linux/syscalls.list Normal file
View File

@ -0,0 +1,5 @@
# File name Caller Syscall name Args Strong name Weak names
kaio_mq_timedsend - mq_timedsend Ci:ipiip __GI_mq_timedsend mq_timedsend
kaio_mq_timedreceive - mq_timedreceive Ci:ipipp __GI_mq_timedreceive mq_timedreceive
kaio_mq_setattr - mq_getsetattr i:ipp __GI_mq_setattr mq_setattr

1
rtkaio/tst-aio10.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-aio10.c>

1
rtkaio/tst-aio8.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-aio8.c>

1
rtkaio/tst-aio9.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-aio9.c>

307
rtkaio/tst-aiod.c Normal file
View File

@ -0,0 +1,307 @@
/* Tests for AIO in librt.
Copyright (C) 1998, 2000, 2002, 2006 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
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. */
#include <aio.h>
#include <errno.h>
#include <error.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include "tst-aiod.h"
/* Prototype for our test function. */
extern void do_prepare (int argc, char *argv[]);
extern int do_test (int argc, char *argv[]);
/* We have a preparation function. */
#define PREPARE do_prepare
/* We might need a bit longer timeout. */
#define TIMEOUT 20 /* sec */
/* This defines the `main' function and some more. */
#include <test-skeleton.c>
/* These are for the temporary file we generate. */
char *name;
int fd;
char *tmpbuf;
int blksz = 100;
void
do_prepare (int argc, char *argv[])
{
char name_len;
name_len = strlen (test_dir);
name = malloc (name_len + sizeof ("/aioXXXXXX"));
mempcpy (mempcpy (name, test_dir, name_len),
"/aioXXXXXX", sizeof ("/aioXXXXXX"));
add_temp_file (name);
/* Open our test file. */
fd = mkstemp (name);
if (fd == -1)
error (EXIT_FAILURE, errno, "cannot open test file `%s'", name);
int sz = set_o_direct (fd);
if (sz != -1)
{
blksz = sz;
printf ("Using O_DIRECT with block size %d\n", blksz);
}
}
static int
test_file (const void *buf, size_t size, int fd, const char *msg)
{
struct stat st;
char *tmp = tmpbuf;
errno = 0;
if (fstat (fd, &st) < 0)
{
error (0, errno, "%s: failed stat", msg);
return 1;
}
if (st.st_size != (off_t) size)
{
error (0, errno, "%s: wrong size: %lu, should be %lu",
msg, (unsigned long int) st.st_size, (unsigned long int) size);
return 1;
}
if (pread (fd, tmp, size, 0) != (ssize_t) size)
{
error (0, errno, "%s: failed pread", msg);
return 1;
}
if (memcmp (buf, tmp, size) != 0)
{
error (0, errno, "%s: failed comparison", msg);
return 1;
}
printf ("%s test ok\n", msg);
return 0;
}
static int
do_wait (struct aiocb **cbp, size_t nent, int allowed_err)
{
int go_on;
size_t cnt;
int result = 0;
do
{
aio_suspend ((const struct aiocb *const *) cbp, nent, NULL);
go_on = 0;
for (cnt = 0; cnt < nent; ++cnt)
if (cbp[cnt] != NULL)
{
if (aio_error (cbp[cnt]) == EINPROGRESS)
go_on = 1;
else
{
if (aio_return (cbp[cnt]) == -1
&& (allowed_err == 0
|| aio_error (cbp[cnt]) != allowed_err))
{
error (0, aio_error (cbp[cnt]), "Operation failed\n");
result = 1;
}
cbp[cnt] = NULL;
}
}
}
while (go_on);
return result;
}
int
do_test (int argc, char *argv[])
{
struct aiocb cbs[10];
struct aiocb cbs_fsync;
struct aiocb *cbp[10];
struct aiocb *cbp_fsync[1];
char *buf;
size_t cnt;
int result = 0;
buf = mmap (NULL, 20 * blksz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
tmpbuf = buf + 10 * blksz;
if (buf == MAP_FAILED)
{
error (0, errno, "mmap failed");
return 1;
}
/* Preparation. */
for (cnt = 0; cnt < 10; ++cnt)
{
cbs[cnt].aio_fildes = fd;
cbs[cnt].aio_reqprio = 0;
cbs[cnt].aio_buf = memset (&buf[cnt * blksz], '0' + cnt, blksz);
cbs[cnt].aio_nbytes = blksz;
cbs[cnt].aio_offset = cnt * blksz;
cbs[cnt].aio_sigevent.sigev_notify = SIGEV_NONE;
cbp[cnt] = &cbs[cnt];
}
/* First a simple test. */
for (cnt = 10; cnt > 0; )
if (aio_write (cbp[--cnt]) < 0 && errno == ENOSYS)
{
error (0, 0, "no aio support in this configuration");
return 0;
}
/* Wait 'til the results are there. */
result |= do_wait (cbp, 10, 0);
/* Test this. */
result |= test_file (buf, 10 * blksz, fd, "aio_write");
/* Read now as we've written it. */
memset (buf, '\0', 10 * blksz);
/* Issue the commands. */
for (cnt = 10; cnt > 0; )
{
--cnt;
cbp[cnt] = &cbs[cnt];
aio_read (cbp[cnt]);
}
/* Wait 'til the results are there. */
result |= do_wait (cbp, 10, 0);
/* Test this. */
for (cnt = 0; cnt < 10 * blksz; ++cnt)
if (buf[cnt] != '0' + (cnt / blksz))
{
result = 1;
error (0, 0, "comparison failed for aio_read test");
break;
}
if (cnt == 10 * blksz)
puts ("aio_read test ok");
/* Remove the test file contents. */
if (ftruncate (fd, 0) < 0)
{
error (0, errno, "ftruncate failed\n");
result = 1;
}
/* Test lio_listio. */
for (cnt = 0; cnt < 10; ++cnt)
{
cbs[cnt].aio_lio_opcode = LIO_WRITE;
cbp[cnt] = &cbs[cnt];
}
/* Issue the command. */
lio_listio (LIO_WAIT, cbp, 10, NULL);
/* ...and immediately test it since we started it in wait mode. */
result |= test_file (buf, 10 * blksz, fd, "lio_listio (write)");
/* Test aio_fsync. */
cbs_fsync.aio_fildes = fd;
cbs_fsync.aio_sigevent.sigev_notify = SIGEV_NONE;
cbp_fsync[0] = &cbs_fsync;
/* Remove the test file contents first. */
if (ftruncate (fd, 0) < 0)
{
error (0, errno, "ftruncate failed\n");
result = 1;
}
/* Write again. */
for (cnt = 10; cnt > 0; )
aio_write (cbp[--cnt]);
if (aio_fsync (O_SYNC, &cbs_fsync) < 0)
{
error (0, errno, "aio_fsync failed\n");
result = 1;
}
result |= do_wait (cbp_fsync, 1, 0);
/* ...and test since all data should be on disk now. */
result |= test_file (buf, 10 * blksz, fd, "aio_fsync (aio_write)");
/* Test aio_cancel. */
/* Remove the test file contents first. */
if (ftruncate (fd, 0) < 0)
{
error (0, errno, "ftruncate failed\n");
result = 1;
}
/* Write again. */
for (cnt = 10; cnt > 0; )
aio_write (cbp[--cnt]);
/* Cancel all requests. */
if (aio_cancel (fd, NULL) == -1)
printf ("aio_cancel (fd, NULL) cannot cancel anything\n");
result |= do_wait (cbp, 10, ECANCELED);
/* Another test for aio_cancel. */
/* Remove the test file contents first. */
if (ftruncate (fd, 0) < 0)
{
error (0, errno, "ftruncate failed\n");
result = 1;
}
/* Write again. */
for (cnt = 10; cnt > 0; )
{
--cnt;
cbp[cnt] = &cbs[cnt];
aio_write (cbp[cnt]);
}
puts ("finished3");
/* Cancel all requests. */
for (cnt = 10; cnt > 0; )
if (aio_cancel (fd, cbp[--cnt]) == -1)
/* This is not an error. The request can simply be finished. */
printf ("aio_cancel (fd, cbp[%Zd]) cannot be canceled\n", cnt);
puts ("finished2");
result |= do_wait (cbp, 10, ECANCELED);
puts ("finished");
return result;
}

52
rtkaio/tst-aiod.h Normal file
View File

@ -0,0 +1,52 @@
/* Tests for AIO in librt.
Copyright (C) 1998, 2000, 2002, 2006 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
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. */
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
static int
set_o_direct (int fd)
{
int ret = -1;
#ifdef O_DIRECT
if (fcntl (fd, F_SETFL, fcntl (fd, F_GETFL) | O_DIRECT) >= 0)
{
int pgsz = sysconf (_SC_PAGESIZE);
char *buf = mmap (NULL, 16 * pgsz, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, -1, 0);
if (buf != MAP_FAILED)
{
memset (buf, 0, 16 * pgsz);
for (int sz = 256; sz <= 16 * pgsz; sz *= 2)
if (write (fd, buf, sz) > 0)
{
ret = sz;
break;
}
ftruncate64 (fd, 0);
munmap (buf, 16 * pgsz);
}
if (ret < 0)
fcntl (fd, F_SETFL, fcntl (fd, F_GETFL) & ~O_DIRECT);
}
#endif
return ret;
}

113
rtkaio/tst-aiod2.c Normal file
View File

@ -0,0 +1,113 @@
/* Test for notification mechanism in lio_listio.
Copyright (C) 2000, 2002, 2006 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 2000.
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. */
#include <aio.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include "tst-aiod.h"
int flag;
static void
thrfct (sigval_t arg)
{
flag = 1;
}
static int
do_test (int argc, char *argv[])
{
char name[] = "/tmp/aio2.XXXXXX";
int fd;
struct aiocb *arr[1];
struct aiocb cb;
static const char buf[] = "Hello World\n";
fd = mkstemp (name);
if (fd == -1)
{
printf ("cannot open temp name: %m\n");
return 1;
}
unlink (name);
arr[0] = &cb;
void *p;
int sz = set_o_direct (fd);
if (sz != -1)
{
int err = posix_memalign (&p, sz, sz);
if (err)
{
errno = err;
printf ("cannot allocate memory: %m\n");
return 1;
}
memcpy (p, buf, sizeof (buf) - 1);
memset (p + sizeof (buf) - 1, ' ', sz - sizeof (buf) + 1);
printf ("Using O_DIRECT with block size %d\n", sz);
}
else
{
p = (void *) buf;
sz = sizeof (buf) - 1;
}
cb.aio_fildes = fd;
cb.aio_lio_opcode = LIO_WRITE;
cb.aio_reqprio = 0;
cb.aio_buf = p;
cb.aio_nbytes = sz;
cb.aio_offset = 0;
cb.aio_sigevent.sigev_notify = SIGEV_THREAD;
cb.aio_sigevent.sigev_notify_function = thrfct;
cb.aio_sigevent.sigev_notify_attributes = NULL;
cb.aio_sigevent.sigev_value.sival_ptr = NULL;
if (lio_listio (LIO_WAIT, arr, 1, NULL) < 0)
{
if (errno == ENOSYS)
{
puts ("no aio support in this configuration");
return 0;
}
printf ("lio_listio failed: %m\n");
return 1;
}
if (flag != 0)
{
puts ("thread created, should not have happened");
return 1;
}
puts ("all OK");
return 0;
}
#include "../test-skeleton.c"

118
rtkaio/tst-aiod3.c Normal file
View File

@ -0,0 +1,118 @@
/* Test for notification mechanism in lio_listio.
Copyright (C) 2000, 2002, 2006 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. */
#include <aio.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include "tst-aiod.h"
int flag;
static void
thrfct (sigval_t arg)
{
flag = 1;
}
static int
do_test (int argc, char *argv[])
{
char name[] = "/tmp/aio3.XXXXXX";
int fd;
struct aiocb *arr[1];
struct aiocb cb;
static const char buf[] = "Hello World\n";
fd = mkstemp (name);
if (fd == -1)
{
printf ("cannot open temp name: %m\n");
return 1;
}
unlink (name);
arr[0] = &cb;
void *p;
int sz = set_o_direct (fd);
if (sz != -1)
{
int err = posix_memalign (&p, sz, sz);
if (err)
{
errno = err;
printf ("cannot allocate memory: %m\n");
return 1;
}
memcpy (p, buf, sizeof (buf) - 1);
memset (p + sizeof (buf) - 1, ' ', sz - sizeof (buf) + 1);
printf ("Using O_DIRECT with block size %d\n", sz);
}
else
{
p = (void *) buf;
sz = sizeof (buf) - 1;
}
cb.aio_fildes = fd;
cb.aio_lio_opcode = LIO_WRITE;
cb.aio_reqprio = 0;
cb.aio_buf = p;
cb.aio_nbytes = sz;
cb.aio_offset = 0;
cb.aio_sigevent.sigev_notify = SIGEV_THREAD;
cb.aio_sigevent.sigev_notify_function = thrfct;
cb.aio_sigevent.sigev_notify_attributes = NULL;
cb.aio_sigevent.sigev_value.sival_ptr = NULL;
if (lio_listio (LIO_NOWAIT, arr, 1, NULL) < 0)
{
if (errno == ENOSYS)
{
puts ("no aio support in this configuration");
return 0;
}
printf ("lio_listio failed: %m\n");
return 1;
}
if (aio_suspend ((const struct aiocb *const *) arr, 1, NULL) < 0)
{
printf ("aio_suspend failed: %m\n");
return 1;
}
if (flag != 0)
{
puts ("thread created, should not have happened");
return 1;
}
puts ("all OK");
return 0;
}
#include "../test-skeleton.c"

182
rtkaio/tst-aiod4.c Normal file
View File

@ -0,0 +1,182 @@
/* Test for completion signal handling.
Copyright (C) 2000, 2001, 2002, 2006 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. */
#include <aio.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include "tst-aiod.h"
/* We might need a bit longer timeout. */
#define TIMEOUT 10 /* sec */
int my_signo;
volatile sig_atomic_t flag;
static void
sighandler (const int signo)
{
flag = signo;
}
static int
wait_flag (void)
{
while (flag == 0)
{
puts ("Sleeping...");
sleep (1);
}
if (flag != my_signo)
{
printf ("signal handler received wrong signal, flag is %d\n", flag);
return 1;
}
return 0;
}
#ifndef SIGRTMIN
# define SIGRTMIN -1
# define SIGRTMAX -1
#endif
static int
do_test (int argc, char *argv[])
{
char name[] = "/tmp/aio4.XXXXXX";
int fd;
struct aiocb *arr[1];
struct aiocb cb;
static const char buf[] = "Hello World\n";
struct aioinit init = {10, 20, 0};
struct sigaction sa;
struct sigevent ev;
if (SIGRTMIN == -1)
{
printf ("RT signals not supported.\n");
return 0;
}
/* Select a signal from the middle of the available choices... */
my_signo = (SIGRTMAX + SIGRTMIN) / 2;
fd = mkstemp (name);
if (fd == -1)
{
printf ("cannot open temp name: %m\n");
return 1;
}
unlink (name);
/* Test also aio_init. */
aio_init (&init);
arr[0] = &cb;
void *p;
int sz = set_o_direct (fd);
if (sz != -1)
{
int err = posix_memalign (&p, sz, sz);
if (err)
{
errno = err;
printf ("cannot allocate memory: %m\n");
return 1;
}
memcpy (p, buf, sizeof (buf) - 1);
memset (p + sizeof (buf) - 1, ' ', sz - sizeof (buf) + 1);
printf ("Using O_DIRECT with block size %d\n", sz);
}
else
{
p = (void *) buf;
sz = sizeof (buf) - 1;
}
cb.aio_fildes = fd;
cb.aio_lio_opcode = LIO_WRITE;
cb.aio_reqprio = 0;
cb.aio_buf = p;
cb.aio_nbytes = sz;
cb.aio_offset = 0;
cb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
cb.aio_sigevent.sigev_notify_function = NULL;
cb.aio_sigevent.sigev_notify_attributes = NULL;
cb.aio_sigevent.sigev_signo = my_signo;
cb.aio_sigevent.sigev_value.sival_ptr = NULL;
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_notify_function = NULL;
ev.sigev_notify_attributes = NULL;
ev.sigev_signo = my_signo;
sa.sa_handler = sighandler;
sigemptyset (&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction (my_signo, &sa, NULL) < 0)
{
printf ("sigaction failed: %m\n");
return 1;
}
flag = 0;
/* First use aio_write. */
if (aio_write (arr[0]) < 0)
{
if (errno == ENOSYS)
{
puts ("no aio support in this configuration");
return 0;
}
printf ("aio_write failed: %m\n");
return 1;
}
if (wait_flag ())
return 1;
puts ("aio_write OK");
flag = 0;
/* Again with lio_listio. */
if (lio_listio (LIO_NOWAIT, arr, 1, &ev) < 0)
{
printf ("lio_listio failed: %m\n");
return 1;
}
if (wait_flag ())
return 1;
puts ("all OK");
return 0;
}
#include "../test-skeleton.c"

152
rtkaio/tst-aiod5.c Normal file
View File

@ -0,0 +1,152 @@
/* Test for completion thread handling.
Copyright (C) 2000, 2002, 2006 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. */
#include <aio.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include "tst-aiod.h"
/* We might need a bit longer timeout. */
#define TIMEOUT 10 /* sec */
#define MY_SIVAL 27
volatile sig_atomic_t flag;
static void
callback (sigval_t s)
{
flag = s.sival_int;
}
static int
wait_flag (void)
{
while (flag == 0)
{
puts ("Sleeping...");
sleep (1);
}
if (flag != MY_SIVAL)
{
printf ("signal handler received wrong signal, flag is %d\n", flag);
return 1;
}
return 0;
}
static int
do_test (int argc, char *argv[])
{
char name[] = "/tmp/aio5.XXXXXX";
int fd;
struct aiocb *arr[1];
struct aiocb cb;
static const char buf[] = "Hello World\n";
struct sigevent ev;
fd = mkstemp (name);
if (fd == -1)
{
printf ("cannot open temp name: %m\n");
return 1;
}
unlink (name);
arr[0] = &cb;
void *p;
int sz = set_o_direct (fd);
if (sz != -1)
{
int err = posix_memalign (&p, sz, sz);
if (err)
{
errno = err;
printf ("cannot allocate memory: %m\n");
return 1;
}
memcpy (p, buf, sizeof (buf) - 1);
memset (p + sizeof (buf) - 1, ' ', sz - sizeof (buf) + 1);
printf ("Using O_DIRECT with block size %d\n", sz);
}
else
{
p = (void *) buf;
sz = sizeof (buf) - 1;
}
cb.aio_fildes = fd;
cb.aio_lio_opcode = LIO_WRITE;
cb.aio_reqprio = 0;
cb.aio_buf = p;
cb.aio_nbytes = sz;
cb.aio_offset = 0;
cb.aio_sigevent.sigev_notify = SIGEV_THREAD;
cb.aio_sigevent.sigev_notify_function = callback;
cb.aio_sigevent.sigev_notify_attributes = NULL;
cb.aio_sigevent.sigev_value.sival_int = MY_SIVAL;
ev.sigev_notify = SIGEV_THREAD;
ev.sigev_notify_function = callback;
ev.sigev_notify_attributes = NULL;
ev.sigev_value.sival_int = MY_SIVAL;
/* First use aio_write. */
if (aio_write (arr[0]) < 0)
{
if (errno == ENOSYS)
{
puts ("no aio support in this configuration");
return 0;
}
printf ("aio_write failed: %m\n");
return 1;
}
if (wait_flag ())
return 1;
puts ("aio_write OK");
flag = 0;
/* Again with lio_listio. */
if (lio_listio (LIO_NOWAIT, arr, 1, &ev) < 0)
{
printf ("lio_listio failed: %m\n");
return 1;
}
if (wait_flag ())
return 1;
puts ("all OK");
return 0;
}
#include "../test-skeleton.c"

308
rtkaio/tst-aiod64.c Normal file
View File

@ -0,0 +1,308 @@
/* Tests for 64bit AIO in librt.
Copyright (C) 1998, 1999, 2000, 2002, 2006 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
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 _LARGEFILE_SOURCE 1
#include <aio.h>
#include <errno.h>
#include <error.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include "tst-aiod.h"
/* Prototype for our test function. */
extern void do_prepare (int argc, char *argv[]);
extern int do_test (int argc, char *argv[]);
/* We have a preparation function. */
#define PREPARE do_prepare
/* We might need a bit longer timeout. */
#define TIMEOUT 20 /* sec */
/* This defines the `main' function and some more. */
#include <test-skeleton.c>
/* These are for the temporary file we generate. */
char *name;
int fd;
char *tmpbuf;
int blksz = 100;
void
do_prepare (int argc, char *argv[])
{
char name_len;
name_len = strlen (test_dir);
name = malloc (name_len + sizeof ("/aioXXXXXX"));
mempcpy (mempcpy (name, test_dir, name_len),
"/aioXXXXXX", sizeof ("/aioXXXXXX"));
add_temp_file (name);
/* Open our test file. */
fd = mkstemp (name);
if (fd == -1)
error (EXIT_FAILURE, errno, "cannot open test file `%s'", name);
int sz = set_o_direct (fd);
if (sz != -1)
{
blksz = sz;
printf ("Using O_DIRECT with block size %d\n", blksz);
}
}
static int
test_file (const void *buf, size_t size, int fd, const char *msg)
{
struct stat st;
char *tmp = tmpbuf;
errno = 0;
if (fstat (fd, &st) < 0)
{
error (0, errno, "%s: failed stat", msg);
return 1;
}
if (st.st_size != (off_t) size)
{
error (0, errno, "%s: wrong size: %lu, should be %lu",
msg, (unsigned long int) st.st_size, (unsigned long int) size);
return 1;
}
if (pread (fd, tmp, size, 0) != (ssize_t) size)
{
error (0, errno, "%s: failed pread", msg);
return 1;
}
if (memcmp (buf, tmp, size) != 0)
{
error (0, errno, "%s: failed comparison", msg);
return 1;
}
printf ("%s test ok\n", msg);
return 0;
}
static int
do_wait (struct aiocb64 **cbp, size_t nent, int allowed_err)
{
int go_on;
size_t cnt;
int result = 0;
do
{
aio_suspend64 ((const struct aiocb64 *const *) cbp, nent, NULL);
go_on = 0;
for (cnt = 0; cnt < nent; ++cnt)
if (cbp[cnt] != NULL)
{
if (aio_error64 (cbp[cnt]) == EINPROGRESS)
go_on = 1;
else
{
if (aio_return64 (cbp[cnt]) == -1
&& (allowed_err == 0
|| aio_error64 (cbp[cnt]) != allowed_err))
{
error (0, aio_error64 (cbp[cnt]), "Operation failed\n");
result = 1;
}
cbp[cnt] = NULL;
}
}
}
while (go_on);
return result;
}
int
do_test (int argc, char *argv[])
{
struct aiocb64 cbs[10];
struct aiocb64 cbs_fsync;
struct aiocb64 *cbp[10];
struct aiocb64 *cbp_fsync[1];
char *buf;
size_t cnt;
int result = 0;
buf = mmap (NULL, 20 * blksz, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
tmpbuf = buf + 10 * blksz;
if (buf == MAP_FAILED)
{
error (0, errno, "mmap failed");
return 1;
}
/* Preparation. */
for (cnt = 0; cnt < 10; ++cnt)
{
cbs[cnt].aio_fildes = fd;
cbs[cnt].aio_reqprio = 0;
cbs[cnt].aio_buf = memset (&buf[cnt * blksz], '0' + cnt, blksz);
cbs[cnt].aio_nbytes = blksz;
cbs[cnt].aio_offset = cnt * blksz;
cbs[cnt].aio_sigevent.sigev_notify = SIGEV_NONE;
cbp[cnt] = &cbs[cnt];
}
/* First a simple test. */
for (cnt = 10; cnt > 0; )
if (aio_write64 (cbp[--cnt]) < 0 && errno == ENOSYS)
{
error (0, 0, "no aio support in this configuration");
return 0;
}
/* Wait 'til the results are there. */
result |= do_wait (cbp, 10, 0);
/* Test this. */
result |= test_file (buf, 10 * blksz, fd, "aio_write");
/* Read now as we've written it. */
memset (buf, '\0', 10 * blksz);
/* Issue the commands. */
for (cnt = 10; cnt > 0; )
{
--cnt;
cbp[cnt] = &cbs[cnt];
aio_read64 (cbp[cnt]);
}
/* Wait 'til the results are there. */
result |= do_wait (cbp, 10, 0);
/* Test this. */
for (cnt = 0; cnt < 10 * blksz; ++cnt)
if (buf[cnt] != '0' + (cnt / blksz))
{
result = 1;
error (0, 0, "comparison failed for aio_read test");
break;
}
if (cnt == 10 * blksz)
puts ("aio_read test ok");
/* Remove the test file contents. */
if (ftruncate64 (fd, 0) < 0)
{
error (0, errno, "ftruncate failed\n");
result = 1;
}
/* Test lio_listio. */
for (cnt = 0; cnt < 10; ++cnt)
{
cbs[cnt].aio_lio_opcode = LIO_WRITE;
cbp[cnt] = &cbs[cnt];
}
/* Issue the command. */
lio_listio64 (LIO_WAIT, cbp, 10, NULL);
/* ...and immediately test it since we started it in wait mode. */
result |= test_file (buf, 10 * blksz, fd, "lio_listio (write)");
/* Test aio_fsync. */
cbs_fsync.aio_fildes = fd;
cbs_fsync.aio_sigevent.sigev_notify = SIGEV_NONE;
cbp_fsync[0] = &cbs_fsync;
/* Remove the test file contents first. */
if (ftruncate64 (fd, 0) < 0)
{
error (0, errno, "ftruncate failed\n");
result = 1;
}
/* Write again. */
for (cnt = 10; cnt > 0; )
aio_write64 (cbp[--cnt]);
if (aio_fsync64 (O_SYNC, &cbs_fsync) < 0)
{
error (0, errno, "aio_fsync failed\n");
result = 1;
}
result |= do_wait (cbp_fsync, 1, 0);
/* ...and test since all data should be on disk now. */
result |= test_file (buf, 10 * blksz, fd, "aio_fsync (aio_write)");
/* Test aio_cancel. */
/* Remove the test file contents first. */
if (ftruncate64 (fd, 0) < 0)
{
error (0, errno, "ftruncate failed\n");
result = 1;
}
/* Write again. */
for (cnt = 10; cnt > 0; )
aio_write64 (cbp[--cnt]);
/* Cancel all requests. */
if (aio_cancel64 (fd, NULL) == -1)
printf ("aio_cancel64 (fd, NULL) cannot cancel anything\n");
result |= do_wait (cbp, 10, ECANCELED);
/* Another test for aio_cancel. */
/* Remove the test file contents first. */
if (ftruncate64 (fd, 0) < 0)
{
error (0, errno, "ftruncate failed\n");
result = 1;
}
/* Write again. */
for (cnt = 10; cnt > 0; )
{
--cnt;
cbp[cnt] = &cbs[cnt];
aio_write64 (cbp[cnt]);
}
puts ("finished3");
/* Cancel all requests. */
for (cnt = 10; cnt > 0; )
if (aio_cancel64 (fd, cbp[--cnt]) == -1)
/* This is not an error. The request can simply be finished. */
printf ("aio_cancel64 (fd, cbp[%Zd]) cannot be canceled\n", cnt);
puts ("finished2");
result |= do_wait (cbp, 10, ECANCELED);
puts ("finished");
return result;
}

1
rtkaio/tst-clock2.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-clock2.c>

1
rtkaio/tst-cpuclock1.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-cpuclock1.c>

1
rtkaio/tst-cpuclock2.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-cpuclock2.c>

1
rtkaio/tst-cputimer1.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-cputimer1.c>

1
rtkaio/tst-cputimer2.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-cputimer2.c>

1
rtkaio/tst-cputimer3.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-cputimer3.c>

1
rtkaio/tst-mqueue8.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-mqueue8.c>

1
rtkaio/tst-mqueue9.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-mqueue9.c>

1
rtkaio/tst-timer.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-timer.c>

1
rtkaio/tst-timer5.c Normal file
View File

@ -0,0 +1 @@
#include <rt/tst-timer5.c>