← Back to branch summary

~gaul/percona-data-recovery-tool-for-innodb/prerequisites

« back to all changes in this revision

Viewing changes to mysql-source/include/keycache.h

  • Committer: Aleksandr Kuzminsky
  • Date: 2010-01-14 13:05:06 UTC
  • mfrom: (1.1.1 page-signature-check)
  • Revision ID: aleksandr.kuzminsky@percona.com-20100114130506-72t6jxtll15gk3pp
Added InnoDB page signature check.
At the beginning of InnoDB page (type FIL_PAGE_INODE) there are infimum and supremum records.
They are located in fixed position depending on InnoDB page format(REDUNDANT (4.x and 5.x versions) or COMPACT(5.x only)).

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysql-source/include/keycache.h
 
1
/* Copyright (C) 2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
/* Key cache variable structures */
 
17
 
 
18
#ifndef _keycache_h
 
19
#define _keycache_h
 
20
C_MODE_START
 
21
 
 
22
/* declare structures that is used by st_key_cache */
 
23
 
 
24
struct st_block_link;
 
25
typedef struct st_block_link BLOCK_LINK;
 
26
struct st_keycache_page;
 
27
typedef struct st_keycache_page KEYCACHE_PAGE;
 
28
struct st_hash_link;
 
29
typedef struct st_hash_link HASH_LINK;
 
30
 
 
31
/* info about requests in a waiting queue */
 
32
typedef struct st_keycache_wqueue
 
33
{
 
34
  struct st_my_thread_var *last_thread;  /* circular list of waiting threads */
 
35
} KEYCACHE_WQUEUE;
 
36
 
 
37
#define CHANGED_BLOCKS_HASH 128             /* must be power of 2 */
 
38
 
 
39
/*
 
40
  The key cache structure
 
41
  It also contains read-only statistics parameters.
 
42
*/   
 
43
 
 
44
typedef struct st_key_cache
 
