fil0fil.h 25.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/******************************************************
The low-level file system

(c) 1995 Innobase Oy

Created 10/25/1995 Heikki Tuuri
*******************************************************/

#ifndef fil0fil_h
#define fil0fil_h

#include "univ.i"
#include "sync0rw.h"
#include "dict0types.h"
#include "ibuf0types.h"
#include "ut0byte.h"
#include "os0file.h"

unknown's avatar
unknown committed
19 20 21
/* When mysqld is run, the default directory "." is the mysqld datadir, but in
ibbackup we must set it explicitly; the patgh must NOT contain the trailing
'/' or '\' */
unknown's avatar
unknown committed
22
extern const char*	fil_path_to_mysql_datadir;
unknown's avatar
unknown committed
23 24 25 26

/* Initial size of a single-table tablespace in pages */
#define FIL_IBD_FILE_INITIAL_SIZE	4

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
/* 'null' (undefined) page offset in the context of file spaces */
#define	FIL_NULL	ULINT32_UNDEFINED

/* Space address data type; this is intended to be used when
addresses accurate to a byte are stored in file pages. If the page part
of the address is FIL_NULL, the address is considered undefined. */

typedef	byte	fil_faddr_t;	/* 'type' definition in C: an address
				stored in a file page is a string of bytes */
#define FIL_ADDR_PAGE	0	/* first in address is the page offset */
#define	FIL_ADDR_BYTE	4	/* then comes 2-byte byte offset within page*/

#define	FIL_ADDR_SIZE	6	/* address size is 6 bytes */

/* A struct for storing a space address FIL_ADDR, when it is used
in C program data structures. */

typedef struct fil_addr_struct	fil_addr_t;
struct fil_addr_struct{
	ulint	page;		/* page number within a space */
	ulint	boffset;	/* byte offset within the page */
};

/* Null file address */
extern fil_addr_t	fil_addr_null;

/* The byte offsets on a file page for various variables */
unknown's avatar
unknown committed
54 55 56 57
#define FIL_PAGE_SPACE_OR_CHKSUM 0	/* in < MySQL-4.0.14 space id the
					page belongs to (== 0) but in later
					versions the 'new' checksum of the
					page */
58 59 60 61 62 63 64 65 66 67 68 69 70
#define FIL_PAGE_OFFSET		4	/* page offset inside space */
#define FIL_PAGE_PREV		8	/* if there is a 'natural' predecessor
					of the page, its offset */
#define FIL_PAGE_NEXT		12	/* if there is a 'natural' successor
					of the page, its offset */
#define FIL_PAGE_LSN		16	/* lsn of the end of the newest
					modification log record to the page */
#define	FIL_PAGE_TYPE		24	/* file page type: FIL_PAGE_INDEX,...,
					2 bytes */
#define FIL_PAGE_FILE_FLUSH_LSN	26	/* this is only defined for the
					first page in a data file: the file
					has been flushed to disk at least up
					to this lsn */
unknown's avatar
unknown committed
71 72
#define FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID  34 /* starting from 4.1.x this
					contains the space id of the page */
73 74 75
#define FIL_PAGE_DATA		38	/* start of the data on the page */

/* File page trailer */
unknown's avatar
unknown committed
76
#define FIL_PAGE_END_LSN_OLD_CHKSUM 8	/* the low 4 bytes of this are used
unknown's avatar
unknown committed
77 78 79
					to store the page checksum, the
					last 4 bytes should be identical
					to the last 4 bytes of FIL_PAGE_LSN */
80 81 82 83 84
#define FIL_PAGE_DATA_END	8

/* File page types */
#define FIL_PAGE_INDEX		17855
#define FIL_PAGE_UNDO_LOG	2
unknown's avatar
unknown committed
85 86
#define FIL_PAGE_INODE		3
#define FIL_PAGE_IBUF_FREE_LIST	4
87 88 89 90 91

