← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/fil0fil.h

  • Committer: Brian Aker
  • Date: 2008-10-28 08:36:02 UTC
  • mfrom: (520.4.13 merge-innodb-plugin)
  • Revision ID: brian@tangent.org-20081028083602-0p3zzlhlxr5q2sqo
Merging Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/fil0fil.h
117
117
#define FIL_PAGE_TYPE_FSP_HDR   8       /* File space header */
118
118
#define FIL_PAGE_TYPE_XDES      9       /* Extent descriptor page */
119
119
#define FIL_PAGE_TYPE_BLOB      10      /* Uncompressed BLOB page */
 
120
#define FIL_PAGE_TYPE_ZBLOB     11      /* First compressed BLOB page */
 
121
#define FIL_PAGE_TYPE_ZBLOB2    12      /* Subsequent compressed BLOB page */
120
122
 
121
123
/* Space types */
122
124
#define FIL_TABLESPACE          501
130
132
 
131
133
/***********************************************************************
132
134
Returns the version number of a tablespace, -1 if not found. */
133
 
 
134
 
ib_longlong
 
135
UNIV_INTERN
 
136
ib_int64_t
135
137
fil_space_get_version(
136
138
/*==================*/
137
139
                        /* out: version number, -1 if the tablespace does not
139
141
        ulint   id);    /* in: space id */
140
142
/***********************************************************************
141
143
Returns the latch of a file space. */
142
 
 
 
144
UNIV_INTERN
143
145
rw_lock_t*
144
146
fil_space_get_latch(
145
147
/*================*/
146
148
                        /* out: latch protecting storage allocation */
147
 
        ulint   id);    /* in: space id */
 
149
        ulint   id,     /* in: space id */
 
150
        ulint*  zip_size);/* out: compressed page size, or
 
151
                        0 for uncompressed tablespaces */
148
152
/***********************************************************************
149
153
Returns the type of a file space. */
150
 
 
 
154
UNIV_INTERN
151
155
ulint
152
156
fil_space_get_type(
153
157
/*===============*/
155
159
        ulint   id);    /* in: space id */
156
160
/***********************************************************************
157
161
Returns the ibuf data of a file space. */
158
 
 
 
162
UNIV_INTERN
159
163
ibuf_data_t*
160
164
fil_space_get_ibuf_data(
161
165
/*====================*/
163
167
        ulint   id);    /* in: space id */
164
168
/***********************************************************************
165
169
Appends a new file to the chain of files of a space. File must be closed. */
166
 
 
 
170
UNIV_INTERN
167
171
void
168
172
fil_node_create(
169
173
/*============*/
173
177
        ulint           id,     /* in: space id where to append */
174
178
        ibool           is_raw);/* in: TRUE if a raw device or
175
179
                                a raw disk partition */
 
180
#ifdef UNIV_LOG_ARCHIVE
176
181
/********************************************************************
177
182
Drops files from the start of a file space, so that its size is cut by
178
183
the amount given. */
179
 
 
 
184
UNIV_INTERN
180
185
void
181
186
fil_space_truncate_start(
182
187
/*=====================*/
184
189
        ulint   trunc_len);     /* in: truncate by this much; it is an error
185
190
                                if this does not equal to the combined size of
186
191
                                some initial files in the space */
 
192
#endif /* UNIV_LOG_ARCHIVE */
187
193
/***********************************************************************
188
194
Creates a space memory object and puts it to the 'fil system' hash table. If
189
195
there is an error, prints an error message to the .err log. */
190
 
 
 
196
UNIV_INTERN
191
197
ibool
192
198
fil_space_create(
193
199
/*=============*/
194
200
                                /* out: TRUE if success */
195
201
        const char*     name,   /* in: space name */
196
202
        ulint           id,     /* in: space id */
 
203
        ulint           zip_size,/* in: compressed page size, or
 
204
                                0 for uncompressed tablespaces */
197
205
        ulint           purpose);/* in: FIL_TABLESPACE, or FIL_LOG if log */
