aboutsummaryrefslogtreecommitdiff
path: root/sys/sys/aio.h
blob: 4b1604b404a51e3db305fb0ca07e5fb284b0f0d8 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
#ifndef	_AIO_H_
#define	_AIO_H_

/*
 * Copyright (c) 1997 John S. Dyson.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. John S. Dyson's name may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * DISCLAIMER:  This code isn't warranted to do anything useful.  Anything
 * bad that happens because of using this software isn't the responsibility
 * of the author.  This software is distributed AS-IS.
 *
 * $Id: aio.h,v 1.2 1997/07/17 04:49:43 dyson Exp $
 */

#include <sys/types.h>

/**************************************************************************/
/* Additions to signal.h -- hack alert.                                   */
/**************************************************************************/
/*
 * sigval structure:
 */
union sigval {
	int	sival_int;
	void	*sival_ptr;
};

/*
 * this is the sigevent structure:
 */
struct sigevent {
	int	sigev_notify;		/* Notification */
	int	sigev_signo;		/* Signal number */
	union sigval sigev_value;	/* Not used yet in FreeBSD */
};

/*
 * values for sigev_notify:
 */	
#define	SIGEV_NONE	0		/* Don't post a signal */
#define	SIGEV_SIGNAL	1		/* Post specified signal */

/**************************************************************************/
/* Actual AIO header                                                      */
/**************************************************************************/
/*
 * Returned by aio_cancel:
 *  (Note that FreeBSD's aio is not cancellable -- yet.)
 */
#define	AIO_CANCELED		0x1
#define AIO_NOTCANCELED       0x2
#define	AIO_ALLDONE		0x3

/*
 * LIO opcodes
 */
#define	LIO_NOP			0x0
#define LIO_WRITE		0x1
#define	LIO_READ		0x2

/*
 * LIO modes
 */
#define	LIO_NOWAIT		0x0
#define	LIO_WAIT		0x1

/*
 * Maximum number of allowed LIO operations
 */
#define	AIO_LISTIO_MAX		16

/*
 * Private mode bit for aio.
 * (This bit is set by the library routine
 *  to allow the kernel to support sync
 *  or async operations in the future.)
 */
#define AIO_PMODE_SYNC		0x1
#define AIO_PMODE_DONE		0x2
#define AIO_PMODE_SUSPEND	0x4

/*
 * I/O active flag -- used for compat
 * with kernel.
 */
#define AIO_PMODE_ACTIVE	0x2357c0de

/*
 * Private members for aiocb -- don't access
 * directly.
 */
struct __aiocb_private {
	int	status;
	int	error;
	int	privatemodes;
	int	active;
	int	tid;
	int	threadinfo;
	void	*userinfo;
	void	*kernelinfo;
};

/*
 * I/O control block
 */
typedef struct aiocb {
	int	aio_fildes;		/* File descriptor */
	off_t	aio_offset;		/* File offset for I/O */
      volatile void *aio_buf;         /* I/O buffer in process space */
	size_t	aio_nbytes;		/* Number of bytes for I/O */
	struct	sigevent aio_sigevent;	/* Signal to deliver */
	int	aio_lio_opcode;		/* LIO opcode */
	int	aio_reqprio;		/* Request priority -- ignored */
	struct	__aiocb_private	_aiocb_private;
} aiocb_t;

#ifndef KERNEL
/*
 * Asynchronously read from a file
 */
int aio_read( struct aiocb *iocb);

/*
 * Asynchronously write to file
 */
int aio_write( struct aiocb *iocb);

/*
 * List I/O Asynchronously/synchronously read/write to/from file
 *	"lio_mode" specifies whether or not the I/O is synchronous.
 *	"acb_list" is an array of "nacb_listent" I/O control blocks.
 *	when all I/Os are complete, the optional signal "sig" is sent.
 */
int lio_listio( int lio_mode, struct aiocb * const acb_list[],
	       int nacb_listent, struct sigevent *sig);

/*
 * Get completion status
 *	returns EINPROGRESS until I/O is complete.
 *	this routine does not block.
 */
int aio_error( const struct aiocb *iocb);

/*
 * Finish up I/O, releasing I/O resources and returns the value
 *	that would have been associated with a synchronous I/O request.
 *	This routine must be called once and only once for each
 *	I/O control block who has had I/O associated with it.
 */
ssize_t aio_return( struct aiocb *iocb);

/*
 * Cancel I/O -- implemented only to return AIO_NOTCANCELLED or
 *	AIO_ALLDONE.  No cancellation operation will occur.
 */
int aio_cancel( int fd, struct aiocb *iocb);

/*
 * Suspend until all specified I/O or timeout is complete.
 */
int aio_suspend( const struct aiocb * const acb_list[], int nacb_listent,
               const struct timespec *tm);

#else

void	aio_proc_rundown( struct proc *p);

#endif

#endif