/* Space types */
#define FIL_TABLESPACE 		501
#define FIL_LOG			502

92 93
extern ulint	fil_n_log_flushes;

94 95 96
extern ulint	fil_n_pending_log_flushes;
extern ulint	fil_n_pending_tablespace_flushes;

unknown's avatar
unknown committed
97

98
/***********************************************************************
unknown's avatar
unknown committed
99
Returns the version number of a tablespace, -1 if not found. */
100

unknown's avatar
unknown committed
101 102 103 104 105 106
ib_longlong
fil_space_get_version(
/*==================*/
			/* out: version number, -1 if the tablespace does not
			exist in the memory cache */
	ulint	id);	/* in: space id */
107
/***********************************************************************
unknown's avatar
unknown committed
108
Returns the latch of a file space. */
109

unknown's avatar
unknown committed
110 111 112 113 114 115 116
rw_lock_t*
fil_space_get_latch(
/*================*/
			/* out: latch protecting storage allocation */
	ulint	id);	/* in: space id */
/***********************************************************************
Returns the type of a file space. */
117

unknown's avatar
unknown committed
118 119 120 121 122 123 124
ulint
fil_space_get_type(
/*===============*/
			/* out: FIL_TABLESPACE or FIL_LOG */
	ulint	id);	/* in: space id */
/***********************************************************************
Returns the ibuf data of a file space. */
125

unknown's avatar
unknown committed
126 127 128 129 130
ibuf_data_t*
fil_space_get_ibuf_data(
/*====================*/
			/* out: ibuf data for this space */
	ulint	id);	/* in: space id */
131
/***********************************************************************
unknown's avatar
unknown committed
132
Appends a new file to the chain of files of a space. File must be closed. */
133 134

void
unknown's avatar
unknown committed
135 136
fil_node_create(
/*============*/
137 138 139 140 141 142
	const char*	name,	/* in: file name (file must be closed) */
	ulint		size,	/* in: file size in database blocks, rounded
				downwards to an integer */
	ulint		id,	/* in: space id where to append */
	ibool		is_raw);/* in: TRUE if a raw device or
				a raw disk partition */
143 144 145 146 147 148 149 150 151 152 153
/********************************************************************
Drops files from the start of a file space, so that its size is cut by
the amount given. */

void
fil_space_truncate_start(
/*=====================*/
	ulint	id,		/* in: space id */
	ulint	trunc_len);	/* in: truncate by this much; it is an error
				if this does not equal to the combined size of
				some initial files in the space */
unknown's avatar
unknown committed
154 155 156
/***********************************************************************
Creates a space memory object and puts it to the 'fil system' hash table. If
there is an error, prints an error message to the .err log. */
unknown's avatar
unknown committed
157 158

ibool
unknown's avatar
unknown committed
159 160
fil_space_create(
/*=============*/
161 162 163 164
				/* out: TRUE if success */
	const char*	name,	/* in: space name */
	ulint		id,	/* in: space id */
	ulint		purpose);/* in: FIL_TABLESPACE, or FIL_LOG if log */
165
/***********************************************************************
unknown's avatar
unknown committed
166 167
Frees a space object from a the tablespace memory cache. Closes the files in
the chain but does not delete them. */
168

unknown's avatar
unknown committed
169
ibool
170 171
fil_space_free(
/*===========*/
unknown's avatar
unknown committed
172
			/* out: TRUE if success */
173 174
	ulint	id);	/* in: space id */
/***********************************************************************
unknown's avatar
unknown committed
175 176
Returns the size of the space in pages. The tablespace must be cached in the
memory cache. */
177 178

ulint
unknown's avatar
unknown committed
179
fil_space_get_size(
180
/*===============*/
unknown's avatar
unknown committed
181
			/* out: space size, 0 if space not found */
182
	ulint	id);	/* in: space id */
unknown's avatar
unknown committed
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
/***********************************************************************
Checks if the pair space, page_no refers to an existing page in a tablespace
file space. The tablespace must be cached in the memory cache. */

