← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mysql-5.6/trusty

« back to all changes in this revision

Viewing changes to storage/ndb/src/kernel/blocks/backup/BackupInit.cpp

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-02-12 11:54:27 UTC
  • Revision ID: package-import@ubuntu.com-20140212115427-oq6tfsqxl1wuwehi
Tags: upstream-5.6.15
Import upstream version 5.6.15

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/ndb/src/kernel/blocks/backup/BackupInit.cpp
 
1
/*
 
2
   Copyright (C) 2003-2008 MySQL AB, 2008 Sun Microsystems, Inc.
 
3
    All rights reserved. Use is subject to license terms.
 
4
 
 
5
   This program is free software; you can redistribute it and/or modify
 
6
   it under the terms of the GNU General Public License as published by
 
7
   the Free Software Foundation; version 2 of the License.
 
8
 
 
9
   This program is distributed in the hope that it will be useful,
 
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
   GNU General Public License for more details.
 
13
 
 
14
   You should have received a copy of the GNU General Public License
 
15
   along with this program; if not, write to the Free Software
 
16
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 
17
*/
 
18
 
 
19
//****************************************************************************
 
20
// 
 
21
// NAME
 
22
//      Backup - Database backup / restore
 
23
//
 
24
//===========================================================================
 
25
#include "Backup.hpp"
 
26
 
 
27
#include <Properties.hpp>
 
28
#include <Configuration.hpp>
 
29
 
 
30
//extern const unsigned Ndbcntr::g_sysTableCount;
 
31
 
 
32
Backup::Backup(Block_context& ctx, Uint32 instanceNumber) :
 
33
  SimulatedBlock(BACKUP, ctx, instanceNumber),
 
34
  c_nodes(c_nodePool),
 
35
  c_backups(c_backupPool)
 
