Below is the list of changes that have just been committed into a local
5.1-ndb repository of jonas. When jonas does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html
ChangeSet
1.1879 05/04/29 16:19:49 joreland@stripped +12 -0
wl1870 - ndb diskdata
Move alloc info to fragment
Apply undo
ndb/src/kernel/blocks/lgman.cpp
1.40 05/04/29 16:19:45 joreland@stripped +22 -11
apply undo
ndb/src/kernel/blocks/dbtup/tuppage.hpp
1.10 05/04/29 16:19:45 joreland@stripped +6 -4
Put disk allocation on fragment
ndb/src/kernel/blocks/dbtup/tuppage.cpp
1.6 05/04/29 16:19:45 joreland@stripped +3 -0
move Tuple_header::FREE int tup_fix_page
ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
1.29 05/04/29 16:19:45 joreland@stripped +73 -49
Put disk allocation on fragment
ndb/src/kernel/blocks/dbtup/DbtupGen.cpp
1.32 05/04/29 16:19:45 joreland@stripped +4 -1
Put disk allocation on fragment
ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp
1.14 05/04/29 16:19:45 joreland@stripped +0 -1
move Tuple_header::FREE int tup_fix_page
ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
1.63 05/04/29 16:19:45 joreland@stripped +10 -9
Put disk allocation on fragment
ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp
1.21 05/04/29 16:19:45 joreland@stripped +247 -42
Put disk allocation on fragment
Apply undo
ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
1.48 05/04/29 16:19:45 joreland@stripped +4 -3
Put disk allocation on fragment
ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
1.33 05/04/29 16:19:45 joreland@stripped +3 -3
Put disk allocation on fragment
ndb/src/kernel/blocks/dbtup/Dbtup.hpp
1.62 05/04/29 16:19:45 joreland@stripped +147 -125
Put disk allocation on fragment
ndb/include/kernel/signaldata/LgmanContinueB.hpp
1.6 05/04/29 16:19:45 joreland@stripped +2 -6
apply undo
# This is a BitKeeper patch. What follows are the unified diffs for the
# set of deltas contained in the patch. The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User: joreland
# Host: eel.hemma.oreland.se.ndb.mysql.com
# Root: /home/jonas/src/mysql-5.1-ndb-dd
--- 1.5/ndb/include/kernel/signaldata/LgmanContinueB.hpp Thu Apr 28 06:54:53 2005
+++ 1.6/ndb/include/kernel/signaldata/LgmanContinueB.hpp Fri Apr 29 16:19:45 2005
@@ -19,12 +19,8 @@
#include "SignalData.hpp"
-class LgmanContinueB {
- /**
- * Sender(s)/Reciver(s)
- */
- friend class Lgman;
-private:
+struct LgmanContinueB {
+
enum {
CUT_LOG_TAIL = 0
,FILTER_LOG = 1
--- 1.20/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp Thu Apr 28 14:50:06 2005
+++ 1.21/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp Fri Apr 29 16:19:45 2005
@@ -135,7 +135,7 @@
}
void
-Dbtup::disk_page_update_free_space(Tablerec* regTabPtr,
+Dbtup::disk_page_update_free_space(Fragrecord* regFragPtr,
PagePtr pagePtr,
Uint32 i)
{
@@ -147,8 +147,8 @@
Ptr<Extent_info> extentPtr;
c_extent_pool.getPtr(extentPtr, ext);
- Uint32 idx= calc_free_list(regTabPtr, free - used);
- Disk_alloc_info& alloc= regTabPtr->m_disk_alloc_info;
+ Disk_alloc_info& alloc= regFragPtr->m_disk_alloc_info;
+ Uint32 idx= alloc.calc_page_free_bits(free - used);
ArrayPool<Page> *pool= (ArrayPool<Page>*)&m_global_page_pool;
if((i & 0x8000) == 0)
@@ -186,16 +186,17 @@
}
void
-Dbtup::disk_page_update_free_space(Tablerec* regTabPtr,
+Dbtup::disk_page_update_free_space(Fragrecord* regFragPtr,
Ptr<Page_request> req,
DLList<Page_request>::Head list[],
Uint32 i,
Uint32 sz)
{
Ptr<Extent_info> extentPtr;
+ Disk_alloc_info& alloc= regFragPtr->m_disk_alloc_info;
extentPtr.i= req.p->m_extent_info_ptr;
Uint32 free= req.p->m_free_space - sz;
- Uint32 idx= calc_free_list(regTabPtr, free);
+ Uint32 idx= alloc.calc_page_free_bits(free);
c_extent_pool.getPtr(extentPtr);
ndbassert(req.p->m_free_space >= sz);
if(i != idx)
@@ -220,7 +221,6 @@
if(old_pos != RNIL) // Current extent
{
jam();
- Disk_alloc_info& alloc= regTabPtr->m_disk_alloc_info;
Uint32 new_pos= alloc.calc_extent_pos(extentPtr.p);
if(old_pos != new_pos)
{
@@ -246,19 +246,19 @@
int
Dbtup::disk_page_prealloc(Signal* signal,
- Fragrecord* fragPtrP,
- Tablerec* tabPtrP,
+ Ptr<Fragrecord> fragPtr,
Local_key* key, Uint32 sz)
{
int err;
Uint32 i, ptrI;
Ptr<Page_request> req;
- Disk_alloc_info& alloc= tabPtrP->m_disk_alloc_info;
- Uint32 idx= calc_free_list(tabPtrP, sz);
+ Fragrecord* fragPtrP = fragPtr.p;
+ Disk_alloc_info& alloc= fragPtrP->m_disk_alloc_info;
+ Uint32 idx= alloc.calc_page_free_bits(sz);
Tablespace_client tsman(signal, c_tsman,
fragPtrP->fragTableId,
fragPtrP->fragmentId,
- tabPtrP->m_tablespace_id);
+ fragPtrP->m_tablespace_id);
/**
* 1) search current dirty pages
@@ -272,7 +272,7 @@
m_global_page_pool.getPtr(page, ptrI);
((Page*)page.p)->uncommitted_used_space += sz;
- disk_page_update_free_space(tabPtrP,*(PagePtr*)&page, i);
+ disk_page_update_free_space(fragPtrP, *(PagePtr*)&page, i);
key->m_page_no= ((Page*)page.p)->m_page_no;
key->m_file_no= ((Page*)page.p)->m_file_no;
if(0)
@@ -297,7 +297,7 @@
c_page_request_pool.getPtr(req, ptrI);
req.p->m_ref_count++;
- disk_page_update_free_space(tabPtrP, req, alloc.m_page_requests, i, sz);
+ disk_page_update_free_space(fragPtrP, req, alloc.m_page_requests, i, sz);
* key = req.p->m_key;
//ndbout_c("found transit page");
return 0;
@@ -318,8 +318,8 @@
new (req.p) Page_request();
req.p->m_ref_count= 1;
- req.p->m_table_id= fragPtrP->fragTableId;
-
+ req.p->m_frag_ptr_i= fragPtr.i;
+
int pageBits; // received
Ptr<Extent_info> ext;
const Uint32 bits= alloc.calc_page_free_bits(sz); // required
@@ -429,7 +429,7 @@
ext.p->m_free_space -= sz;
// And put page request in correct free list
- idx= calc_free_list(tabPtrP, new_size);
+ idx= alloc.calc_page_free_bits(new_size);
{
LocalDLList<Page_request> list(c_page_request_pool,
alloc.m_page_requests[idx]);
@@ -481,11 +481,11 @@
Ptr<GlobalPage> gpage;
m_global_page_pool.getPtr(gpage, page_id);
- Ptr<Tablerec> tabPtr;
- tabPtr.i= req.p->m_table_id;
- ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
+ Ptr<Fragrecord> fragPtr;
+ fragPtr.i= req.p->m_frag_ptr_i;
+ ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
- disk_page_alloc_callback_common(signal, req, tabPtr, gpage);
+ disk_page_alloc_callback_common(signal, req, fragPtr, gpage);
}
void
@@ -506,14 +506,19 @@
Ptr<GlobalPage> gpage;
m_global_page_pool.getPtr(gpage, page_id);
+ Ptr<Fragrecord> fragPtr;
+ fragPtr.i= req.p->m_frag_ptr_i;
+ ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
+
Ptr<Tablerec> tabPtr;
- tabPtr.i= req.p->m_table_id;
+ tabPtr.i = fragPtr.p->fragTableId;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
Page* page= (Page*)gpage.p;
page->m_page_no= req.p->m_key.m_page_no;
page->m_file_no= req.p->m_key.m_file_no;
- page->m_table_id= tabPtr.i;
+ page->m_table_id= fragPtr.p->fragTableId;
+ page->m_fragment_id = fragPtr.p->fragmentId;
page->m_extent_info_ptr= req.p->m_extent_info_ptr;
if(tabPtr.p->m_attributes[DD].m_no_of_varsize == 0)
{
@@ -524,13 +529,13 @@
{
abort();
}
- disk_page_alloc_callback_common(signal, req, tabPtr, gpage);
+ disk_page_alloc_callback_common(signal, req, fragPtr, gpage);
}
void
Dbtup::disk_page_alloc_callback_common(Signal* signal,
Ptr<Page_request> req,
- Ptr<Tablerec> tabPtr,
+ Ptr<Fragrecord> fragPtr,
Ptr<GlobalPage> pagePtr)
{
Page* page= (Page*)pagePtr.p;
@@ -542,15 +547,14 @@
* 4) inform pgman about current users
*/
Uint32 idx= req.p->m_list_index;
- Disk_alloc_info& alloc= tabPtr.p->m_disk_alloc_info;
+ Disk_alloc_info& alloc= fragPtr.p->m_disk_alloc_info;
- Uint32 used=
- tabPtr.p->m_disk_alloc_info.m_page_free_bits_map[0]-req.p->m_free_space;
+ Uint32 used= alloc.m_page_free_bits_map[0]-req.p->m_free_space;
page->uncommitted_used_space= used;
Uint32 real_free= page->free_space;
ndbassert(real_free >= used);
- Uint32 new_idx= calc_free_list(tabPtr.p, real_free - used);
+ Uint32 new_idx= alloc.calc_page_free_bits(real_free - used);
page->list_index= new_idx;
ArrayPool<Page> *cheat_pool= (ArrayPool<Page>*)&m_global_page_pool;
@@ -589,7 +593,7 @@
int flags= Page_cache_client::UNMAP_EVENT;
Callback tmp;
- tmp.m_callbackData= tabPtr.i;
+ tmp.m_callbackData= fragPtr.i;
tmp.m_callbackFunction =
safe_cast(&Dbtup::disk_page_unmap_callback);
@@ -612,11 +616,12 @@
}
void
-Dbtup::disk_page_free(Signal *signal, Tablerec *tabPtrP,
+Dbtup::disk_page_free(Signal *signal,
+ Tablerec *tabPtrP, Fragrecord * fragPtrP,
Local_key* key, PagePtr pagePtr, Uint32 gci)
{
Uint32 page_idx= key->m_page_idx;
- Uint32 logfile_group_id= tabPtrP->m_logfile_group_id;
+ Uint32 logfile_group_id= fragPtrP->m_logfile_group_id;
if(tabPtrP->m_attributes[DD].m_no_of_varsize == 0)
{
const Uint32 *src= ((Fix_page*)pagePtr.p)->get_ptr(page_idx, 0);
@@ -637,12 +642,12 @@
((Var_page*)pagePtr.p)->free_record(page_idx, 0);
}
- disk_page_update_free_space(tabPtrP, pagePtr, pagePtr.p->list_index);
+ disk_page_update_free_space(fragPtrP, pagePtr, pagePtr.p->list_index);
}
void
-Dbtup::disk_page_abort_prealloc(Signal *signal,
- Tablerec *tabPtrP, Local_key* key, Uint32 sz)
+Dbtup::disk_page_abort_prealloc(Signal *signal, Fragrecord* fragPtrP,
+ Local_key* key, Uint32 sz)
{
Page_cache_client::Request req;
req.m_callback.m_callbackData= sz;
@@ -661,7 +666,7 @@
default:
Ptr<GlobalPage> page;
m_global_page_pool.getPtr(page, (Uint32)res);
- disk_page_abort_prealloc_callback_1(signal, tabPtrP, *(PagePtr*)&page,
+ disk_page_abort_prealloc_callback_1(signal, fragPtrP, *(PagePtr*)&page,
sz);
}
}
@@ -681,21 +686,24 @@
tabPtr.i= pagePtr.p->m_table_id;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
+ Ptr<Fragrecord> fragPtr;
+ getFragmentrec(fragPtr, pagePtr.p->m_fragment_id, tabPtr.p);
+
// It can't be in a free list when just
// picked up from disk
pagePtr.p->list_index |= 0x8000;
- disk_page_abort_prealloc_callback_1(signal, tabPtr.p, pagePtr, sz);
+ disk_page_abort_prealloc_callback_1(signal, fragPtr.p, pagePtr, sz);
}
void
Dbtup::disk_page_abort_prealloc_callback_1(Signal* signal,
- Tablerec* tabPtrP,
+ Fragrecord* fragPtrP,
PagePtr pagePtr,
Uint32 sz)
{
ndbassert(pagePtr.p->uncommitted_used_space >= sz);
pagePtr.p->uncommitted_used_space -= sz;
- disk_page_update_free_space(tabPtrP, pagePtr, pagePtr.p->list_index);
+ disk_page_update_free_space(fragPtrP, pagePtr, pagePtr.p->list_index);
}
void
@@ -776,7 +784,7 @@
tabPtr.i = tableId;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
getFragmentrec(fragPtr, fragId, tabPtr.p);
- Disk_alloc_info& alloc= tabPtr.p->m_disk_alloc_info;
+ Disk_alloc_info& alloc= fragPtr.p->m_disk_alloc_info;
Ptr<Extent_info> ext;
ndbrequire(c_extent_pool.seize(ext));
@@ -812,7 +820,7 @@
tabPtr.i = tableId;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
getFragmentrec(fragPtr, fragId, tabPtr.p);
- Disk_alloc_info& alloc= tabPtr.p->m_disk_alloc_info;
+ Disk_alloc_info& alloc= fragPtr.p->m_disk_alloc_info;
Ptr<Extent_info> ext;
ndbrequire(c_extent_pool.getPtr(alloc.m_curr_extent_info_ptr_i));
@@ -850,10 +858,207 @@
}
}
+#include <signaldata/LgmanContinueB.hpp>
+
+static Dbtup::Apply_undo f_undo;
+
void
-Dbtup::disk_restart_exec_undo(Signal* signal,
- Uint32 type, const Uint32 * ptr, Uint32 len)
+Dbtup::disk_restart_undo(Signal* signal, Uint64 lsn,
+ Uint32 type, const Uint32 * ptr, Uint32 len)
{
+ f_undo.m_lsn= lsn;
+ f_undo.m_ptr= ptr;
+ f_undo.m_len= len;
+ f_undo.m_type = type;
+
+ Page_cache_client::Request preq;
+ switch(type){
+ case File_formats::Undofile::UNDO_LCP_FIRST:
+ case File_formats::Undofile::UNDO_LCP:
+ {
+ ndbrequire(len == 3);
+ Uint32 tableId = ptr[1] >> 16;
+ Uint32 fragId = ptr[1] & 0xFFFF;
+ disk_restart_undo_lcp(tableId, fragId);
+ disk_restart_undo_next(signal);
+ return;
+ }
+ case File_formats::Undofile::UNDO_TUP_ALLOC:
+ {
+ Disk_undo::Alloc* rec= (Disk_undo::Alloc*)ptr;
+ preq.m_page.m_page_no = rec->m_page_no;
+ preq.m_page.m_file_no = rec->m_file_no_page_idx >> 16;
+ preq.m_page.m_page_idx = rec->m_file_no_page_idx & 0xFFFF;
+ break;
+ }
+ case File_formats::Undofile::UNDO_TUP_UPDATE:
+ {
+ Disk_undo::Update* rec= (Disk_undo::Update*)ptr;
+ preq.m_page.m_page_no = rec->m_page_no;
+ preq.m_page.m_file_no = rec->m_file_no_page_idx >> 16;
+ preq.m_page.m_page_idx = rec->m_file_no_page_idx & 0xFFFF;
+ break;
+ }
+ case File_formats::Undofile::UNDO_TUP_FREE:
+ {
+ Disk_undo::Free* rec= (Disk_undo::Free*)ptr;
+ preq.m_page.m_page_no = rec->m_page_no;
+ preq.m_page.m_file_no = rec->m_file_no_page_idx >> 16;
+ preq.m_page.m_page_idx = rec->m_file_no_page_idx & 0xFFFF;
+ break;
+ }
+ default:
+ ndbrequire(false);
+ }
+
+ f_undo.m_key = preq.m_page;
+ preq.m_callback.m_callbackFunction =
+ safe_cast(&Dbtup::disk_restart_undo_callback);
+ int flags = 0;
+ int res= m_pgman.get_page(signal, preq, flags);
+ switch(res)
+ {
+ case 0:
+ break; // Wait for callback
+ case -1:
+ ndbrequire(false);
+ break;
+ default:
+ execute(signal, preq.m_callback, res); // run callback
+ }
+}
+
+void
+Dbtup::disk_restart_undo_next(Signal* signal)
+{
+ signal->theData[0] = LgmanContinueB::EXECUTE_UNDO_RECORD;
+ sendSignal(LGMAN_REF, GSN_CONTINUEB, signal, 1, JBB);
}
+void
+Dbtup::disk_restart_undo_lcp(Uint32 tableId, Uint32 fragId)
+{
+ Ptr<Tablerec> tabPtr;
+ tabPtr.i= tableId;
+ ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
+
+ FragrecordPtr fragPtr;
+ getFragmentrec(fragPtr, fragId, tabPtr.p);
+
+ ndbrequire(!fragPtr.p->m_undo_complete);
+ fragPtr.p->m_undo_complete = true;
+}
+
+void
+Dbtup::disk_restart_undo_callback(Signal* signal,
+ Uint32 id,
+ Uint32 page_id)
+{
+ Ptr<GlobalPage> page;
+ m_global_page_pool.getPtr(page, page_id);
+
+ Page* pageP = (Page*)page.p;
+
+ Uint64 lsn = 0;
+ lsn += pageP->m_page_header.m_page_lsn_hi; lsn <<= 32;
+ lsn += pageP->m_page_header.m_page_lsn_lo;
+
+ if(f_undo.m_lsn <= lsn)
+ {
+ Uint32 tableId= pageP->m_table_id;
+ Uint32 fragId = pageP->m_fragment_id;
+
+ f_undo.m_table_ptr.i= tableId;
+ ptrCheckGuard(f_undo.m_table_ptr, cnoOfTablerec, tablerec);
+
+ getFragmentrec(f_undo.m_fragment_ptr, fragId, f_undo.m_table_ptr.p);
+
+ if(!f_undo.m_fragment_ptr.p->m_undo_complete)
+ {
+ f_undo.m_page_ptr.i = page_id;
+ f_undo.m_page_ptr.p = pageP;
+
+ ndbout_c("applying %lld", f_undo.m_lsn);
+ /**
+ * Apply undo record
+ */
+ switch(f_undo.m_type){
+ case File_formats::Undofile::UNDO_TUP_ALLOC:
+ disk_restart_undo_alloc(&f_undo);
+ break;
+ case File_formats::Undofile::UNDO_TUP_UPDATE:
+ disk_restart_undo_update(&f_undo);
+ break;
+ case File_formats::Undofile::UNDO_TUP_FREE:
+ disk_restart_undo_free(&f_undo);
+ break;
+ default:
+ ndbrequire(false);
+ }
+ m_pgman.update_lsn(f_undo.m_key, f_undo.m_lsn);
+ }
+ else
+ {
+ ndbout_c("lsn %lld frag undo complete", f_undo.m_lsn);
+ }
+ }
+ else
+ {
+ ndbout_c("f_undo.m_lsn %lld > lsn %lld -> skip",
+ f_undo.m_lsn, lsn);
+ }
+ disk_restart_undo_next(signal);
+}
+
+void
+Dbtup::disk_restart_undo_alloc(Apply_undo* undo)
+{
+ if(undo->m_table_ptr.p->m_attributes[DD].m_no_of_varsize == 0)
+ ((Fix_page*)undo->m_page_ptr.p)->free_record(undo->m_key.m_page_idx);
+ else
+ ((Var_page*)undo->m_page_ptr.p)->free_record(undo->m_key.m_page_idx, 0);
+}
+
+void
+Dbtup::disk_restart_undo_update(Apply_undo* undo)
+{
+ Uint32* ptr;
+ Uint32 len= undo->m_len - 4;
+ if(undo->m_table_ptr.p->m_attributes[DD].m_no_of_varsize == 0)
+ {
+ ptr= ((Fix_page*)undo->m_page_ptr.p)->get_ptr(undo->m_key.m_page_idx, len);
+ ndbrequire(len == undo->m_table_ptr.p->m_offsets[DD].m_fix_header_size);
+ }
+ else
+ {
+ ptr= ((Var_page*)undo->m_page_ptr.p)->get_ptr(undo->m_key.m_page_idx);
+ abort();
+ }
+
+ const Disk_undo::Update *update = (const Disk_undo::Update*)undo->m_ptr;
+ const Uint32* src= update->m_data;
+ memcpy(ptr, src, 4 * len);
+}
+
+void
+Dbtup::disk_restart_undo_free(Apply_undo* undo)
+{
+ Uint32* ptr, idx;
+ Uint32 len= undo->m_len - 4;
+ if(undo->m_table_ptr.p->m_attributes[DD].m_no_of_varsize == 0)
+ {
+ ndbrequire(len == undo->m_table_ptr.p->m_offsets[DD].m_fix_header_size);
+ idx= ((Fix_page*)undo->m_page_ptr.p)->alloc_record();
+ ptr= ((Fix_page*)undo->m_page_ptr.p)->get_ptr(idx, len);
+ }
+ else
+ {
+ abort();
+ }
+
+ ndbrequire(idx == undo->m_key.m_page_idx);
+ const Disk_undo::Free *free = (const Disk_undo::Free*)undo->m_ptr;
+ const Uint32* src= free->m_data;
+ memcpy(ptr, src, 4 * len);
+}
--- 1.5/ndb/src/kernel/blocks/dbtup/tuppage.cpp Tue Apr 5 22:20:06 2005
+++ 1.6/ndb/src/kernel/blocks/dbtup/tuppage.cpp Fri Apr 29 16:19:45 2005
@@ -16,6 +16,7 @@
#include <ndb_global.h>
#include "tuppage.hpp"
+#include "Dbtup.hpp"
Uint32
Tup_fixsize_page::alloc_record()
@@ -57,6 +58,8 @@
assert(freePageOffset < DATA_WORDS);
m_data[freePageOffset] = (0x8000 << 16) + startOfList;
+ m_data[freePageOffset + 1] = Dbtup::Tuple_header::FREE;
+
if (endOfList == 0xFFFF) {
assert(startOfList == 0xFFFF);
next_free_index = (freePageOffset << 16) + freePageOffset;
--- 1.9/ndb/src/kernel/blocks/dbtup/tuppage.hpp Tue Apr 5 22:20:06 2005
+++ 1.10/ndb/src/kernel/blocks/dbtup/tuppage.hpp Fri Apr 29 16:19:45 2005
@@ -45,8 +45,9 @@
Uint32 m_page_no;
Uint32 m_file_no;
Uint32 m_table_id;
+ Uint32 m_fragment_id;
Uint32 m_extent_info_ptr;
- Uint32 unused_ph[12];
+ Uint32 unused_ph[11];
STATIC_CONST( DATA_WORDS = File_formats::PAGE_SIZE_WORDS - 32 );
@@ -72,8 +73,9 @@
Uint32 m_page_no;
Uint32 m_file_no;
Uint32 m_table_id;
+ Uint32 m_fragment_id;
Uint32 m_extent_info_ptr;
- Uint32 unused_ph[12];
+ Uint32 unused_ph[11];
STATIC_CONST( DATA_WORDS = File_formats::PAGE_SIZE_WORDS - 32 );
@@ -89,7 +91,6 @@
* return page_idx
**/
Uint32 alloc_record();
-
Uint32 free_record(Uint32 page_idx);
};
@@ -112,10 +113,11 @@
Uint32 m_page_no;
Uint32 m_file_no;
Uint32 m_table_id;
+ Uint32 m_fragment_id;
Uint32 m_extent_info_ptr;
Uint32 high_index; // size of index + 1
Uint32 insert_pos;
- Uint32 unused_ph[10];
+ Uint32 unused_ph[9];
STATIC_CONST( DATA_WORDS = File_formats::PAGE_SIZE_WORDS - 32 );
STATIC_CONST( CHAIN = 0x8000 );
--- 1.39/ndb/src/kernel/blocks/lgman.cpp Thu Apr 28 15:34:46 2005
+++ 1.40/ndb/src/kernel/blocks/lgman.cpp Fri Apr 29 16:19:45 2005
@@ -24,7 +24,8 @@
#include <signaldata/LCP.hpp>
#include <signaldata/SumaImpl.hpp>
#include <signaldata/LgmanContinueB.hpp>
-#include <../ndbfs/Ndbfs.hpp>
+#include "ndbfs/Ndbfs.hpp"
+#include "dbtup/Dbtup.hpp"
#include <EventLogger.hpp>
extern EventLogger g_eventLogger;
@@ -1943,19 +1944,30 @@
void
Lgman::execute_undo_record(Signal* signal)
{
- const Uint32* ptr;
Uint64 lsn;
+ const Uint32* ptr;
+ Dbtup* tup= (Dbtup*)globalData.getBlock(DBTUP);
if((ptr = get_next_undo_record(&lsn)))
{
Uint32 len= (* ptr) & 0xFFFF;
Uint32 type= (* ptr) >> 16;
Uint32 mask= type & ~(Uint32)File_formats::Undofile::UNDO_NEXT_LSN;
switch(mask){
+ case File_formats::Undofile::UNDO_END:
+ ndbout_c("Found end of log");
+ stop_run_undo_log(signal);
+ return;
case File_formats::Undofile::UNDO_LCP:
case File_formats::Undofile::UNDO_LCP_FIRST:
{
Uint32 lcp = * (ptr - len + 1);
printf("Found LCP: %d looking for %d", lcp, m_latest_lcp);
+ if(lcp > m_latest_lcp)
+ {
+ // Just ignore
+ break;
+ }
+
if(lcp < m_latest_lcp ||
(lcp == m_latest_lcp &&
mask == File_formats::Undofile::UNDO_LCP_FIRST))
@@ -1964,21 +1976,20 @@
stop_run_undo_log(signal);
return;
}
- ndbout_c("");
- break;
+ // Fallthrough
}
- case File_formats::Undofile::UNDO_END:
- ndbout_c("Found end of log");
- stop_run_undo_log(signal);
+ case File_formats::Undofile::UNDO_TUP_ALLOC:
+ case File_formats::Undofile::UNDO_TUP_UPDATE:
+ case File_formats::Undofile::UNDO_TUP_FREE:
+ tup->disk_restart_undo(signal, lsn, mask, ptr - len + 1, len);
return;
- break;
default:
- (void)1; //ndbout_c("Found undo: %d len: %d lsn: %lld", type & 0x7FFF, len, lsn);
+ ndbrequire(false);
}
}
-
signal->theData[0] = LgmanContinueB::EXECUTE_UNDO_RECORD;
- sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB);
+ sendSignal(LGMAN_REF, GSN_CONTINUEB, signal, 1, JBB);
+
return;
}
--- 1.61/ndb/src/kernel/blocks/dbtup/Dbtup.hpp Mon Apr 25 16:26:48 2005
+++ 1.62/ndb/src/kernel/blocks/dbtup/Dbtup.hpp Fri Apr 29 16:19:45 2005
@@ -375,6 +375,114 @@
void scanClose(Signal* signal, ScanOpPtr scanPtr);
void releaseScanOp(ScanOpPtr& scanPtr);
+ typedef Tup_page Page;
+ typedef Ptr<Page> PagePtr;
+
+ struct Page_request
+ {
+ Page_request() {}
+ Local_key m_key;
+ Uint16 m_free_space; // in bytes/records
+ Uint16 m_list_index; // in Disk_alloc_info.m_page_requests
+ Uint32 m_frag_ptr_i;
+ Uint32 m_extent_info_ptr;
+ Uint32 m_ref_count; // Waiters for page
+ union {
+ Uint32 nextList;
+ Uint32 nextPool;
+ };
+ Uint32 prevList;
+ }; // 32 bytes
+
+ STATIC_CONST( EXTENT_SEARCH_MATRIX_COLS = 4 ); // Guarantee size
+ STATIC_CONST( EXTENT_SEARCH_MATRIX_ROWS = 5 ); // Total size
+ STATIC_CONST( EXTENT_SEARCH_MATRIX_SIZE = 20 );
+
+ struct Extent_info
+ {
+ Local_key m_key;
+ Uint32 m_free_space;
+ Uint32 m_free_matrix_pos;
+ Uint16 m_free_page_count[EXTENT_SEARCH_MATRIX_COLS];
+ union {
+ Uint32 nextList;
+ Uint32 nextPool;
+ };
+ Uint32 prevList;
+ }; // 32bytes
+
+ typedef LocalDLList<Extent_info> Extent_list;
+ typedef LocalDLList<Page_request> Page_request_list;
+
+ struct Tablerec;
+ struct Disk_alloc_info
+ {
+ Disk_alloc_info() {}
+ Disk_alloc_info(const Tablerec* tabPtrP,
+ Uint32 extent_size_in_pages);
+
+ /**
+ * Disk allocation
+ *
+ * 1) Allocate space on pages that already are dirty
+ * (4 free lists for different requests)
+ * 2) Allocate space on pages waiting to maped that will be dirty
+ * (4 free lists for different requests)
+ * 3) Check if "current" extent can accommodate request
+ * If so, allocate page from there
+ * Else put "current" into free matrix
+ * 4) Search free matrix for extent with greatest amount of free space
+ * while still accommodating current request
+ * (20 free lists for different requests)
+ */
+
+ /**
+ * Free list of pages in different size
+ * that are dirty
+ */
+ DLList<Page>::Head m_dirty_pages[MAX_FREE_LIST]; // In real page id's
+
+ /**
+ * Requests (for update) that have sufficient space left after request
+ * these are currently being "mapped"
+ */
+ DLList<Page_request>::Head m_page_requests[MAX_FREE_LIST];
+
+ /**
+ * Current extent
+ */
+ Uint32 m_curr_extent_info_ptr_i;
+
+ /**
+ *
+ */
+ STATIC_CONST( SZ = EXTENT_SEARCH_MATRIX_SIZE );
+ Uint32 m_extent_search_matrix[SZ]; // 4x4
+ DLList<Extent_info>::Head m_free_extents[SZ];
+ Uint32 m_total_extent_free_space_thresholds[EXTENT_SEARCH_MATRIX_ROWS];
+ Uint32 m_page_free_bits_map[EXTENT_SEARCH_MATRIX_COLS];
+
+ Uint32 find_extent(Uint32 sz) const;
+ Uint32 calc_extent_pos(const Extent_info*) const;
+
+ /**
+ * Compute minimum free space on page given bits
+ */
+ Uint32 calc_page_free_space(Uint32 bits) const {
+ return m_page_free_bits_map[bits];
+ }
+
+ /**
+ * Compute page free bits, given free space
+ */
+ Uint32 calc_page_free_bits(Uint32 free) const {
+ for(Uint32 i = 0; i<EXTENT_SEARCH_MATRIX_COLS-1; i++)
+ if(free >= m_page_free_bits_map[i])
+ return i;
+ return EXTENT_SEARCH_MATRIX_COLS - 1;
+ }
+ };
+
struct Fragrecord {
Uint32 nextStartRange;
Uint32 currentPageRange;
@@ -392,6 +500,11 @@
DLList<ScanOp> m_scanList;
Fragrecord(ArrayPool<ScanOp> & scanOpPool) : m_scanList(scanOpPool) {}
+
+ bool m_undo_complete;
+ Uint32 m_tablespace_id;
+ Uint32 m_logfile_group_id;
+ Disk_alloc_info m_disk_alloc_info;
};
typedef Ptr<Fragrecord> FragrecordPtr;
@@ -520,9 +633,6 @@
};
typedef Ptr<Operationrec> OperationrecPtr;
- typedef Tup_page Page;
- typedef Ptr<Page> PagePtr;
-
/* ****************************** PAGE RANGE RECORD ************************** */
/* PAGE RANGES AND BASE PAGE ID. EACH RANGE HAS A CORRESPONDING BASE PAGE ID */
/* THAT IS USED TO CALCULATE REAL PAGE ID FROM A FRAGMENT PAGE ID AND A TABLE */
@@ -628,111 +738,6 @@
*/
ArrayPool<TupTriggerData> c_triggerPool;
- struct Page_request
- {
- Page_request() {}
- Local_key m_key;
- Uint16 m_free_space; // in bytes/records
- Uint16 m_list_index; // in Disk_alloc_info.m_page_requests
- Uint32 m_table_id;
- Uint32 m_extent_info_ptr;
- Uint32 m_ref_count; // Waiters for page
- union {
- Uint32 nextList;
- Uint32 nextPool;
- };
- Uint32 prevList;
- }; // 32 bytes
-
- STATIC_CONST( EXTENT_SEARCH_MATRIX_COLS = 4 ); // Guarantee size
- STATIC_CONST( EXTENT_SEARCH_MATRIX_ROWS = 5 ); // Total size
- STATIC_CONST( EXTENT_SEARCH_MATRIX_SIZE = 20 );
-
- struct Extent_info
- {
- Local_key m_key;
- Uint32 m_free_space;
- Uint32 m_free_matrix_pos;
- Uint16 m_free_page_count[EXTENT_SEARCH_MATRIX_COLS];
- union {
- Uint32 nextList;
- Uint32 nextPool;
- };
- Uint32 prevList;
- }; // 32bytes
-
- typedef LocalDLList<Extent_info> Extent_list;
- typedef LocalDLList<Page_request> Page_request_list;
-
- struct Tablerec;
- struct Disk_alloc_info
- {
- Disk_alloc_info() {}
- Disk_alloc_info(const Tablerec* tabPtrP,
- Uint32 extent_size_in_pages);
-
- /**
- * Disk allocation
- *
- * 1) Allocate space on pages that already are dirty
- * (4 free lists for different requests)
- * 2) Allocate space on pages waiting to maped that will be dirty
- * (4 free lists for different requests)
- * 3) Check if "current" extent can accommodate request
- * If so, allocate page from there
- * Else put "current" into free matrix
- * 4) Search free matrix for extent with greatest amount of free space
- * while still accommodating current request
- * (20 free lists for different requests)
- */
-
- /**
- * Free list of pages in different size
- * that are dirty
- */
- DLList<Page>::Head m_dirty_pages[MAX_FREE_LIST]; // In real page id's
-
- /**
- * Requests (for update) that have sufficient space left after request
- * these are currently being "mapped"
- */
- DLList<Page_request>::Head m_page_requests[MAX_FREE_LIST];
-
- /**
- * Current extent
- */
- Uint32 m_curr_extent_info_ptr_i;
-
- /**
- *
- */
- STATIC_CONST( SZ = EXTENT_SEARCH_MATRIX_SIZE );
- Uint32 m_extent_search_matrix[SZ]; // 4x4
- DLList<Extent_info>::Head m_free_extents[SZ];
- Uint32 m_total_extent_free_space_thresholds[EXTENT_SEARCH_MATRIX_ROWS];
- Uint32 m_page_free_bits_map[EXTENT_SEARCH_MATRIX_COLS];
-
- Uint32 find_extent(Uint32 sz) const;
- Uint32 calc_extent_pos(const Extent_info*) const;
-
- /**
- * Compute minimum free space on page given bits
- */
- Uint32 calc_page_free_space(Uint32 bits) const {
- return m_page_free_bits_map[bits];
- }
-
- /**
- * Compute page free bits, given free space
- */
- Uint32 calc_page_free_bits(Uint32 free) const {
- for(Uint32 i = 0; i<EXTENT_SEARCH_MATRIX_COLS-1; i++)
- if(free >= m_page_free_bits_map[i])
- return i;
- return EXTENT_SEARCH_MATRIX_COLS - 1;
- }
- };
-
/* ************ TABLE RECORD ************ */
/* THIS RECORD FORMS A LIST OF TABLE */
/* REFERENCE INFORMATION. ONE RECORD */
@@ -829,10 +834,6 @@
Uint32 fragid[MAX_FRAG_PER_NODE];
Uint32 fragrec[MAX_FRAG_PER_NODE];
- Uint32 m_tablespace_id;
- Uint32 m_logfile_group_id;
- Disk_alloc_info m_disk_alloc_info;
-
struct {
Uint32 tabUserPtr;
Uint32 tabUserRef;
@@ -1521,7 +1522,7 @@
//------------------------------------------------------------------
int handleInsertReq(Signal* signal,
Ptr<Operationrec> regOperPtr,
- Fragrecord* const regFragPtr,
+ Ptr<Fragrecord>,
Tablerec* const regTabPtr,
KeyReqStruct* req_struct);
@@ -2172,8 +2173,8 @@
void sendFSREMOVEREQ(Signal* signal, TablerecPtr tabPtr);
void releaseFragment(Signal* signal, Uint32 tableId);
- void drop_table_free_exent(Signal*, TablerecPtr tabPtr, Uint32);
-
+ void drop_fragment_free_exent(Signal*, TablerecPtr, FragrecordPtr, Uint32);
+
// Initialisation
void initData();
void initRecords();
@@ -2280,10 +2281,12 @@
Uint32 get_alloc_page(Fragrecord* const, Uint32);
void update_free_page_list(Fragrecord* const, Var_page*);
-
+
+#if 0
Uint32 calc_free_list(const Tablerec* regTabPtr, Uint32 sz) const {
return regTabPtr->m_disk_alloc_info.calc_page_free_bits(sz);
}
+#endif
Uint32 calculate_free_list_impl(Uint32) const ;
void remove_free_page(Fragrecord*, Var_page*, Uint32);
@@ -2422,25 +2425,26 @@
* key.m_page_no contains disk page
* key.m_page_idx contains byte preallocated
*/
- int disk_page_prealloc(Signal*, Fragrecord*,Tablerec*,Local_key*, Uint32 sz);
- void disk_page_abort_prealloc(Signal*, Tablerec*,Local_key*, Uint32);
+ int disk_page_prealloc(Signal*, Ptr<Fragrecord>, Local_key*, Uint32);
+ void disk_page_abort_prealloc(Signal*, Fragrecord*,Local_key*, Uint32);
void disk_page_abort_prealloc_callback(Signal*, Uint32, Uint32);
- void disk_page_abort_prealloc_callback_1(Signal*, Tablerec*,
+ void disk_page_abort_prealloc_callback_1(Signal*, Fragrecord*,
PagePtr, Uint32);
void disk_page_alloc_callback(Signal*, Uint32 page_request, Uint32 page_id);
void disk_page_alloc_initial_callback(Signal*, Uint32, Uint32);
void disk_page_alloc_callback_common(Signal*,
Ptr<Page_request>,
- Ptr<Tablerec>,
+ Ptr<Fragrecord>,
Ptr<GlobalPage>);
- void disk_page_free(Signal*, Tablerec*, Local_key*, PagePtr, Uint32);
+ void disk_page_free(Signal*,
+ Tablerec*, Fragrecord*, Local_key*, PagePtr, Uint32);
- void disk_page_update_free_space(Tablerec*, Ptr<Page_request>,
+ void disk_page_update_free_space(Fragrecord*, Ptr<Page_request>,
DLList<Page_request>::Head list[],
Uint32 i, Uint32 sz);
- void disk_page_update_free_space(Tablerec*, PagePtr, Uint32 i);
+ void disk_page_update_free_space(Fragrecord*, PagePtr, Uint32 i);
void disk_page_unmap_callback(Signal*, Uint32 tableId, Uint32 page_id);
void disk_page_commit_callback(Signal*, Uint32 opPtrI, Uint32 page_id);
@@ -2464,9 +2468,27 @@
const Local_key* key);
void disk_restart_page_bits(Uint32 tableId, Uint32 fragId,
const Local_key*, Uint32 bits);
- void disk_restart_exec_undo(Signal* signal,
- Uint32 type, const Uint32 * ptr, Uint32 len);
+ void disk_restart_undo(Signal* signal, Uint64 lsn,
+ Uint32 type, const Uint32 * ptr, Uint32 len);
+
+ struct Apply_undo
+ {
+ Uint32 m_type, m_len;
+ const Uint32* m_ptr;
+ Uint64 m_lsn;
+ Ptr<Tablerec> m_table_ptr;
+ Ptr<Fragrecord> m_fragment_ptr;
+ Ptr<Page> m_page_ptr;
+ Local_key m_key;
+ };
+
private:
+ void disk_restart_undo_next(Signal*);
+ void disk_restart_undo_lcp(Uint32, Uint32);
+ void disk_restart_undo_callback(Signal* signal, Uint32, Uint32);
+ void disk_restart_undo_alloc(Apply_undo*);
+ void disk_restart_undo_update(Apply_undo*);
+ void disk_restart_undo_free(Apply_undo*);
void fix_commit_order(OperationrecPtr);
void commit_operation(Signal*, Uint32, Tuple_header*, Page*,
--- 1.32/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp Wed Apr 6 08:18:14 2005
+++ 1.33/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp Fri Apr 29 16:19:45 2005
@@ -129,7 +129,7 @@
jam();
Local_key key;
memcpy(&key, copy->get_disk_ref_ptr(regTabPtr.p), sizeof(key));
- disk_page_abort_prealloc(signal, regTabPtr.p, &key, key.m_page_idx);
+ disk_page_abort_prealloc(signal, regFragPtr.p, &key, key.m_page_idx);
}
Uint32 bits= copy->m_header_bits;
@@ -175,7 +175,7 @@
if(regOperPtr.p->is_first_operation() && regOperPtr.p->is_last_operation())
{
- c_lgman->free_log_space(regTabPtr.p->m_logfile_group_id,
+ c_lgman->free_log_space(regFragPtr.p->m_logfile_group_id,
regOperPtr.p->m_undo_buffer_space);
}
@@ -320,7 +320,7 @@
tabPtr.i= fragPtr.p->fragTableId;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
- c_lgman->free_log_space(tabPtr.p->m_logfile_group_id,
+ c_lgman->free_log_space(fragPtr.p->m_logfile_group_id,
regOperPtr->m_undo_buffer_space);
PagePtr tmp;
--- 1.47/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp Wed Apr 6 08:18:14 2005
+++ 1.48/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp Fri Apr 29 16:19:45 2005
@@ -160,7 +160,8 @@
Ptr<GlobalPage> disk_page;
m_global_page_pool.getPtr(disk_page,
regOperPtr->m_commit_disk_callback_page);
- disk_page_free(signal, regTabPtr, &disk, *(PagePtr*)&disk_page, gci);
+ disk_page_free(signal, regTabPtr, regFragPtr,
+ &disk, *(PagePtr*)&disk_page, gci);
}
}
@@ -256,7 +257,7 @@
{
Local_key key;
memcpy(&key, copy->get_disk_ref_ptr(regTabPtr), sizeof(Local_key));
- Uint32 logfile_group_id= regTabPtr->m_logfile_group_id;
+ Uint32 logfile_group_id= regFragPtr->m_logfile_group_id;
Page* page= (Page*)m_pgman.m_ptr.p;
Uint32 sz, *dst;
@@ -515,7 +516,7 @@
safe_cast(&Dbtup::disk_page_log_buffer_callback);
Uint32 sz= regOperPtr.p->m_undo_buffer_space;
- Logfile_client lgman(this, c_lgman, regTabPtr.p->m_logfile_group_id);
+ Logfile_client lgman(this, c_lgman, regFragPtr.p->m_logfile_group_id);
int res= lgman.get_log_buffer(signal, sz, &cb);
switch(res){
case 0:
--- 1.62/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp Fri Apr 15 12:41:35 2005
+++ 1.63/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp Fri Apr 29 16:19:45 2005
@@ -895,7 +895,7 @@
jam();
do_insert:
if (handleInsertReq(signal, operPtr,
- regFragPtr, regTabPtr, &req_struct) == -1)
+ fragptr, regTabPtr, &req_struct) == -1)
{
return;
}
@@ -1154,8 +1154,8 @@
Uint32 sz= operPtrP->m_undo_buffer_space=
(sizeof(Dbtup::Disk_undo::Update) >> 2) + sizes[DD] - 1;
- terrorCode= c_lgman->alloc_log_space(regTabPtr->m_logfile_group_id,
- sz);
+ terrorCode= c_lgman->alloc_log_space(regFragPtr->m_logfile_group_id,
+ sz);
if(terrorCode)
{
goto error;
@@ -1284,10 +1284,11 @@
int Dbtup::handleInsertReq(Signal* signal,
Ptr<Operationrec> regOperPtr,
- Fragrecord* const regFragPtr,
+ Ptr<Fragrecord> fragPtr,
Tablerec* const regTabPtr,
KeyReqStruct *req_struct)
{
+ Fragrecord* regFragPtr = fragPtr.p;
Uint32 *dst, *ptr= 0;
Tuple_header *base= req_struct->m_tuple_ptr, *org= base;
Tuple_header *tuple_ptr;
@@ -1316,8 +1317,8 @@
if(regTabPtr->m_no_of_disk_attributes)
{
int res;
- if((res= c_lgman->alloc_log_space(regTabPtr->m_logfile_group_id,
- regOperPtr.p->m_undo_buffer_space)))
+ if((res= c_lgman->alloc_log_space(regFragPtr->m_logfile_group_id,
+ regOperPtr.p->m_undo_buffer_space)))
{
terrorCode= res;
goto error;
@@ -1386,7 +1387,7 @@
Uint32 size= regTabPtr->m_attributes[DD].m_no_of_varsize == 0 ?
1 : sizes[2+DD];
- int ret= disk_page_prealloc(signal, regFragPtr, regTabPtr, &tmp, size);
+ int ret= disk_page_prealloc(signal, fragPtr, &tmp, size);
ndbassert(ret >= 0);
regOperPtr.p->op_struct.m_disk_preallocated= 1;
@@ -1484,8 +1485,8 @@
regOperPtr->m_undo_buffer_space= sz;
int res;
- if((res= c_lgman->alloc_log_space(regTabPtr->m_logfile_group_id,
- sz)))
+ if((res= c_lgman->alloc_log_space(regFragPtr->m_logfile_group_id,
+ sz)))
{
terrorCode= res;
goto error;
--- 1.13/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp Sun Apr 24 17:38:12 2005
+++ 1.14/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp Fri Apr 29 16:19:45 2005
@@ -177,7 +177,6 @@
Fix_page* regPagePtr)
{
Uint32 free= regPagePtr->free_record(key->m_page_idx);
- regPagePtr->m_data[key->m_page_idx + 1] = Tuple_header::FREE;
if(free == 1)
{
--- 1.31/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp Mon Apr 11 14:40:27 2005
+++ 1.32/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp Fri Apr 29 16:19:45 2005
@@ -205,8 +205,11 @@
TablerecPtr tabPtr;
tabPtr.i= dataPtr;
+ FragrecordPtr fragPtr;
+ fragPtr.i= signal->theData[2];
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
- drop_table_free_exent(signal, tabPtr, signal->theData[2]);
+ ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
+ drop_fragment_free_exent(signal, tabPtr, fragPtr, signal->theData[3]);
return;
break;
default:
--- 1.28/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp Fri Apr 15 09:14:17 2005
+++ 1.29/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp Fri Apr 29 16:19:45 2005
@@ -143,7 +143,9 @@
regFragPtr.p->free_var_page_array[3]= RNIL;
regFragPtr.p->fragTableId= regTabPtr.i;
regFragPtr.p->fragmentId= fragId;
-
+ regFragPtr.p->m_tablespace_id= tablespace;
+ regFragPtr.p->m_undo_complete= false;
+
Uint32 noAllocatedPages= allocFragPages(regFragPtr.p, pages);
if (noAllocatedPages == 0) {
@@ -200,7 +202,6 @@
regTabPtr.p->noOfKeyAttr= noOfKeyAttr;
regTabPtr.p->noOfCharsets= noOfCharsets;
regTabPtr.p->m_no_of_attributes= noOfAttributes;
- regTabPtr.p->m_tablespace_id= tablespace;
regTabPtr.p->notNullAttributeMask.clear();
@@ -312,7 +313,9 @@
signal, 2, JBB);
if(lastAttr)
+ {
releaseFragoperrec(fragOperPtr);
+ }
return;
}
@@ -524,15 +527,23 @@
Uint32 extent_size= 1;
if(regTabPtr.p->m_no_of_disk_attributes)
{
- CreateFilegroupImplReq rep;
- Tablespace_client tsman(0, c_tsman, 0, 0, regTabPtr.p->m_tablespace_id);
- ndbrequire(tsman.get_tablespace_info(&rep) == 0);
- extent_size= rep.tablespace.extent_size;
- regTabPtr.p->m_logfile_group_id= rep.tablespace.logfile_group_id;
+ for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++)
+ {
+ if((regFragPtr.i = regTabPtr.p->fragrec[i]) != RNIL)
+ {
+ ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
+ CreateFilegroupImplReq rep;
+ Tablespace_client tsman(0, c_tsman, 0, 0,
+ regFragPtr.p->m_tablespace_id);
+ ndbrequire(tsman.get_tablespace_info(&rep) == 0);
+ extent_size= rep.tablespace.extent_size;
+ regFragPtr.p->m_logfile_group_id= rep.tablespace.logfile_group_id;
+
+ new (®FragPtr.p->m_disk_alloc_info)
+ Disk_alloc_info(regTabPtr.p, extent_size);
+ }
+ }
}
- new (®TabPtr.p->m_disk_alloc_info)
- Disk_alloc_info(regTabPtr.p, extent_size);
-
#if 0
ndbout << *regTabPtr.p << endl;
Uint32 idx= regTabPtr.p->tabDescriptor;
@@ -766,17 +777,22 @@
FragrecordPtr regFragPtr;
regFragPtr.i= fragIndex;
ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
- releaseFragPages(regFragPtr.p);
- tabPtr.p->fragid[i]= RNIL;
- tabPtr.p->fragrec[i]= RNIL;
- releaseFragrec(regFragPtr);
-
- signal->theData[0]= ZREL_FRAG;
- signal->theData[1]= tableId;
- sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
+ Disk_alloc_info& alloc= regFragPtr.p->m_disk_alloc_info;
+ if(alloc.m_curr_extent_info_ptr_i != RNIL)
+ {
+ LocalDLList<Extent_info>
+ list(c_extent_pool, alloc.m_free_extents[0]);
+ Ptr<Extent_info> ext_ptr;
+ c_extent_pool.getPtr(ext_ptr, alloc.m_curr_extent_info_ptr_i);
+ list.add(ext_ptr);
+ alloc.m_curr_extent_info_ptr_i= RNIL;
+ }
+
+ drop_fragment_free_exent(signal, tabPtr, regFragPtr, 0);
return;
}
+
sendFSREMOVEREQ(signal, tabPtr);
}
@@ -807,36 +823,37 @@
TablerecPtr tabPtr;
tabPtr.i= fsConf->userPointer;
ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
-
- if(tabPtr.p->m_disk_alloc_info.m_curr_extent_info_ptr_i != RNIL)
- {
- LocalDLList<Extent_info>
- list(c_extent_pool, tabPtr.p->m_disk_alloc_info.m_free_extents[0]);
- Ptr<Extent_info> ext_ptr;
- c_extent_pool.getPtr(ext_ptr,
- tabPtr.p->m_disk_alloc_info.m_curr_extent_info_ptr_i);
- list.add(ext_ptr);
- tabPtr.p->m_disk_alloc_info.m_curr_extent_info_ptr_i= RNIL;
- }
-
- drop_table_free_exent(signal, tabPtr, 0);
+
+ DropTabConf * const dropConf= (DropTabConf *)signal->getDataPtrSend();
+ dropConf->senderRef= reference();
+ dropConf->senderData= tabPtr.p->m_dropTable.tabUserPtr;
+ dropConf->tableId= tabPtr.i;
+ sendSignal(tabPtr.p->m_dropTable.tabUserRef, GSN_DROP_TAB_CONF,
+ signal, DropTabConf::SignalLength, JBB);
+
+ releaseTabDescr(tabPtr.p);
+ initTab(tabPtr.p);
}
void
-Dbtup::drop_table_free_exent(Signal *signal, TablerecPtr tabPtr, Uint32 pos)
+Dbtup::drop_fragment_free_exent(Signal *signal,
+ TablerecPtr tabPtr,
+ FragrecordPtr fragPtr,
+ Uint32 pos)
{
+ Disk_alloc_info& alloc_info= fragPtr.p->m_disk_alloc_info;
for(; pos<EXTENT_SEARCH_MATRIX_SIZE; pos++)
{
- if(!tabPtr.p->m_disk_alloc_info.m_free_extents[pos].isEmpty())
+ if(!alloc_info.m_free_extents[pos].isEmpty())
{
jam();
LocalDLList<Extent_info>
- list(c_extent_pool, tabPtr.p->m_disk_alloc_info.m_free_extents[pos]);
+ list(c_extent_pool, alloc_info.m_free_extents[pos]);
Ptr<Extent_info> ext_ptr;
list.first(ext_ptr);
- Tablespace_client tsman(signal, c_tsman, tabPtr.i, 0,
- tabPtr.p->m_tablespace_id);
+ Tablespace_client tsman(signal, c_tsman, tabPtr.i, fragPtr.p->fragmentId,
+ fragPtr.p->m_tablespace_id);
tsman.free_extent(&ext_ptr.p->m_key);
@@ -844,29 +861,36 @@
signal->theData[0] = ZFREE_EXTENT;
signal->theData[1] = tabPtr.i;
- signal->theData[2] = pos;
- sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB);
+ signal->theData[2] = fragPtr.i;
+ signal->theData[3] = pos;
+ sendSignal(cownref, GSN_CONTINUEB, signal, 4, JBB);
return;
}
}
-
+
ArrayPool<Page> *cheat_pool= (ArrayPool<Page>*)&m_global_page_pool;
for(pos= 0; pos<MAX_FREE_LIST; pos++)
{
- ndbrequire(tabPtr.p->m_disk_alloc_info.m_page_requests[pos].isEmpty());
- LocalDLList<Page> list(* cheat_pool, tabPtr.p->m_disk_alloc_info.m_dirty_pages[pos]);
+ ndbrequire(alloc_info.m_page_requests[pos].isEmpty());
+ LocalDLList<Page> list(* cheat_pool, alloc_info.m_dirty_pages[pos]);
list.remove();
}
+
+ releaseFragPages(fragPtr.p);
- DropTabConf * const dropConf= (DropTabConf *)signal->getDataPtrSend();
- dropConf->senderRef= reference();
- dropConf->senderData= tabPtr.p->m_dropTable.tabUserPtr;
- dropConf->tableId= tabPtr.i;
- sendSignal(tabPtr.p->m_dropTable.tabUserRef, GSN_DROP_TAB_CONF,
- signal, DropTabConf::SignalLength, JBB);
+ Uint32 i;
+ for(i= 0; i<MAX_FRAG_PER_NODE; i++)
+ if(tabPtr.p->fragrec[i] == fragPtr.i)
+ break;
+ ndbrequire(i != MAX_FRAG_PER_NODE);
+ tabPtr.p->fragid[i]= RNIL;
+ tabPtr.p->fragrec[i]= RNIL;
+ releaseFragrec(fragPtr);
- releaseTabDescr(tabPtr.p);
- initTab(tabPtr.p);
+ signal->theData[0]= ZREL_FRAG;
+ signal->theData[1]= tabPtr.i;
+ sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
+ return;
}
void Dbtup::execFSREMOVEREF(Signal* signal)
| Thread |
|---|
| • bk commit into 5.1-ndb tree (joreland:1.1879) | jonas.oreland | 29 Apr |