ibool
fil_check_adress_in_tablespace(
/*===========================*/
			/* out: TRUE if the address is meaningful */
	ulint	id,	/* in: space id */
	ulint	page_no);/* in: page number */
/********************************************************************
Initializes the tablespace memory cache. */

void
fil_init(
/*=====*/
	ulint	max_n_open);	/* in: max number of open files */
/***********************************************************************
Opens all log files and system tablespace data files. They stay open until the
database server shutdown. This should be called at a server startup after the
space objects for the log and the system tablespace have been created. The
purpose of this operation is to make sure we never run out of file descriptors
if we need to read from the insert buffer or to write to the log. */

void
fil_open_log_and_system_tablespace_files(void);
/*==========================================*/
/***********************************************************************
Closes all open files. There must not be any pending i/o's or not flushed
modifications in the files. */

void
fil_close_all_files(void);
/*=====================*/
/***********************************************************************
Sets the max tablespace id counter if the given number is bigger than the
previous value. */

void
fil_set_max_space_id_if_bigger(
/*===========================*/
	ulint	max_id);/* in: maximum known id */
/********************************************************************
Initializes the ibuf data structure for space 0 == the system tablespace.
This can be called after the file space headers have been created and the
dictionary system has been initialized. */

void
fil_ibuf_init_at_db_start(void);
/*===========================*/
233 234
/********************************************************************
Writes the flushed lsn and the latest archived log number to the page
unknown's avatar
unknown committed
235
header of the first page of each data file in the system tablespace. */
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252

ulint
fil_write_flushed_lsn_to_data_files(
/*================================*/
				/* out: DB_SUCCESS or error number */
	dulint	lsn,		/* in: lsn to write */
	ulint	arch_log_no);	/* in: latest archived log file number */
/***********************************************************************
Reads the flushed lsn and arch no fields from a data file at database
startup. */

void
fil_read_flushed_lsn_and_arch_log_no(
/*=================================*/
	os_file_t data_file,		/* in: open data file */
	ibool	one_read_already,	/* in: TRUE if min and max parameters
					below already contain sensible data */
unknown's avatar
unknown committed
253
#ifdef UNIV_LOG_ARCHIVE
254
	ulint*	min_arch_log_no,	/* in/out: */
unknown's avatar
unknown committed
255 256 257 258
	ulint*	max_arch_log_no,	/* in/out: */
#endif /* UNIV_LOG_ARCHIVE */
	dulint*	min_flushed_lsn,	/* in/out: */
	dulint*	max_flushed_lsn);	/* in/out: */
259
/***********************************************************************
unknown's avatar
unknown committed
260 261
Increments the count of pending insert buffer page merges, if space is not
being deleted. */
262

unknown's avatar
unknown committed
263 264 265 266 267 268 269 270 271 272 273 274
ibool
fil_inc_pending_ibuf_merges(
/*========================*/
			/* out: TRUE if being deleted, and ibuf merges should
			be skipped */
	ulint	id);	/* in: space id */
/***********************************************************************
Decrements the count of pending insert buffer page merges. */

void
fil_decr_pending_ibuf_merges(
/*========================*/
275 276
	ulint	id);	/* in: space id */
/***********************************************************************
unknown's avatar
unknown committed
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
Parses the body of a log record written about an .ibd file operation. That is,
the log record part after the standard (type, space id, page no) header of the
log record.

If desired, also replays the delete or rename operation if the .ibd file
exists and the space id in it matches. Replays the create operation if a file
at that path does not exist yet. If the database directory for the file to be
created does not exist, then we create the directory, too.

Note that ibbackup --apply-log sets fil_path_to_mysql_datadir to point to the
datadir that we should use in replaying the file operations. */

