os0file.h 25.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/******************************************************
The interface to the operating system file io

(c) 1995 Innobase Oy

Created 10/21/1995 Heikki Tuuri
*******************************************************/

#ifndef os0file_h
#define os0file_h

#include "univ.i"

unknown's avatar
unknown committed
14 15 16
#ifndef __WIN__
#include <dirent.h>
#include <sys/stat.h>
17
#include <time.h>
unknown's avatar
unknown committed
18
#endif
unknown's avatar
unknown committed
19

unknown's avatar
unknown committed
20 21
typedef	struct fil_node_struct	fil_node_t;

unknown's avatar
unknown committed
22 23
extern ibool	os_do_not_call_flush_at_each_write;
extern ibool	os_has_said_disk_full;
unknown's avatar
unknown committed
24
extern ibool	os_aio_print_debug;
unknown's avatar
unknown committed
25

unknown's avatar
unknown committed
26 27 28
extern ulint	os_file_n_pending_preads;
extern ulint	os_file_n_pending_pwrites;

29 30 31
extern ulint    os_n_pending_reads;
extern ulint    os_n_pending_writes;

32 33
#ifdef __WIN__

34 35
/* We define always WIN_ASYNC_IO, and check at run-time whether
   the OS actually supports it: Win 95 does not, NT does. */
36 37 38 39 40 41 42
#define WIN_ASYNC_IO

#define UNIV_NON_BUFFERED_IO

#endif

#ifdef __WIN__
43
#define os_file_t	HANDLE
44 45 46 47
#else
typedef int	os_file_t;
#endif

unknown's avatar
unknown committed
48 49
extern ulint	os_innodb_umask;

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
/* If this flag is TRUE, then we will use the native aio of the
OS (provided we compiled Innobase with it in), otherwise we will
use simulated aio we build below with threads */

extern ibool	os_aio_use_native_aio;

#define OS_FILE_SECTOR_SIZE		512

/* The next value should be smaller or equal to the smallest sector size used
on any disk. A log block is required to be a portion of disk which is written
so that if the start and the end of a block get written to disk, then the
whole block gets written. This should be true even in most cases of a crash:
if this fails for a log block, then it is equivalent to a media failure in the
log. */

#define OS_FILE_LOG_BLOCK_SIZE		512

/* Options for file_create */
#define	OS_FILE_OPEN			51
#define	OS_FILE_CREATE			52
#define OS_FILE_OVERWRITE		53
unknown's avatar
unknown committed
71
#define OS_FILE_OPEN_RAW		54
unknown's avatar
unknown committed
72
#define	OS_FILE_CREATE_PATH		55
73 74
#define	OS_FILE_OPEN_RETRY		56	/* for os_file_create() on
						the first ibdata file */
75

unknown's avatar
unknown committed
76 77
#define OS_FILE_READ_ONLY 		333
#define	OS_FILE_READ_WRITE		444
unknown's avatar
unknown committed
78
#define	OS_FILE_READ_ALLOW_DELETE	555	/* for ibbackup */
unknown's avatar
unknown committed
79

80 81 82 83
/* Options for file_create */
#define	OS_FILE_AIO			61
#define	OS_FILE_NORMAL			62

84 85 86 87
/* Types for file create */
#define	OS_DATA_FILE			100
#define OS_LOG_FILE			101

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
/* Error codes from os_file_get_last_error */
#define	OS_FILE_NOT_FOUND		71
#define	OS_FILE_DISK_FULL		72
#define	OS_FILE_ALREADY_EXISTS		73
#define OS_FILE_AIO_RESOURCES_RESERVED	74	/* wait for OS aio resources
						to become available again */
#define	OS_FILE_ERROR_NOT_SPECIFIED	75

/* Types for aio operations */
#define OS_FILE_READ	10
#define OS_FILE_WRITE	11

#define OS_FILE_LOG	256	/* This can be ORed to type */

#define OS_AIO_N_PENDING_IOS_PER_THREAD 32	/* Win NT does not allow more
						than 64 */