36
{
 
37
  BLOCK_CONSTRUCTOR(Backup);
 
38
  
 
39
  c_masterNodeId = getOwnNodeId();
 
40
  
 
41
  // Add received signals
 
42
  addRecSignal(GSN_READ_CONFIG_REQ, &Backup::execREAD_CONFIG_REQ);
 
43
  addRecSignal(GSN_STTOR, &Backup::execSTTOR);
 
44
  addRecSignal(GSN_DUMP_STATE_ORD, &Backup::execDUMP_STATE_ORD);
 
45
  addRecSignal(GSN_READ_NODESCONF, &Backup::execREAD_NODESCONF);
 
46
  addRecSignal(GSN_NODE_FAILREP, &Backup::execNODE_FAILREP);
 
47
  addRecSignal(GSN_INCL_NODEREQ, &Backup::execINCL_NODEREQ);
 
48
  addRecSignal(GSN_CONTINUEB, &Backup::execCONTINUEB);
 
49
  addRecSignal(GSN_READ_CONFIG_REQ, &Backup::execREAD_CONFIG_REQ, true);  
 
50
 
 
51
  addRecSignal(GSN_SCAN_HBREP, &Backup::execSCAN_HBREP);
 
52
  addRecSignal(GSN_TRANSID_AI, &Backup::execTRANSID_AI);
 
53
  addRecSignal(GSN_SCAN_FRAGREF, &Backup::execSCAN_FRAGREF);
 
54
  addRecSignal(GSN_SCAN_FRAGCONF, &Backup::execSCAN_FRAGCONF);
 
55
 
 
56
  addRecSignal(GSN_BACKUP_TRIG_REQ, &Backup::execBACKUP_TRIG_REQ);
 
57
  addRecSignal(GSN_TRIG_ATTRINFO, &Backup::execTRIG_ATTRINFO);
 
58
  addRecSignal(GSN_FIRE_TRIG_ORD, &Backup::execFIRE_TRIG_ORD);
 
59
 
 
60
  addRecSignal(GSN_LIST_TABLES_CONF, &Backup::execLIST_TABLES_CONF);
 
61
  addRecSignal(GSN_GET_TABINFOREF, &Backup::execGET_TABINFOREF);
 
62
  addRecSignal(GSN_GET_TABINFO_CONF, &Backup::execGET_TABINFO_CONF);
 
63
 
 
64
  addRecSignal(GSN_CREATE_TRIG_IMPL_REF, &Backup::execCREATE_TRIG_IMPL_REF);
 
65
  addRecSignal(GSN_CREATE_TRIG_IMPL_CONF, &Backup::execCREATE_TRIG_IMPL_CONF);
 
66
 
 
67
  addRecSignal(GSN_DROP_TRIG_IMPL_REF, &Backup::execDROP_TRIG_IMPL_REF);
 
68
  addRecSignal(GSN_DROP_TRIG_IMPL_CONF, &Backup::execDROP_TRIG_IMPL_CONF);
 
69
 
 
70
  addRecSignal(GSN_DIH_SCAN_TAB_CONF, &Backup::execDIH_SCAN_TAB_CONF);
 
71
  addRecSignal(GSN_DIH_SCAN_GET_NODES_CONF,
 
72
               &Backup::execDIH_SCAN_GET_NODES_CONF);
 
73
 
 
74
  addRecSignal(GSN_FSOPENREF, &Backup::execFSOPENREF, true);
 
75
  addRecSignal(GSN_FSOPENCONF, &Backup::execFSOPENCONF);
 
76
 
 
77
  addRecSignal(GSN_FSCLOSEREF, &Backup::execFSCLOSEREF, true);
 
78
  addRecSignal(GSN_FSCLOSECONF, &Backup::execFSCLOSECONF);
 
79
 
 
80
  addRecSignal(GSN_FSAPPENDREF, &Backup::execFSAPPENDREF, true);
 
81
  addRecSignal(GSN_FSAPPENDCONF, &Backup::execFSAPPENDCONF);
 
82
 
 
83
  addRecSignal(GSN_FSREMOVEREF, &Backup::execFSREMOVEREF, true);
 
84
  addRecSignal(GSN_FSREMOVECONF, &Backup::execFSREMOVECONF);
 
85
 
 
86
  /*****/
 
87
  addRecSignal(GSN_BACKUP_REQ, &Backup::execBACKUP_REQ);
 
88
  addRecSignal(GSN_ABORT_BACKUP_ORD, &Backup::execABORT_BACKUP_ORD);
 
89
 
 
90
  addRecSignal(GSN_DEFINE_BACKUP_REQ, &Backup::execDEFINE_BACKUP_REQ);
 
91
  addRecSignal(GSN_DEFINE_BACKUP_REF, &Backup::execDEFINE_BACKUP_REF);
 
92
  addRecSignal(GSN_DEFINE_BACKUP_CONF, &Backup::execDEFINE_BACKUP_CONF);
 
93
 
 
94
  addRecSignal(GSN_START_BACKUP_REQ, &Backup::execSTART_BACKUP_REQ);
 
95
  addRecSignal(GSN_START_BACKUP_REF, &Backup::execSTART_BACKUP_REF);
 
96
  addRecSignal(GSN_START_BACKUP_CONF, &Backup::execSTART_BACKUP_CONF);
 
97
  
 
98
  addRecSignal(GSN_BACKUP_FRAGMENT_REQ, &Backup::execBACKUP_FRAGMENT_REQ);
 
99
  addRecSignal(GSN_BACKUP_FRAGMENT_REF, &Backup::execBACKUP_FRAGMENT_REF);
 
100
  addRecSignal(GSN_BACKUP_FRAGMENT_CONF, &Backup::execBACKUP_FRAGMENT_CONF);
 
101
 
 
102
  addRecSignal(GSN_BACKUP_FRAGMENT_COMPLETE_REP,
 
103
               &Backup::execBACKUP_FRAGMENT_COMPLETE_REP);
 
104
  
 
105
  addRecSignal(GSN_STOP_BACKUP_REQ, &Backup::execSTOP_BACKUP_REQ);
 
106
  addRecSignal(GSN_STOP_BACKUP_REF, &Backup::execSTOP_BACKUP_REF);
 
107
  addRecSignal(GSN_STOP_BACKUP_CONF, &Backup::execSTOP_BACKUP_CONF);
 
108
  
 
109
  //addRecSignal(GSN_BACKUP_STATUS_REQ, &Backup::execBACKUP_STATUS_REQ);
 
110
  //addRecSignal(GSN_BACKUP_STATUS_CONF, &Backup::execBACKUP_STATUS_CONF);
 
111
  
 
112
  addRecSignal(GSN_UTIL_SEQUENCE_REF, &Backup::execUTIL_SEQUENCE_REF);
 
113
  addRecSignal(GSN_UTIL_SEQUENCE_CONF, &Backup::execUTIL_SEQUENCE_CONF);
 
114
 
 
115
  addRecSignal(GSN_WAIT_GCP_REF, &Backup::execWAIT_GCP_REF);
 
116
  addRecSignal(GSN_WAIT_GCP_CONF, &Backup::execWAIT_GCP_CONF);
 
117
  addRecSignal(GSN_BACKUP_LOCK_TAB_CONF, &Backup::execBACKUP_LOCK_TAB_CONF);
 
118
  addRecSignal(GSN_BACKUP_LOCK_TAB_REF, &Backup::execBACKUP_LOCK_TAB_REF);
 
119
 
 
120
  /**
 
121
   * Testing
 
122
   */
 
123
  addRecSignal(GSN_BACKUP_REF, &Backup::execBACKUP_REF);
 
124
  addRecSignal(GSN_BACKUP_CONF, &Backup::execBACKUP_CONF);
 
125
  addRecSignal(GSN_BACKUP_ABORT_REP, &Backup::execBACKUP_ABORT_REP);
 
126
  addRecSignal(GSN_BACKUP_COMPLETE_REP, &Backup::execBACKUP_COMPLETE_REP);
 
127
  
 
128
  addRecSignal(GSN_LCP_PREPARE_REQ, &Backup::execLCP_PREPARE_REQ);
 
129
  addRecSignal(GSN_END_LCPREQ, &Backup::execEND_LCPREQ);
 
130
 
 
131
  addRecSignal(GSN_DBINFO_SCANREQ, &Backup::execDBINFO_SCANREQ);
 
132
}
 