byte*
fil_op_log_parse_or_replay(
/*=======================*/
                        	/* out: end of log record, or NULL if the
				record was not completely contained between
				ptr and end_ptr */
        byte*   ptr,    	/* in: buffer containing the log record body,
				or an initial segment of it, if the record does
				not fir completely between ptr and end_ptr */
        byte*   end_ptr,	/* in: buffer end */
	ulint	type,		/* in: the type of this log record */
	ibool	do_replay,	/* in: TRUE if we want to replay the
				operation, and not just parse the log record */
	ulint	space_id);	/* in: if do_replay is TRUE, the space id of
				the tablespace in question; otherwise
				ignored */
/***********************************************************************
unknown's avatar
unknown committed
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
Deletes a single-table tablespace. The tablespace must be cached in the
memory cache. */

ibool
fil_delete_tablespace(
/*==================*/
			/* out: TRUE if success */
	ulint	id);	/* in: space id */
/***********************************************************************
Discards a single-table tablespace. The tablespace must be cached in the
memory cache. Discarding is like deleting a tablespace, but
1) we do not drop the table from the data dictionary;
2) we remove all insert buffer entries for the tablespace immediately; in DROP
TABLE they are only removed gradually in the background;
3) when the user does IMPORT TABLESPACE, the tablespace will have the same id
as it originally had. */

ibool
fil_discard_tablespace(
/*===================*/
			/* out: TRUE if success */
	ulint	id);	/* in: space id */
/***********************************************************************
Renames a single-table tablespace. The tablespace must be cached in the
tablespace memory cache. */

ibool
fil_rename_tablespace(
/*==================*/
335 336 337 338 339 340 341 342 343
					/* out: TRUE if success */
	const char*	old_name,	/* in: old table name in the standard
					databasename/tablename format of
					InnoDB, or NULL if we do the rename
					based on the space id only */
	ulint		id,		/* in: space id */
	const char*	new_name);	/* in: new table name in the standard
					databasename/tablename format
					of InnoDB */
unknown's avatar
unknown committed
344

unknown's avatar
unknown committed
345 346 347 348
/***********************************************************************
Creates a new single-table tablespace to a database directory of MySQL.
Database directories are under the 'datadir' of MySQL. The datadir is the
directory of a running mysqld program. We can refer to it by simply the
unknown's avatar
unknown committed
349 350
path '.'. Tables created with CREATE TEMPORARY TABLE we place in the temp
dir of the mysqld server. */
351 352

ulint
unknown's avatar
unknown committed
353 354
fil_create_new_single_table_tablespace(
/*===================================*/
355 356 357 358 359 360
					/* out: DB_SUCCESS or error code */
	ulint*		space_id,	/* in/out: space id; if this is != 0,
					then this is an input parameter,
					otherwise output */
	const char*	tablename,	/* in: the table name in the usual
					databasename/tablename format
unknown's avatar
unknown committed
361 362 363 364
					of InnoDB, or a dir path to a temp
					table */
	ibool		is_temp,	/* in: TRUE if a table created with
					CREATE TEMPORARY TABLE */
365 366 367
	ulint		size);		/* in: the initial size of the
					tablespace file in pages,
					must be >= FIL_IBD_FILE_INITIAL_SIZE */
unknown's avatar
unknown committed
368 369 370 371
/************************************************************************
Tries to open a single-table tablespace and checks the space id is right in
it. If does not succeed, prints an error message to the .err log. This
function is used to open the tablespace when we load a table definition
unknown's avatar
unknown committed
372
to the dictionary cache. NOTE that we assume this operation is used under the
unknown's avatar
unknown committed
373 374 375 376 377
protection of the dictionary mutex, so that two users cannot race here. */

ibool
fil_open_single_table_tablespace(
/*=============================*/
378 379 380 381
				/* out: TRUE if success */
	ulint		id,	/* in: space id */
	const char*	name);	/* in: table name in the
				databasename/tablename format */
