musl/src/stdio/__stdio_close.c

#include "stdio_impl.h"

static int dummy(int fd)
{
	return fd;
}

weak_alias(dummy, __aio_close);

int __stdio_close(FILE *f)
{
	return syscall(SYS_close, __aio_close(f->fd));
}
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`#include "stdio_impl.h"`

overhaul aio implementation for correctness previously, aio operations were not tracked by file descriptor; each operation was completely independent. this resulted in non-conforming behavior for non-seekable/append-mode writes (which are required to be ordered) and made it impossible to implement aio_cancel, which in turn made closing file descriptors with outstanding aio operations unsafe. the new implementation is significantly heavier (roughly twice the size, and seems to be slightly slower) and presently aims mainly at correctness, not performance. most of the public interfaces have been moved into a single file, aio.c, because there is little benefit to be had from splitting them. whenever any aio functions are used, aio_cancel and the internal queue lifetime management and fd-to-queue mapping code must be linked, and these functions make up the bulk of the code size. the close function's interaction with aio is implemented with weak alias magic, to avoid pulling in heavy aio cancellation code in programs that don't use aio, and the expensive cancellation path (which includes signal blocking) is optimized out when there are no active aio queues. 2015-02-13 00:27:45 -05:00			`static int dummy(int fd)`
			`{`
			`return fd;`
			`}`

			`weak_alias(dummy, __aio_close);`

initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`int __stdio_close(FILE *f)`
			`{`
overhaul aio implementation for correctness previously, aio operations were not tracked by file descriptor; each operation was completely independent. this resulted in non-conforming behavior for non-seekable/append-mode writes (which are required to be ordered) and made it impossible to implement aio_cancel, which in turn made closing file descriptors with outstanding aio operations unsafe. the new implementation is significantly heavier (roughly twice the size, and seems to be slightly slower) and presently aims mainly at correctness, not performance. most of the public interfaces have been moved into a single file, aio.c, because there is little benefit to be had from splitting them. whenever any aio functions are used, aio_cancel and the internal queue lifetime management and fd-to-queue mapping code must be linked, and these functions make up the bulk of the code size. the close function's interaction with aio is implemented with weak alias magic, to avoid pulling in heavy aio cancellation code in programs that don't use aio, and the expensive cancellation path (which includes signal blocking) is optimized out when there are no active aio queues. 2015-02-13 00:27:45 -05:00			`return syscall(SYS_close, __aio_close(f->fd));`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`}`