/* Modes for aio operations */
#define OS_AIO_NORMAL	21	/* Normal asynchronous i/o not for ibuf
				pages or ibuf bitmap pages */
#define OS_AIO_IBUF	22	/* Asynchronous i/o for ibuf pages or ibuf
				bitmap pages */
#define OS_AIO_LOG  	23	/* Asynchronous i/o for the log */
#define OS_AIO_SYNC	24	/* Asynchronous i/o where the calling thread
				will itself wait for the i/o to complete,
				doing also the job of the i/o-handler thread;
				can be used for any pages, ibuf or non-ibuf.
				This is used to save CPU time, as we can do
				with fewer thread switches. Plain synchronous
				i/o is not as good, because it must serialize
				the file seek and read or write, causing a
				bottleneck for parallelism. */

#define OS_AIO_SIMULATED_WAKE_LATER	512 /* This can be ORed to mode
				in the call of os_aio(...),
				if the caller wants to post several i/o
				requests in a batch, and only after that
 				wake the i/o-handler thread; this has
				effect only in simulated aio */ 
127 128 129
#define OS_WIN31     1
#define OS_WIN95     2	
#define OS_WINNT     3
unknown's avatar
unknown committed
130
#define OS_WIN2000   4
131

unknown's avatar
Merge  
unknown committed
132 133 134 135
extern ulint	os_n_file_reads;
extern ulint	os_n_file_writes;
extern ulint	os_n_fsyncs;

unknown's avatar
unknown committed
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
/* File types for directory entry data type */

enum os_file_type_enum{
    OS_FILE_TYPE_UNKNOWN = 0,
    OS_FILE_TYPE_FILE,	 		/* regular file */
    OS_FILE_TYPE_DIR,			/* directory */
    OS_FILE_TYPE_LINK 			/* symbolic link */
};
typedef enum os_file_type_enum	  os_file_type_t;

/* Maximum path string length in bytes when referring to tables with in the
'./databasename/tablename.ibd' path format; we can allocate at least 2 buffers
of this size from the thread stack; that is why this should not be made much
bigger than 4000 bytes */
#define OS_FILE_MAX_PATH	4000

/* Struct used in fetching information of a file in a directory */
struct os_file_stat_struct{
154 155 156 157 158 159
	char		name[OS_FILE_MAX_PATH];	/* path to a file */
	os_file_type_t	type;			/* file type */
	ib_longlong	size;			/* file size */
	time_t          ctime;			/* creation time */
	time_t		mtime;			/* modification time */
	time_t		atime;			/* access time */
unknown's avatar
unknown committed
160
};
161
typedef struct os_file_stat_struct	os_file_stat_t;
unknown's avatar
unknown committed
162

unknown's avatar
unknown committed
163
#ifdef __WIN__
unknown's avatar
unknown committed
164 165 166 167 168
typedef HANDLE  os_file_dir_t;	/* directory stream */
#else
typedef DIR*	os_file_dir_t;	/* directory stream */
#endif

169 170 171 172 173 174
/***************************************************************************
Gets the operating system version. Currently works only on Windows. */

ulint
os_get_os_version(void);
/*===================*/
unknown's avatar
unknown committed
175
                  /* out: OS_WIN95, OS_WIN31, OS_WINNT, or OS_WIN2000 */
176
/********************************************************************
unknown's avatar
unknown committed
177 178 179 180 181
Creates the seek mutexes used in positioned reads and writes. */

void
os_io_init_simple(void);
/*===================*/
unknown's avatar
unknown committed
182
/***************************************************************************
183
Creates a temporary file. */
184 185 186 187

FILE*
os_file_create_tmpfile(void);
/*========================*/
unknown's avatar
unknown committed
188
			/* out: temporary file handle (never NULL) */
189
/***************************************************************************
unknown's avatar
unknown committed
190 191 192 193 194 195 196 197
The os_file_opendir() function opens a directory stream corresponding to the
directory named by the dirname argument. The directory stream is positioned
at the first entry. In both Unix and Windows we automatically skip the '.'
and '..' items at the start of the directory listing. */