45
{
 
46
  my_bool key_cache_inited;
 
47
  my_bool resize_in_flush;       /* true during flush of resize operation    */
 
48
  my_bool can_be_used;           /* usage of cache for read/write is allowed */
 
49
  uint key_cache_shift;
 
50
  ulong key_cache_mem_size;      /* specified size of the cache memory       */
 
51
  uint key_cache_block_size;     /* size of the page buffer of a cache block */
 
52
  ulong min_warm_blocks;         /* min number of warm blocks;               */
 
53
  ulong age_threshold;           /* age threshold for hot blocks             */
 
54
  ulonglong keycache_time;       /* total number of block link operations    */
 
55
  uint hash_entries;             /* max number of entries in the hash table  */
 
56
  int hash_links;                /* max number of hash links                 */
 
57
  int hash_links_used;           /* number of hash links currently used      */
 
58
  int disk_blocks;               /* max number of blocks in the cache        */
 
59
  ulong blocks_used; /* maximum number of concurrently used blocks */
 
60
  ulong blocks_unused; /* number of currently unused blocks */
 
61
  ulong blocks_changed;          /* number of currently dirty blocks         */
 
62
  ulong warm_blocks;             /* number of blocks in warm sub-chain       */
 
63
  ulong cnt_for_resize_op;       /* counter to block resize operation        */
 
64
  long blocks_available;      /* number of blocks available in the LRU chain */
 
65
  HASH_LINK **hash_root;         /* arr. of entries into hash table buckets  */
 
66
  HASH_LINK *hash_link_root;     /* memory for hash table links              */
 
67
  HASH_LINK *free_hash_list;     /* list of free hash links                  */
 
68
  BLOCK_LINK *free_block_list; /* list of free blocks */
 
69
  BLOCK_LINK *block_root;        /* memory for block links                   */
 
70
  byte HUGE_PTR *block_mem;      /* memory for block buffers                 */
 
71
  BLOCK_LINK *used_last;         /* ptr to the last block of the LRU chain   */
 
72
  BLOCK_LINK *used_ins;          /* ptr to the insertion block in LRU chain  */
 
73
  pthread_mutex_t cache_lock;    /* to lock access to the cache structure    */
 
74
  KEYCACHE_WQUEUE resize_queue;  /* threads waiting during resize operation  */
 
75
  KEYCACHE_WQUEUE waiting_for_hash_link; /* waiting for a free hash link     */
 
76
  KEYCACHE_WQUEUE waiting_for_block;    /* requests waiting for a free block */
 
77
  BLOCK_LINK *changed_blocks[CHANGED_BLOCKS_HASH]; /* hash for dirty file bl.*/
 
78
  BLOCK_LINK *file_blocks[CHANGED_BLOCKS_HASH];    /* hash for other file bl.*/
 
79
 
 
80
  /*
 
81
    The following variables are and variables used to hold parameters for
 
82
    initializing the key cache.
 
83
  */
 
84
 
 
85
  ulonglong param_buff_size;    /* size the memory allocated for the cache  */
 
86
  ulong param_block_size;       /* size of the blocks in the key cache      */
 
87
  ulong param_division_limit;   /* min. percentage of warm blocks           */
 
88
  ulong param_age_threshold;    /* determines when hot block is downgraded  */
 
89
 
 
90
  /* Statistics variables. These are reset in reset_key_cache_counters(). */
 
91
  ulong global_blocks_changed;  /* number of currently dirty blocks         */
 
92
  ulonglong global_cache_w_requests;/* number of write requests (write hits) */
 
93
  ulonglong global_cache_write;     /* number of writes from cache to files  */
 
94
  ulonglong global_cache_r_requests;/* number of read requests (read hits)   */
 
95
  ulonglong global_cache_read;      /* number of reads from files to cache   */
 
96
 
 
97
  int blocks;                   /* max number of blocks in the cache        */
 
98
  my_bool in_init;              /* Set to 1 in MySQL during init/resize     */
 
99
} KEY_CACHE;
 
100
 
 
101
/* The default key cache */
 
102
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
 
103
 
 
104
extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 
105
                          ulong use_mem, uint division_limit,
 
106
                          uint age_threshold);
 
107
extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
 
108
                            ulong use_mem, uint division_limit,
 
109
                            uint age_threshold);
 
110
extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
 
111
                                   uint age_threshold);
 
112
extern byte *key_cache_read(KEY_CACHE *keycache,
 
113
                            File file, my_off_t filepos, int level,
 
114
                            byte *buff, uint length,
 
115
                            uint block_length,int return_buffer);
 
116
extern int key_cache_insert(KEY_CACHE *keycache,
 
117
                            File file, my_off_t filepos, int level,
 
118
                            byte *buff, uint length);
 
119
extern int key_cache_write(KEY_CACHE *keycache,
 
120
                           File file, my_off_t filepos, int level,
 
121
                           byte *buff, uint length,
 
122
                           uint block_length,int force_write);
 
123
extern int flush_key_blocks(KEY_CACHE *keycache,
 
124
                            int file, enum flush_type type);
 
125
extern void end_key_cache(KEY_CACHE *keycache, my_bool cleanup);
 
126
 
 
127
/* Functions to handle multiple key caches */
 
128
extern my_bool multi_keycache_init(void);
 
129
extern void multi_keycache_free(void);
 
130
extern KEY_CACHE *multi_key_cache_search(byte *key, uint length);
 
131
extern my_bool multi_key_cache_set(const byte *key, uint length,
 
132
                                   KEY_CACHE *key_cache);
 
133
extern void multi_key_cache_change(KEY_CACHE *old_data,
 
134
                                   KEY_CACHE *new_data);
 
135
extern int reset_key_cache_counters(const char *name,
 
136
                                    KEY_CACHE *key_cache);
 
137
C_MODE_END
 
138
#endif /* _keycache_h */