unknown's avatar
unknown committed
382
/************************************************************************
383 384 385 386 387 388 389 390 391 392 393 394
It is possible, though very improbable, that the lsn's in the tablespace to be
imported have risen above the current system lsn, if a lengthy purge, ibuf
merge, or rollback was performed on a backup taken with ibbackup. If that is
the case, reset page lsn's in the file. We assume that mysqld was shut down
after it performed these cleanup operations on the .ibd file, so that it at
the shutdown stamped the latest lsn to the FIL_PAGE_FILE_FLUSH_LSN in the
first page of the .ibd file, and we can determine whether we need to reset the
lsn's just by looking at that flush lsn. */

ibool
fil_reset_too_high_lsns(
/*====================*/
395 396 397 398 399 400
					/* out: TRUE if success */
	const char*	name,		/* in: table name in the
					databasename/tablename format */
	dulint		current_lsn);	/* in: reset lsn's if the lsn stamped
					to FIL_PAGE_FILE_FLUSH_LSN in the
					first page is too high */
401
/************************************************************************
unknown's avatar
unknown committed
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
At the server startup, if we need crash recovery, scans the database
directories under the MySQL datadir, looking for .ibd files. Those files are
single-table tablespaces. We need to know the space id in each of them so that
we know into which file we should look to check the contents of a page stored
in the doublewrite buffer, also to know where to apply log records where the
space id is != 0. */

ulint
fil_load_single_table_tablespaces(void);
/*===================================*/
			/* out: DB_SUCCESS or error number */
/************************************************************************
If we need crash recovery, and we have called
fil_load_single_table_tablespaces() and dict_load_single_table_tablespaces(),
we can call this function to print an error message of orphaned .ibd files
for which there is not a data dictionary entry with a matching table name
and space id. */

void
fil_print_orphaned_tablespaces(void);
/*================================*/
/***********************************************************************
Returns TRUE if a single-table tablespace does not exist in the memory cache,
or is being deleted there. */

ibool
fil_tablespace_deleted_or_being_deleted_in_mem(
/*===========================================*/
				/* out: TRUE if does not exist or is being\
				deleted */
	ulint		id,	/* in: space id */
	ib_longlong	version);/* in: tablespace_version should be this; if
				you pass -1 as the value of this, then this
				parameter is ignored */
/***********************************************************************
Returns TRUE if a single-table tablespace exists in the memory cache. */

ibool
fil_tablespace_exists_in_mem(
/*=========================*/
			/* out: TRUE if exists */
443 444
	ulint	id);	/* in: space id */
/***********************************************************************
unknown's avatar
unknown committed
445 446 447
Returns TRUE if a matching tablespace exists in the InnoDB tablespace memory
cache. Note that if we have not done a crash recovery at the database startup,
there may be many tablespaces which are not yet in the memory cache. */
448 449

ibool
unknown's avatar
unknown committed
450 451
fil_space_for_table_exists_in_mem(
/*==============================*/
452 453 454 455
					/* out: TRUE if a matching tablespace
					exists in the memory cache */
	ulint		id,		/* in: space id */
	const char*	name,		/* in: table name in the standard
unknown's avatar
unknown committed
456 457 458 459
					'databasename/tablename' format or
					the dir path to a temp table */
	ibool		is_temp,	/* in: TRUE if created with CREATE
					TEMPORARY TABLE */
460 461 462 463 464 465 466 467 468 469 470
	ibool		mark_space,	/* in: in crash recovery, at database
					startup we mark all spaces which have
					an associated table in the InnoDB
					data dictionary, so that
					we can print a warning about orphaned
					tablespaces */
	ibool		print_error_if_does_not_exist);
					/* in: print detailed error
					information to the .err log if a
					matching tablespace is not found from
					memory */
unknown's avatar
unknown committed
471 472
/**************************************************************************
Tries to extend a data file so that it would accommodate the number of pages
unknown's avatar
unknown committed
473 474
given. The tablespace must be cached in the memory cache. If the space is big
enough already, does nothing. */
unknown's avatar
unknown committed
475 476