os_file_dir_t
os_file_opendir(
/*============*/
198 199 200 201 202 203 204 205 206
					/* out: directory stream, NULL if
					error */
	const char*	dirname,	/* in: directory name; it must not
					contain a trailing '\' or '/' */
	ibool		error_is_fatal);/* in: TRUE if we should treat an
					error as a fatal error; if we try to
					open symlinks then we do not wish a
					fatal error if it happens not to be
					a directory */
unknown's avatar
unknown committed
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
/***************************************************************************
Closes a directory stream. */

int
os_file_closedir(
/*=============*/
				/* out: 0 if success, -1 if failure */
	os_file_dir_t	dir);	/* in: directory stream */
/***************************************************************************
This function returns information of the next file in the directory. We jump
over the '.' and '..' entries in the directory. */

int
os_file_readdir_next_file(
/*======================*/
				/* out: 0 if ok, -1 if error, 1 if at the end
				of the directory */
224
	const char*	dirname,/* in: directory name or path */
unknown's avatar
unknown committed
225 226
	os_file_dir_t	dir,	/* in: directory stream */
	os_file_stat_t*	info);	/* in/out: buffer where the info is returned */
unknown's avatar
unknown committed
227 228 229 230 231 232 233 234 235
/*********************************************************************
This function attempts to create a directory named pathname. The new directory
gets default permissions. On Unix, the permissions are (0770 & ~umask). If the
directory exists already, nothing is done and the call succeeds, unless the
fail_if_exists arguments is true. */

ibool
os_file_create_directory(
/*=====================*/
236 237 238 239 240 241
					/* out: TRUE if call succeeds,
					FALSE on error */
	const char*	pathname,	/* in: directory name as
					null-terminated string */
	ibool		fail_if_exists);/* in: if TRUE, pre-existing directory
					is treated as an error. */
unknown's avatar
unknown committed
242 243 244 245 246 247
/********************************************************************
A simple function to open or create a file. */

os_file_t
os_file_create_simple(
/*==================*/
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
				/* out, own: handle to the file, not defined
				if error, error number can be retrieved with
				os_file_get_last_error */
	const char*	name,	/* in: name of the file or path as a
				null-terminated string */
	ulint		create_mode,/* in: OS_FILE_OPEN if an existing file is
				opened (if does not exist, error), or
				OS_FILE_CREATE if a new file is created
				(if exists, error), or
	                        OS_FILE_CREATE_PATH if new file
				(if exists, error) and subdirectories along
				its path are created (if needed)*/
	ulint		access_type,/* in: OS_FILE_READ_ONLY or
				OS_FILE_READ_WRITE */
	ibool*		success);/* out: TRUE if succeed, FALSE if error */
unknown's avatar
unknown committed
263
/********************************************************************
unknown's avatar
unknown committed
264 265 266 267 268
A simple function to open or create a file. */

os_file_t
os_file_create_simple_no_error_handling(
/*====================================*/
269 270 271 272 273 274 275 276 277 278 279 280 281 282
				/* out, own: handle to the file, not defined
				if error, error number can be retrieved with
				os_file_get_last_error */
	const char*	name,	/* in: name of the file or path as a
				null-terminated string */
	ulint		create_mode,/* in: OS_FILE_OPEN if an existing file
				is opened (if does not exist, error), or
				OS_FILE_CREATE if a new file is created
				(if exists, error) */
	ulint		access_type,/* in: OS_FILE_READ_ONLY,
				OS_FILE_READ_WRITE, or
				OS_FILE_READ_ALLOW_DELETE; the last option is
				used by a backup program reading the file */
	ibool*		success);/* out: TRUE if succeed, FALSE if error */
unknown's avatar
unknown committed
283
/********************************************************************
284 285 286 287 288
Opens an existing file or creates a new. */