133
  
 
134
Backup::~Backup()
 
135
{
 
136
}
 
137
 
 
138
BLOCK_FUNCTIONS(Backup)
 
139
 
 
140
template class ArrayPool<Backup::Page32>;
 
141
template class ArrayPool<Backup::Fragment>;
 
142
 
 
143
void
 
144
Backup::execREAD_CONFIG_REQ(Signal* signal)
 
145
{
 
146
  const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
 
147
  Uint32 ref = req->senderRef;
 
148
  Uint32 senderData = req->senderData;
 
149
  ndbrequire(req->noOfParameters == 0);
 
150
 
 
151
  const ndb_mgm_configuration_iterator * p = 
 
152
    m_ctx.m_config.getOwnConfigIterator();
 
153
  ndbrequire(p != 0);
 
154
 
 
155
  c_defaults.m_disk_write_speed = 10 * (1024 * 1024);
 
156
  c_defaults.m_disk_write_speed_sr = 100 * (1024 * 1024);
 
157
  c_defaults.m_disk_synch_size = 4 * (1024 * 1024);
 
158
  c_defaults.m_o_direct = true;
 
159
 
 
160
  Uint32 noBackups = 0, noTables = 0, noAttribs = 0, noFrags = 0;
 
161
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_DISCLESS, 
 
162
                                        &c_defaults.m_diskless));
 
163
  ndb_mgm_get_int_parameter(p, CFG_DB_O_DIRECT,
 
164
                            &c_defaults.m_o_direct);
 
165
  ndb_mgm_get_int_parameter(p, CFG_DB_CHECKPOINT_SPEED_SR,
 
166
                            &c_defaults.m_disk_write_speed_sr);
 
167
  ndb_mgm_get_int_parameter(p, CFG_DB_CHECKPOINT_SPEED,
 
168
                            &c_defaults.m_disk_write_speed);
 
169
  ndb_mgm_get_int_parameter(p, CFG_DB_DISK_SYNCH_SIZE,
 
170
                            &c_defaults.m_disk_synch_size);
 
171
  ndb_mgm_get_int_parameter(p, CFG_DB_COMPRESSED_BACKUP,
 
172
                            &c_defaults.m_compressed_backup);
 
173
  ndb_mgm_get_int_parameter(p, CFG_DB_COMPRESSED_LCP,
 
174
                            &c_defaults.m_compressed_lcp);
 
175
 
 
176
  m_backup_report_frequency = 0;
 
177
  ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_REPORT_FREQUENCY, 
 
178
                            &m_backup_report_frequency);
 
179
  /*
 
180
    We adjust the disk speed parameters from bytes per second to rather be
 
181
    words per 100 milliseconds. We convert disk synch size from bytes per
 
182
    second to words per second.
 
183
  */
 
184
  c_defaults.m_disk_write_speed /= (4 * 10);
 
185
  c_defaults.m_disk_write_speed_sr /= (4 * 10);
 