198
206
/***********************************************************************
199
207
Frees a space object from a the tablespace memory cache. Closes the files in
200
208
the chain but does not delete them. */
201
 
 
 
209
UNIV_INTERN
202
210
ibool
203
211
fil_space_free(
204
212
/*===========*/
207
215
/***********************************************************************
208
216
Returns the size of the space in pages. The tablespace must be cached in the
209
217
memory cache. */
210
 
 
 
218
UNIV_INTERN
211
219
ulint
212
220
fil_space_get_size(
213
221
/*===============*/
214
222
                        /* out: space size, 0 if space not found */
215
223
        ulint   id);    /* in: space id */
216
224
/***********************************************************************
 
225
Returns the flags of the space. The tablespace must be cached
 
226
in the memory cache. */
 
227
UNIV_INTERN
 
228
ulint
 
229
fil_space_get_flags(
 
230
/*================*/
 
231
                        /* out: flags, ULINT_UNDEFINED if space not found */
 
232
        ulint   id);    /* in: space id */
 
233
/***********************************************************************
 
234
Returns the compressed page size of the space, or 0 if the space
 
235
is not compressed. The tablespace must be cached in the memory cache. */
 
236
UNIV_INTERN
 
237
ulint
 
238
fil_space_get_zip_size(
 
239
/*===================*/
 
240
                        /* out: compressed page size, ULINT_UNDEFINED
 
241
                        if space not found */
 
242
        ulint   id);    /* in: space id */
 
243
/***********************************************************************
217
244
Checks if the pair space, page_no refers to an existing page in a tablespace
218
245
file space. The tablespace must be cached in the memory cache. */
219
 
 
 
246
UNIV_INTERN
220
247
ibool
221
248
fil_check_adress_in_tablespace(
222
249
/*===========================*/
225
252
        ulint   page_no);/* in: page number */
226
253
/********************************************************************
227
254
Initializes the tablespace memory cache. */
228
 
 
 
255
UNIV_INTERN
229
256
void
230
257
fil_init(
231
258
/*=====*/
236
263
space objects for the log and the system tablespace have been created. The
237
264
purpose of this operation is to make sure we never run out of file descriptors
238
265
if we need to read from the insert buffer or to write to the log. */
239
 
 
 
266
UNIV_INTERN
240
267
void
241
268
fil_open_log_and_system_tablespace_files(void);
242
269
/*==========================================*/
243
270
/***********************************************************************
244
271
Closes all open files. There must not be any pending i/o's or not flushed
245
272
modifications in the files. */
246
 
 
 
273
UNIV_INTERN
247
274
void
248
275
fil_close_all_files(void);
249
276
/*=====================*/
250
277
/***********************************************************************
251
278
Sets the max tablespace id counter if the given number is bigger than the
252
279
previous value. */
253
 
 
 
280
UNIV_INTERN
254
281
void
255
282
fil_set_max_space_id_if_bigger(
256
283
/*===========================*/
259
286
Initializes the ibuf data structure for space 0 == the system tablespace.
260
287
This can be called after the file space headers have been created and the
261
288
dictionary system has been initialized. */
262
 
 
 
289
UNIV_INTERN
263
290
void
264
291
fil_ibuf_init_at_db_start(void);
265
292
/*===========================*/
266
293
/********************************************************************
267
294
Writes the flushed lsn and the latest archived log number to the page
268
295
header of the first page of each data file in the system tablespace. */
269
 
 
 
296
UNIV_INTERN
270
297
ulint
271
298
fil_write_flushed_lsn_to_data_files(
272
299
/*================================*/
273
 
                                /* out: DB_SUCCESS or error number */
274
 
        dulint  lsn,            /* in: lsn to write */
275
 
        ulint   arch_log_no);   /* in: latest archived log file number */
 
300
                                        /* out: DB_SUCCESS or error number */
 
301
        ib_uint64_t     lsn,            /* in: lsn to write */
 
302
        ulint           arch_log_no);   /* in: latest archived log
 
303
                                        file number */
276
304
/***********************************************************************
277
305
Reads the flushed lsn and arch no fields from a data file at database
278
306
startup. */
279
 
 
 
307
UNIV_INTERN
280
308
void
281
309
fil_read_flushed_lsn_and_arch_log_no(
282
310
/*=================================*/
283
 
        os_file_t data_file,            /* in: open data file */
284
 
        ibool   one_read_already,       /* in: TRUE if min and max parameters
285
 
                                        below already contain sensible data */
 
311
        os_file_t       data_file,              /* in: open data file */
 
312
        ibool           one_read_already,       /* in: TRUE if min and max
 
313
                                                parameters below already
 
314
                                                contain sensible data */
286
315
#ifdef UNIV_LOG_ARCHIVE
287
 
        ulint*  min_arch_log_no,        /* in/out: */
288
 
        ulint*  max_arch_log_no,        /* in/out: */
 
316
        ulint*          min_arch_log_no,        /* in/out: */
 
317
        ulint*          max_arch_log_no,        /* in/out: */
289
318
#endif /* UNIV_LOG_ARCHIVE */
290
 
        dulint* min_flushed_lsn,        /* in/out: */
291
 
        dulint* max_flushed_lsn);       /* in/out: */
 
319
        ib_uint64_t*    min_flushed_lsn,        /* in/out: */
 
320
        ib_uint64_t*    max_flushed_lsn);       /* in/out: */
292
321
/***********************************************************************
293
322
Increments the count of pending insert buffer page merges, if space is not
294
323
being deleted. */
295
 
 
 
324
UNIV_INTERN
296
325
ibool
297
326
fil_inc_pending_ibuf_merges(
298
327
/*========================*/
301
330
        ulint   id);    /* in: space id */
302
331
/***********************************************************************
303
332
Decrements the count of pending insert buffer page merges. */
304
 
 
 
333
UNIV_INTERN
305
334
void
306
335
fil_decr_pending_ibuf_merges(
307
336
/*=========================*/
318
347
 
319
348
Note that ibbackup --apply-log sets fil_path_to_mysql_datadir to point to the
320
349
datadir that we should use in replaying the file operations. */
321
 
 
 
350
UNIV_INTERN
322
351
byte*
323
352
fil_op_log_parse_or_replay(
324
353
/*=======================*/
330
359
                                not fir completely between ptr and end_ptr */
331
360
        byte*   end_ptr,        /* in: buffer end */
332
361
        ulint   type,           /* in: the type of this log record */
333
 
        ibool   do_replay,      /* in: TRUE if we want to replay the
334
 
                                operation, and not just parse the log record */
335
 
        ulint   space_id);      /* in: if do_replay is TRUE, the space id of
336
 
                                the tablespace in question; otherwise
337
 
                                ignored */
 
362
        ulint   space_id);      /* in: the space id of the tablespace in
 
363
                                question, or 0 if the log record should
 
364
                                only be parsed but not replayed */
338
365
/***********************************************************************
339
366
Deletes a single-table tablespace. The tablespace must be cached in the
340
367
memory cache. */
341
 
 
 
368
UNIV_INTERN
342
369
ibool
343
370
fil_delete_tablespace(
344
371
/*==================*/
352
379
TABLE they are only removed gradually in the background;
353
380
3) when the user does IMPORT TABLESPACE, the tablespace will have the same id
354
381
as it originally had. */
355
 
 
 
382
UNIV_INTERN
356
383
ibool
357
384
fil_discard_tablespace(
358
385
/*===================*/
361
388
/***********************************************************************
362
389
Renames a single-table tablespace. The tablespace must be cached in the
363
390
tablespace memory cache. */
364
 
 
 
391
UNIV_INTERN
365
392
ibool
366
393
fil_rename_tablespace(
367
394
/*==================*/
381
408
directory of a running mysqld program. We can refer to it by simply the
382
409
path '.'. Tables created with CREATE TEMPORARY TABLE we place in the temp
383
410
dir of the mysqld server. */
384
 
 
 
411
UNIV_INTERN
385
412
ulint
386
413
fil_create_new_single_table_tablespace(
387
414
/*===================================*/
395
422
                                        table */
396
423
        ibool           is_temp,        /* in: TRUE if a table created with
397
424
                                        CREATE TEMPORARY TABLE */
 
425
        ulint           flags,          /* in: tablespace flags */
398
426
        ulint           size);          /* in: the initial size of the
399
427
                                        tablespace file in pages,
400
428
                                        must be >= FIL_IBD_FILE_INITIAL_SIZE */
407
435
or under the protection of the dictionary mutex, so that two users cannot
408
436
race here. This operation does not leave the file associated with the
409
437
tablespace open, but closes it after we have looked at the space id in it. */
410
 
 
 
438
UNIV_INTERN
411
439
ibool
412
440
fil_open_single_table_tablespace(
413
441
/*=============================*/
420
448
                                        faster (the OS caches them) than
421
449
                                        accessing the first page of the file */
422
450
        ulint           id,             /* in: space id */
 
451
        ulint           flags,          /* in: tablespace flags */
423
452
        const char*     name);          /* in: table name in the
424
453
                                        databasename/tablename format */
425
454
/************************************************************************
431
460
the shutdown stamped the latest lsn to the FIL_PAGE_FILE_FLUSH_LSN in the
432
461
first page of the .ibd file, and we can determine whether we need to reset the
433
462
lsn's just by looking at that flush lsn. */
434
 
 
 
463
UNIV_INTERN
435
464
ibool
436
465
fil_reset_too_high_lsns(
437
466
/*====================*/
438
467
                                        /* out: TRUE if success */
439
468
        const char*     name,           /* in: table name in the
440
469
                                        databasename/tablename format */
441
 
        dulint          current_lsn);   /* in: reset lsn's if the lsn stamped
 
470
        ib_uint64_t     current_lsn);   /* in: reset lsn's if the lsn stamped
442
471
                                        to FIL_PAGE_FILE_FLUSH_LSN in the
443
472
                                        first page is too high */
444
473
/************************************************************************
448
477
we know into which file we should look to check the contents of a page stored
449
478
in the doublewrite buffer, also to know where to apply log records where the
450
479
space id is != 0. */
451
 
 
 
480
UNIV_INTERN
452
481
ulint
453
482
fil_load_single_table_tablespaces(void);
454
483
/*===================================*/
459
488
we can call this function to print an error message of orphaned .ibd files
460
489
for which there is not a data dictionary entry with a matching table name
461
490
and space id. */
462
 
 
 
491
UNIV_INTERN
463
492
void
464
493
fil_print_orphaned_tablespaces(void);
465
494
/*================================*/
466
495
/***********************************************************************
467
496
Returns TRUE if a single-table tablespace does not exist in the memory cache,
468
497
or is being deleted there. */
469
 
 
 
498
UNIV_INTERN
470
499
ibool
471
500
fil_tablespace_deleted_or_being_deleted_in_mem(
472
501
/*===========================================*/
473
502
                                /* out: TRUE if does not exist or is being\
474
503
                                deleted */
475
504
        ulint           id,     /* in: space id */
476
 
        ib_longlong     version);/* in: tablespace_version should be this; if
 
505
        ib_int64_t      version);/* in: tablespace_version should be this; if
477
506
                                you pass -1 as the value of this, then this
478
507
                                parameter is ignored */
479
508
/***********************************************************************
480
509
Returns TRUE if a single-table tablespace exists in the memory cache. */
481
 
 
 
510
UNIV_INTERN
482
511
ibool
483
512
fil_tablespace_exists_in_mem(
484
513
/*=========================*/
488
517
Returns TRUE if a matching tablespace exists in the InnoDB tablespace memory
489
518
cache. Note that if we have not done a crash recovery at the database startup,
490
519
there may be many tablespaces which are not yet in the memory cache. */
491
 
 
 
520
UNIV_INTERN
492
521
ibool
493
522
fil_space_for_table_exists_in_mem(
494
523
/*==============================*/
515
544
Tries to extend a data file so that it would accommodate the number of pages
516
545
given. The tablespace must be cached in the memory cache. If the space is big
517
546
enough already, does nothing. */
518
 
 
 
547
UNIV_INTERN
519
548
ibool
520
549
fil_extend_space_to_desired_size(
521
550
/*=============================*/
533
562
ibbackup --apply-log phase we extended the spaces on-demand so that log records
534
563
could be appllied, but that may have left spaces still too small compared to
535
564
the size stored in the space header. */
536
 
 
 
565
UNIV_INTERN
537
566
void
538
567
fil_extend_tablespaces_to_stored_len(void);
539
568
/*======================================*/
540
569
#endif
541
570
/***********************************************************************
542
571
Tries to reserve free extents in a file space. */
543
 
 
 
572
UNIV_INTERN
544
573
ibool
545
574
fil_space_reserve_free_extents(
546
575
/*===========================*/
550
579
        ulint   n_to_reserve);  /* in: how many one wants to reserve */
551
580
/***********************************************************************
552
581
Releases free extents in a file space. */
553
 
 
 
582
UNIV_INTERN
554
583
void
555
584
fil_space_release_free_extents(
556
585
/*===========================*/
559
588
/***********************************************************************
560
589
Gets the number of reserved extents. If the database is silent, this number
561
590
should be zero. */
562
 
 
 
591
UNIV_INTERN
563
592
ulint
564
593
fil_space_get_n_reserved_extents(
565
594
/*=============================*/
566
595
        ulint   id);            /* in: space id */
567
596
/************************************************************************
568
597
Reads or writes data. This operation is asynchronous (aio). */
569
 
 
 
598
UNIV_INTERN
570
599
ulint
571
600
fil_io(
572
601
/*===*/
584
613
                                caution! */
585
614
        ibool   sync,           /* in: TRUE if synchronous aio is desired */
586
615
        ulint   space_id,       /* in: space id */
 
616
        ulint   zip_size,       /* in: compressed page size in bytes;
 
617
                                0 for uncompressed pages */
587
618
        ulint   block_offset,   /* in: offset in number of blocks */
588
619
        ulint   byte_offset,    /* in: remainder of offset in bytes; in
589
620
                                aio this must be divisible by the OS block
596
627
                                appropriately aligned */
597
628
        void*   message);       /* in: message for aio handler if non-sync
598
629
                                aio used, else ignored */
599
 
/************************************************************************
600
 
Reads data from a space to a buffer. Remember that the possible incomplete
601
 
blocks at the end of file are ignored: they are not taken into account when
602
 
calculating the byte offset within a space. */
603
 
 
604
 
ulint
605
 
fil_read(
606
 
/*=====*/
607
 
                                /* out: DB_SUCCESS, or DB_TABLESPACE_DELETED
608
 
                                if we are trying to do i/o on a tablespace
609
 
                                which does not exist */
610
 
        ibool   sync,           /* in: TRUE if synchronous aio is desired */
611
 
        ulint   space_id,       /* in: space id */
612
 
        ulint   block_offset,   /* in: offset in number of blocks */
613
 
        ulint   byte_offset,    /* in: remainder of offset in bytes; in aio
614
 
                                this must be divisible by the OS block size */
615
 
        ulint   len,            /* in: how many bytes to read; this must not
616
 
                                cross a file boundary; in aio this must be a
617
 
                                block size multiple */
618
 
        void*   buf,            /* in/out: buffer where to store data read;
619
 
                                in aio this must be appropriately aligned */
620
 
        void*   message);       /* in: message for aio handler if non-sync
621
 
                                aio used, else ignored */
622
 
/************************************************************************
623
 
Writes data to a space from a buffer. Remember that the possible incomplete
624
 
blocks at the end of file are ignored: they are not taken into account when
625
 
calculating the byte offset within a space. */
626
 
 
627
 
ulint
628
 
fil_write(
629
 
/*======*/
630
 
                                /* out: DB_SUCCESS, or DB_TABLESPACE_DELETED
631
 
                                if we are trying to do i/o on a tablespace
632
 
                                which does not exist */
633
 
        ibool   sync,           /* in: TRUE if synchronous aio is desired */
634
 
        ulint   space_id,       /* in: space id */
635
 
        ulint   block_offset,   /* in: offset in number of blocks */
636
 
        ulint   byte_offset,    /* in: remainder of offset in bytes; in aio
637
 
                                this must be divisible by the OS block size */
638
 
        ulint   len,            /* in: how many bytes to write; this must
639
 
                                not cross a file boundary; in aio this must
640
 
                                be a block size multiple */
641
 
        void*   buf,            /* in: buffer from which to write; in aio
642
 
                                this must be appropriately aligned */
643
 
        void*   message);       /* in: message for aio handler if non-sync
644
 
                                aio used, else ignored */
645
630
/**************************************************************************
646
631
Waits for an aio operation to complete. This function is used to write the
647
632
handler for completed requests. The aio array of pending requests is divided
648
633
into segments (see os0file.c for more info). The thread specifies which
649
634
segment it wants to wait for. */
650
 
 
 
635
UNIV_INTERN
651
636
void
652
637
fil_aio_wait(
653
638
/*=========*/
656
641
/**************************************************************************
657
642
Flushes to disk possible writes cached by the OS. If the space does not exist
658
643
or is being dropped, does not do anything. */
659
 
 
 
644
UNIV_INTERN
660
645
void
661
646
fil_flush(
662
647
/*======*/
665
650
/**************************************************************************
666
651
Flushes to disk writes in file spaces of the given type possibly cached by
667
652
the OS. */
668
 
 
 
653
UNIV_INTERN
669
654
void
670
655
fil_flush_file_spaces(
671
656
/*==================*/
672
657
        ulint   purpose);       /* in: FIL_TABLESPACE, FIL_LOG */
673
658
/**********************************************************************
674
659
Checks the consistency of the tablespace cache. */
675
 
 
 
660
UNIV_INTERN
676
661
ibool
677
662
fil_validate(void);
678
663
/*==============*/
679
664
                        /* out: TRUE if ok */
680
665
/************************************************************************
681
666
Returns TRUE if file address is undefined. */
682
 
 
 
667
UNIV_INTERN
683
668
ibool
684
669
fil_addr_is_null(
685
670
/*=============*/
687
672
        fil_addr_t      addr);  /* in: address */
688
673
/************************************************************************
689
674
Accessor functions for a file page */
690
 
 
691
 
ulint
692
 
fil_page_get_prev(byte* page);
693
 
ulint
694
 
fil_page_get_next(byte* page);
 
675
UNIV_INTERN
 
676
ulint
 
677
fil_page_get_prev(const byte*   page);
 
678
ulint
 
679
fil_page_get_next(const byte*   page);
695
680
/*************************************************************************
696
681
Sets the file page type. */
697
 
 
 
682
UNIV_INTERN
698
683
void
699
684
fil_page_set_type(
700
685
/*==============*/
702
687
        ulint   type);  /* in: type */
703
688
/*************************************************************************
704
689
Gets the file page type. */
705
 
 
 
690
UNIV_INTERN
706
691
ulint
707
692
fil_page_get_type(
708
693
/*==============*/
709
 
                        /* out: type; NOTE that if the type has not been
710
 
                        written to page, the return value not defined */
711
 
        byte*   page);  /* in: file page */
 
694
                                /* out: type; NOTE that if the type
 
695
                                has not been written to page, the
 
696
                                return value not defined */
 
697
        const byte*     page);  /* in: file page */
712
698
 
713
699
 
714
700
typedef struct fil_space_struct fil_space_t;