os_file_t
os_file_create(
/*===========*/
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
				/* out, own: handle to the file, not defined
				if error, error number can be retrieved with
				os_file_get_last_error */
	const char*	name,	/* in: name of the file or path as a
				null-terminated string */
	ulint		create_mode,/* in: OS_FILE_OPEN if an existing file
				is opened (if does not exist, error), or
				OS_FILE_CREATE if a new file is created
				(if exists, error),
				OS_FILE_OVERWRITE if a new file is created
				or an old overwritten;
				OS_FILE_OPEN_RAW, if a raw device or disk
				partition should be opened */
	ulint		purpose,/* in: OS_FILE_AIO, if asynchronous,
				non-buffered i/o is desired,
				OS_FILE_NORMAL, if any normal file;
				NOTE that it also depends on type, os_aio_..
				and srv_.. variables whether we really use
				async i/o or unbuffered i/o: look in the
				function source code for the exact rules */
	ulint		type,	/* in: OS_DATA_FILE or OS_LOG_FILE */
	ibool*		success);/* out: TRUE if succeed, FALSE if error */
311
/***************************************************************************
unknown's avatar
unknown committed
312 313 314 315 316
Deletes a file. The file has to be closed before calling this. */

ibool
os_file_delete(
/*===========*/
317 318
				/* out: TRUE if success */
	const char*	name);	/* in: file path as a null-terminated string */
unknown's avatar
unknown committed
319 320 321 322 323 324 325

/***************************************************************************
Deletes a file if it exists. The file has to be closed before calling this. */

ibool
os_file_delete_if_exists(
/*=====================*/
326 327
				/* out: TRUE if success */
	const char*	name);	/* in: file path as a null-terminated string */
unknown's avatar
unknown committed
328 329 330 331 332 333 334
/***************************************************************************
Renames a file (can also move it to another directory). It is safest that the
file is closed before calling this function. */

ibool
os_file_rename(
/*===========*/
335 336 337 338
					/* out: TRUE if success */
	const char*	oldpath,	/* in: old file path as a
					null-terminated string */
	const char*	newpath);	/* in: new file path */
unknown's avatar
unknown committed
339
/***************************************************************************
340 341 342 343 344 345 346 347 348
Closes a file handle. In case of error, error number can be retrieved with
os_file_get_last_error. */

ibool
os_file_close(
/*==========*/
				/* out: TRUE if success */
	os_file_t	file);	/* in, own: handle to a file */
/***************************************************************************
unknown's avatar
unknown committed
349 350 351 352 353 354 355 356
Closes a file handle. */

ibool
os_file_close_no_error_handling(
/*============================*/
				/* out: TRUE if success */
	os_file_t	file);	/* in, own: handle to a file */
/***************************************************************************
357 358 359 360 361 362 363 364 365 366 367
Gets a file size. */

ibool
os_file_get_size(
/*=============*/
				/* out: TRUE if success */
	os_file_t	file,	/* in: handle to a file */
	ulint*		size,	/* out: least significant 32 bits of file
				size */
	ulint*		size_high);/* out: most significant 32 bits of size */
/***************************************************************************
368 369 370 371 372 373 374 375
Gets file size as a 64-bit integer ib_longlong. */

ib_longlong
os_file_get_size_as_iblonglong(
/*===========================*/
				/* out: size in bytes, -1 if error */
	os_file_t	file);	/* in: handle to a file */
/***************************************************************************
376 377 378 379 380 381
Sets a file size. This function can be used to extend or truncate a file. */

ibool
os_file_set_size(
/*=============*/
				/* out: TRUE if success */
382
	const char*	name,	/* in: name of the file or path as a
383 384 385 386 387 388
				null-terminated string */
	os_file_t	file,	/* in: handle to a file */
	ulint		size,	/* in: least significant 32 bits of file
				size */
	ulint		size_high);/* in: most significant 32 bits of size */
/***************************************************************************
389 390 391 392 393 394 395 396
Truncates a file at its current position. */

ibool
os_file_set_eof(
/*============*/
				/* out: TRUE if success */
	FILE*		file);	/* in: file to be truncated */