186
 
 
187
  ndb_mgm_get_int_parameter(p, CFG_DB_PARALLEL_BACKUPS, &noBackups);
 
188
  //  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_TABLES, &noTables));
 
189
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DICT_TABLE, &noTables));
 
190
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_ATTRIBUTES, &noAttribs));
 
191
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DIH_FRAG_CONNECT, &noFrags));
 
192
 
 
193
  noAttribs++; //RT 527 bug fix
 
194
 
 
195
  c_nodePool.setSize(MAX_NDB_NODES);
 
196
  c_backupPool.setSize(noBackups + 1);
 
197
  c_backupFilePool.setSize(3 * noBackups + 1);
 
198
  c_tablePool.setSize(noBackups * noTables + 1);
 
199
  c_triggerPool.setSize(noBackups * 3 * noTables);
 
200
  c_fragmentPool.setSize(noBackups * noFrags + 1);
 
201
  
 
202
  Uint32 szDataBuf = (2 * 1024 * 1024);
 
203
  Uint32 szLogBuf = (2 * 1024 * 1024);
 
204
  Uint32 szWrite = 32768, maxWriteSize = (256 * 1024);
 
205
  ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_DATA_BUFFER_MEM, &szDataBuf);
 
206
  ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_LOG_BUFFER_MEM, &szLogBuf);
 
207
  ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_WRITE_SIZE, &szWrite);
 
208
  ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_MAX_WRITE_SIZE, &maxWriteSize);
 
209
  
 
210
  c_defaults.m_logBufferSize = szLogBuf;
 
211
  c_defaults.m_dataBufferSize = szDataBuf;
 
212
  c_defaults.m_minWriteSize = szWrite;
 
213
  c_defaults.m_maxWriteSize = maxWriteSize;
 
214
  c_defaults.m_lcp_buffer_size = szDataBuf;
 
215
 
 
216
  Uint32 szMem = 0;
 
217
  ndb_mgm_get_int_parameter(p, CFG_DB_BACKUP_MEM, &szMem);
 
218
  Uint32 noPages = (szMem + c_defaults.m_lcp_buffer_size + sizeof(Page32) - 1) 
 
219
    / sizeof(Page32);
 
220
  // We need to allocate an additional of 2 pages. 1 page because of a bug in
 
221
  // ArrayPool and another one for DICTTAINFO.
 
222
  c_pagePool.setSize(noPages + NO_OF_PAGES_META_FILE + 2, true); 
 
223
  
 
224
  { // Init all tables
 
225
    SLList<Table> tables(c_tablePool);
 
226
    TablePtr ptr;
 
227
    while(tables.seize(ptr)){
 
228
      new (ptr.p) Table(c_fragmentPool);
 
229
    }
 
230
    tables.release();
 
231
  }
 
232
 
 
233
  {
 
234
    SLList<BackupFile> ops(c_backupFilePool);
 
235
    BackupFilePtr ptr;
 
236
    while(ops.seize(ptr)){
 
237
      new (ptr.p) BackupFile(* this, c_pagePool);
 
238
    }
 
239
    ops.release();
 
240
  }
 
241
  
 
242
  {
 
243
    SLList<BackupRecord> recs(c_backupPool);
 
244
    BackupRecordPtr ptr;
 
245
    while(recs.seize(ptr)){
 
246
      new (ptr.p) BackupRecord(* this, c_tablePool, 
 
247
                               c_backupFilePool, c_triggerPool);
 
248
    }
 
249
    recs.release();
 
250
  }
 
251
 
 
252
  // Initialize BAT for interface to file system
 
253
  {
 
254
    Page32Ptr p;
 
255
    ndbrequire(c_pagePool.seizeId(p, 0));
 
256
    c_startOfPages = (Uint32 *)p.p;
 
257
    c_pagePool.release(p);
 
258
    
 
259
    NewVARIABLE* bat = allocateBat(1);
 
260
    bat[0].WA = c_startOfPages;
 
261
    bat[0].nrr = c_pagePool.getSize()*sizeof(Page32)/sizeof(Uint32);
 
262
  }
 
263
 
 
264
  ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
 
265
  conf->senderRef = reference();
 
266
  conf->senderData = senderData;
 
267
  sendSignal(ref, GSN_READ_CONFIG_CONF, signal, 
 
268
             ReadConfigConf::SignalLength, JBB);
 
269
}
 
270