ibool
unknown's avatar
unknown committed
477 478
fil_extend_space_to_desired_size(
/*=============================*/
unknown's avatar
unknown committed
479
				/* out: TRUE if success */
unknown's avatar
unknown committed
480 481 482
	ulint*	actual_size,	/* out: size of the space after extension;
				if we ran out of disk space this may be lower
				than the desired size */
unknown's avatar
unknown committed
483 484
	ulint	space_id,	/* in: space id, must be != 0 */
	ulint	size_after_extend);/* in: desired size in pages after the
unknown's avatar
unknown committed
485 486 487 488 489 490 491 492 493 494 495 496 497
				extension; if the current space size is bigger
				than this already, the function does nothing */
#ifdef UNIV_HOTBACKUP
/************************************************************************
Extends all tablespaces to the size stored in the space header. During the
ibbackup --apply-log phase we extended the spaces on-demand so that log records
could be appllied, but that may have left spaces still too small compared to
the size stored in the space header. */

void
fil_extend_tablespaces_to_stored_len(void);
/*======================================*/
#endif
unknown's avatar
unknown committed
498 499 500 501 502
/***********************************************************************
Tries to reserve free extents in a file space. */

ibool
fil_space_reserve_free_extents(
503
/*===========================*/
unknown's avatar
unknown committed
504 505 506 507
				/* out: TRUE if succeed */
	ulint	id,		/* in: space id */
	ulint	n_free_now,	/* in: number of free extents now */
	ulint	n_to_reserve);	/* in: how many one wants to reserve */
508
/***********************************************************************
unknown's avatar
unknown committed
509
Releases free extents in a file space. */
510 511

void
unknown's avatar
unknown committed
512 513 514 515 516 517 518 519 520 521 522 523
fil_space_release_free_extents(
/*===========================*/
	ulint	id,		/* in: space id */
	ulint	n_reserved);	/* in: how many one reserved */
/***********************************************************************
Gets the number of reserved extents. If the database is silent, this number
should be zero. */

ulint
fil_space_get_n_reserved_extents(
/*=============================*/
	ulint	id);		/* in: space id */
524 525 526
/************************************************************************
Reads or writes data. This operation is asynchronous (aio). */

unknown's avatar
unknown committed
527
ulint
528 529
fil_io(
/*===*/
unknown's avatar
unknown committed
530 531 532
				/* out: DB_SUCCESS, or DB_TABLESPACE_DELETED
				if we are trying to do i/o on a tablespace
				which does not exist */
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
	ulint	type,		/* in: OS_FILE_READ or OS_FILE_WRITE,
				ORed to OS_FILE_LOG, if a log i/o
				and ORed to OS_AIO_SIMULATED_WAKE_LATER
				if simulated aio and we want to post a
				batch of i/os; 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! */
	ibool	sync,		/* in: TRUE if synchronous aio is desired */
	ulint	space_id,	/* in: space id */
	ulint	block_offset,	/* in: offset in number of blocks */
	ulint	byte_offset,	/* in: remainder of offset in bytes; in
				aio this must be divisible by the OS block
				size */
unknown's avatar
unknown committed
548 549 550
	ulint	len,		/* in: how many bytes to read or write; this
				must not cross a file boundary; in aio this
				must be a block size multiple */
551 552 553 554 555 556 557
	void*	buf,		/* in/out: buffer where to store read data
				or from where to write; in aio this must be
				appropriately aligned */
	void*	message);	/* in: message for aio handler if non-sync
				aio used, else ignored */
/************************************************************************
Reads data from a space to a buffer. Remember that the possible incomplete
unknown's avatar
unknown committed
558
blocks at the end of file are ignored: they are not taken into account when
559 560
calculating the byte offset within a space. */