/***************************************************************************
397 398 399 400 401 402 403 404 405 406 407 408 409 410
Flushes the write buffers of a given file to the disk. */

ibool
os_file_flush(
/*==========*/
				/* out: TRUE if success */
	os_file_t	file);	/* in, own: handle to a file */
/***************************************************************************
Retrieves the last error number if an error occurs in a file io function.
The number should be retrieved before any other OS calls (because they may
overwrite the error number). If the number is not known to this program,
the OS error number + 100 is returned. */

ulint
unknown's avatar
unknown committed
411 412 413 414 415 416
os_file_get_last_error(
/*===================*/
					/* out: error number, or OS error
					number + 100 */
	ibool	report_all_errors);	/* in: TRUE if we want an error message
					printed of all errors */
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
/***********************************************************************
Requests a synchronous read operation. */

ibool
os_file_read(
/*=========*/
				/* out: TRUE if request was
				successful, FALSE if fail */
	os_file_t	file,	/* in: handle to a file */
	void*		buf,	/* in: buffer where to read */
	ulint		offset,	/* in: least significant 32 bits of file
				offset where to read */
	ulint		offset_high,/* in: most significant 32 bits of
				offset */
	ulint		n);	/* in: number of bytes to read */	
/***********************************************************************
unknown's avatar
unknown committed
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
Requests a synchronous positioned read operation. This function does not do
any error handling. In case of error it returns FALSE. */

ibool
os_file_read_no_error_handling(
/*===========================*/
				/* out: TRUE if request was
				successful, FALSE if fail */
	os_file_t	file,	/* in: handle to a file */
	void*		buf,	/* in: buffer where to read */
	ulint		offset,	/* in: least significant 32 bits of file
				offset where to read */
	ulint		offset_high,/* in: most significant 32 bits of
				offset */
	ulint		n);	/* in: number of bytes to read */	

/***********************************************************************
450 451 452 453 454 455 456
Requests a synchronous write operation. */

ibool
os_file_write(
/*==========*/
				/* out: TRUE if request was
				successful, FALSE if fail */
457
	const char*	name,	/* in: name of the file or path as a
458 459
				null-terminated string */
	os_file_t	file,	/* in: handle to a file */
460
	const void*	buf,	/* in: buffer from which to write */
461 462 463 464 465
	ulint		offset,	/* in: least significant 32 bits of file
				offset where to write */
	ulint		offset_high,/* in: most significant 32 bits of
				offset */
	ulint		n);	/* in: number of bytes to write */	
unknown's avatar
unknown committed
466 467 468 469 470 471 472
/***********************************************************************
Check the existence and type of the given file. */

ibool
os_file_status(
/*===========*/
				/* out: TRUE if call succeeded */
473 474
	const char*	path,	/* in:  pathname of the file */
	ibool*		exists,	/* out: TRUE if file exists */
unknown's avatar
unknown committed
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
	os_file_type_t* type);	/* out: type of the file (if it exists) */
/********************************************************************
The function os_file_dirname returns a directory component of a
null-terminated pathname string.  In the usual case, dirname returns
the string up to, but not including, the final '/', and basename
is the component following the final '/'.  Trailing '/' charac­
ters are not counted as part of the pathname.

If path does not contain a slash, dirname returns the string ".".

Concatenating the string returned by dirname, a "/", and the basename
yields a complete pathname.

The return value is  a copy of the directory component of the pathname.
The copy is allocated from heap. It is the caller responsibility
to free it after it is no longer needed.	

The following list of examples (taken from SUSv2) shows the strings
returned by dirname and basename for different paths:

       path           dirname        basename
       "/usr/lib"     "/usr"         "lib"
       "/usr/"        "/"            "usr"
       "usr"          "."            "usr"
       "/"            "/"            "/"
       "."            "."            "."
       ".."           "."            ".."
*/

char*
os_file_dirname(
/*============*/
				/* out, own: directory component of the
				pathname */
509
	const char*	path);	/* in: pathname */