unknown's avatar
unknown committed
561
ulint
562 563
fil_read(
/*=====*/
unknown's avatar
unknown committed
564 565 566
				/* out: DB_SUCCESS, or DB_TABLESPACE_DELETED
				if we are trying to do i/o on a tablespace
				which does not exist */
567 568 569 570 571 572 573 574 575 576 577 578 579 580
	ibool	sync,		/* in: TRUE if synchronous aio is desired */
	ulint	space_id,	/* in: space id */
	ulint	block_offset,	/* in: offset in number of blocks */
	ulint	byte_offset,	/* in: remainder of offset in bytes; in aio
				this must be divisible by the OS block size */
	ulint	len,		/* in: how many bytes to read; this must not
				cross a file boundary; in aio this must be a
				block size multiple */
	void*	buf,		/* in/out: buffer where to store data read;
				in aio this must be appropriately aligned */
	void*	message);	/* in: message for aio handler if non-sync
				aio used, else ignored */
/************************************************************************
Writes data to a space from a buffer. Remember that the possible incomplete
unknown's avatar
unknown committed
581
blocks at the end of file are ignored: they are not taken into account when
582 583
calculating the byte offset within a space. */

unknown's avatar
unknown committed
584
ulint
585 586
fil_write(
/*======*/
unknown's avatar
unknown committed
587 588 589
				/* out: DB_SUCCESS, or DB_TABLESPACE_DELETED
				if we are trying to do i/o on a tablespace
				which does not exist */
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
	ibool	sync,		/* in: TRUE if synchronous aio is desired */
	ulint	space_id,	/* in: space id */
	ulint	block_offset,	/* in: offset in number of blocks */
	ulint	byte_offset,	/* in: remainder of offset in bytes; in aio
				this must be divisible by the OS block size */
	ulint	len,		/* in: how many bytes to write; this must
				not cross a file boundary; in aio this must
				be a block size multiple */
	void*	buf,		/* in: buffer from which to write; in aio
				this must be appropriately aligned */
	void*	message);	/* in: message for aio handler if non-sync
				aio used, else ignored */
/**************************************************************************
Waits for an aio operation to complete. This function is used to write the
handler for completed requests. The aio array of pending requests is divided
into segments (see os0file.c for more info). The thread specifies which
segment it wants to wait for. */

void
fil_aio_wait(
/*=========*/
	ulint	segment);	/* in: the number of the segment in the aio
				array to wait for */ 
/**************************************************************************
unknown's avatar
unknown committed
614 615
Flushes to disk possible writes cached by the OS. If the space does not exist
or is being dropped, does not do anything. */
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630

void
fil_flush(
/*======*/
	ulint	space_id);	/* in: file space id (this can be a group of
				log files or a tablespace of the database) */
/**************************************************************************
Flushes to disk writes in file spaces of the given type possibly cached by
the OS. */

void
fil_flush_file_spaces(
/*==================*/
	ulint	purpose);	/* in: FIL_TABLESPACE, FIL_LOG */
/**********************************************************************
unknown's avatar
unknown committed
631
Checks the consistency of the tablespace cache. */
632 633 634 635 636 637

ibool
fil_validate(void);
/*==============*/
			/* out: TRUE if ok */
/************************************************************************
unknown's avatar
unknown committed
638 639 640 641 642 643 644 645
Returns TRUE if file address is undefined. */

ibool
fil_addr_is_null(
/*=============*/
				/* out: TRUE if undefined */
	fil_addr_t	addr);	/* in: address */
/************************************************************************
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673
Accessor functions for a file page */

ulint
fil_page_get_prev(byte*	page);
ulint
fil_page_get_next(byte*	page);
/*************************************************************************
Sets the file page type. */

void
fil_page_set_type(
/*==============*/
	byte* 	page,	/* in: file page */
	ulint	type);	/* in: type */
/*************************************************************************
Gets the file page type. */

ulint
fil_page_get_type(
/*==============*/
			/* out: type; NOTE that if the type has not been
			written to page, the return value not defined */
	byte* 	page);	/* in: file page */


typedef	struct fil_space_struct	fil_space_t;

#endif