unknown's avatar
unknown committed
510 511 512 513 514 515 516 517
/********************************************************************
Creates all missing subdirectories along the given path. */
	
ibool
os_file_create_subdirs_if_needed(
/*=============================*/
				/* out: TRUE if call succeeded
				   FALSE otherwise */
518
	const char*	path);	/* in: path name */
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
/****************************************************************************
Initializes the asynchronous io system. Creates separate aio array for
non-ibuf read and write, a third aio array for the ibuf i/o, with just one
segment, two aio arrays for log reads and writes with one segment, and a
synchronous aio array of the specified size. The combined number of segments
in the three first aio arrays is the parameter n_segments given to the
function. The caller must create an i/o handler thread for each segment in
the four first arrays, but not for the sync aio array. */

void
os_aio_init(
/*========*/
	ulint	n,		/* in: maximum number of pending aio operations
				allowed; n must be divisible by n_segments */
	ulint	n_segments,	/* in: combined number of segments in the four
				first aio arrays; must be >= 4 */
	ulint	n_slots_sync);	/* in: number of slots in the sync aio array */
/***********************************************************************
Requests an asynchronous i/o operation. */

ibool
os_aio(
/*===*/
				/* out: TRUE if request was queued
				successfully, FALSE if fail */
	ulint		type,	/* in: OS_FILE_READ or OS_FILE_WRITE */
	ulint		mode,	/* in: OS_AIO_NORMAL, ..., possibly ORed
				to OS_AIO_SIMULATED_WAKE_LATER: the
				last flag advises this function not to wake
				i/o-handler threads, but the caller will
				do the waking explicitly later, in this
				way the caller can post several requests in
				a batch; NOTE that the batch must not be
				so big that it exhausts the slots in aio
				arrays! NOTE that a simulated batch
				may introduce hidden chances of deadlocks,
				because i/os are not actually handled until
				all have been posted: use with great
				caution! */
558
	const char*	name,	/* in: name of the file or path as a
559 560 561 562 563 564 565 566 567
				null-terminated string */
	os_file_t	file,	/* in: handle to a file */
	void*		buf,	/* in: buffer where to read or from which
				to write */
	ulint		offset,	/* in: least significant 32 bits of file
				offset where to read or write */
	ulint		offset_high, /* in: most significant 32 bits of
				offset */
	ulint		n,	/* in: number of bytes to read or write */	
unknown's avatar
unknown committed
568
	fil_node_t*	message1,/* in: messages for the aio handler (these
569 570 571 572
				can be used to identify a completed aio
				operation); if mode is OS_AIO_SYNC, these
				are ignored */
	void*		message2);
573
/****************************************************************************
unknown's avatar
unknown committed
574 575 576 577 578 579 580
Wakes up all async i/o threads so that they know to exit themselves in
shutdown. */

void
os_aio_wake_all_threads_at_shutdown(void);
/*=====================================*/
/****************************************************************************
581 582 583 584 585 586
Waits until there are no pending writes in os_aio_write_array. There can
be other, synchronous, pending writes. */

void
os_aio_wait_until_no_pending_writes(void);
/*=====================================*/
587 588 589 590 591 592
/**************************************************************************
Wakes up simulated aio i/o-handler threads if they have something to do. */

void
os_aio_simulated_wake_handler_threads(void);
/*=======================================*/
unknown's avatar
unknown committed
593 594 595 596 597 598 599 600 601
/**************************************************************************
This function can be called if one wants to post a batch of reads and
prefers an i/o-handler thread to handle them all at once later. You must
call os_aio_simulated_wake_handler_threads later to ensure the threads
are not left sleeping! */

void
os_aio_simulated_put_read_threads_to_sleep(void);
/*============================================*/
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625

#ifdef WIN_ASYNC_IO
/**************************************************************************
This function is only used in Windows asynchronous i/o.
Waits for an aio operation to complete. This function is used to wait the
for completed requests. The aio array of pending requests is divided
into segments. The thread specifies which segment or slot it wants to wait
for. NOTE: this function will also take care of freeing the aio slot,
therefore no other thread is allowed to do the freeing! */

ibool
os_aio_windows_handle(
/*==================*/
				/* out: TRUE if the aio operation succeeded */
	ulint	segment,	/* in: the number of the segment in the aio
				arrays to wait for; segment 0 is the ibuf
				i/o thread, segment 1 the log i/o thread,
				then follow the non-ibuf read threads, and as
				the last are the non-ibuf write threads; if
				this is ULINT_UNDEFINED, then it means that
				sync aio is used, and this parameter is
				ignored */
	ulint	pos,		/* this parameter is used only in sync aio:
				wait for the aio slot at this position */  
unknown's avatar
unknown committed
626
	fil_node_t**message1,	/* out: the messages passed with the aio
627 628 629 630
				request; note that also in the case where
				the aio operation failed, these output
				parameters are valid and can be used to
				restart the operation, for example */
631 632
	void**	message2,
	ulint*	type);		/* out: OS_FILE_WRITE or ..._READ */
633
#endif
unknown's avatar
unknown committed
634 635

/* Currently we do not use Posix async i/o */
636 637 638 639 640 641 642 643 644 645
#ifdef POSIX_ASYNC_IO
/**************************************************************************
This function is only used in Posix asynchronous i/o. Waits for an aio
operation to complete. */

ibool
os_aio_posix_handle(
/*================*/
				/* out: TRUE if the aio operation succeeded */
	ulint	array_no,	/* in: array number 0 - 3 */
unknown's avatar
unknown committed
646
	fil_node_t**message1,	/* out: the messages passed with the aio
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
				request; note that also in the case where
				the aio operation failed, these output
				parameters are valid and can be used to
				restart the operation, for example */
	void**	message2);
#endif
/**************************************************************************
Does simulated aio. This function should be called by an i/o-handler
thread. */

ibool
os_aio_simulated_handle(
/*====================*/
				/* out: TRUE if the aio operation succeeded */
	ulint	segment,	/* in: the number of the segment in the aio
				arrays to wait for; segment 0 is the ibuf
				i/o thread, segment 1 the log i/o thread,
				then follow the non-ibuf read threads, and as
				the last are the non-ibuf write threads */
unknown's avatar
unknown committed
666
	fil_node_t**message1,	/* out: the messages passed with the aio
667 668 669 670
				request; note that also in the case where
				the aio operation failed, these output
				parameters are valid and can be used to
				restart the operation, for example */
671 672
	void**	message2,
	ulint*	type);		/* out: OS_FILE_WRITE or ..._READ */
673 674 675 676 677 678 679 680 681 682 683
/**************************************************************************
Validates the consistency of the aio system. */

ibool
os_aio_validate(void);
/*=================*/
				/* out: TRUE if ok */
/**************************************************************************
Prints info of the aio arrays. */

void
unknown's avatar
unknown committed
684 685
os_aio_print(
/*=========*/
686
	FILE*	file);	/* in: file where to print */
687
/**************************************************************************
unknown's avatar
unknown committed
688 689 690 691 692
Refreshes the statistics used to print per-second averages. */

void
os_aio_refresh_stats(void);
/*======================*/
unknown's avatar
unknown committed
693 694

#ifdef UNIV_DEBUG
unknown's avatar
unknown committed
695
/**************************************************************************
696 697 698 699 700 701
Checks that all slots in the system have been freed, that is, there are
no pending io operations. */

ibool
os_aio_all_slots_free(void);
/*=======================*/
unknown's avatar
unknown committed
702
#endif /* UNIV_DEBUG */
703 704 705 706 707 708 709 710 711 712

/***********************************************************************
This function returns information about the specified file */
ibool
os_file_get_status(
/*===============*/
					/* out: TRUE if stat information found */
	const char*     path,		/* in:  pathname of the file */
	os_file_stat_t* stat_info);	/* information of a file in a directory */

713
#endif