AREXPORT ArMapId &ArMapId::operator=(const ArMapId &other) { if (&other != this) { mySourceName = other.mySourceName; myFileName = other.myFileName; delete [] myChecksum; myChecksum = NULL; myChecksumLength = 0; delete [] myDisplayChecksum; myDisplayChecksum = NULL; myDisplayChecksumLength = 0; if (other.myChecksumLength > 0) { setChecksum(other.myChecksum, other.myChecksumLength); } mySize = other.mySize; myTimestamp = other.myTimestamp; } return *this; }
void GREv0Layer::computeCalculateFields() { computeCalculateFieldsInner(); if (getGreHeader()->checksumBit == 0) return; // calculate checksum setChecksum(0); ScalarBuffer<uint16_t> buffer; buffer.buffer = (uint16_t*)m_Data; buffer.len = m_DataLen; size_t checksum = compute_checksum(&buffer, 1); setChecksum(checksum); }
String MessageBuilder::getMessage(){ String output = String('>') + m_flags + m_address_from + m_address_to + m_message_type + m_message_sub_type + m_data + "00;"; setChecksum(output); return output; }
/** * set the given state and updates the codes * @param _value the new state {STATE_on,STATE_off} */ void Tadiran::setState(uint8_t _value) { state=_value; if (state & 1) codes[9] = CODE_high; else codes[9] = CODE_low; setChecksum(); }
/** * set the given fan and updates the codes * @param _value the new fan speed {FAN_auto, FAN_1, FAN_2, FAN_3} */ void Tadiran::setFan(uint8_t _value) { fan=_value; if (fan & 2) codes[13]=CODE_high; else codes[13]=CODE_low; if (fan & 1) codes[11]=CODE_high; else codes[11]=CODE_low; setChecksum(); }
/** * set the given mode and updates the codes * @param _value the new mode {MODE_auto,MODE_cold,MODE_dry,MODE_fan,MODE_heat} */ void Tadiran::setMode(uint8_t _value) { mode=_value; if (mode & 4) codes[7]=CODE_high; else codes[7]=CODE_low; if (mode & 2) codes[5]=CODE_high; else codes[5]=CODE_low; if (mode & 1) codes[3]=CODE_high; else codes[3]=CODE_low; setChecksum(); }
AREXPORT ArMapId::ArMapId(const ArMapId &other) : mySourceName(other.mySourceName), myFileName(other.myFileName), myChecksum(NULL), myChecksumLength(0), myDisplayChecksum(NULL), myDisplayChecksumLength(0), mySize(other.mySize), myTimestamp(other.myTimestamp) { if (other.myChecksumLength > 0) { setChecksum(other.myChecksum, other.myChecksumLength); } }
/** * set the given temperature and updates the codes * @param _value the new value [16..30] */ void Tadiran::setTemeprature(uint8_t _value) { temperature=_value; if (temperature & 8) codes[25]=CODE_high; else codes[25]=CODE_low; if (temperature & 4) codes[23]=CODE_high; else codes[23]=CODE_low; if (temperature & 2) codes[21]=CODE_high; else codes[21]=CODE_low; if (temperature & 1) codes[19]=CODE_high; else codes[19]=CODE_low; setChecksum(); }
AREXPORT ArMapId::ArMapId(const char *sourceName, const char *fileName, const unsigned char *checksum, size_t checksumLength, long int size, const time_t timestamp) : mySourceName((sourceName != NULL) ? sourceName : ""), myFileName((fileName != NULL) ? fileName : ""), myChecksum(NULL), myChecksumLength(0), myDisplayChecksum(NULL), myDisplayChecksumLength(0), mySize(size), myTimestamp(timestamp) { if (checksumLength > 0) { setChecksum(checksum, checksumLength); } }
static int fill(CharBuff* toBeFilled, PckDescr* descr, char* payload) { int offset; if((toBeFilled == NULL) || (payload == NULL && descr->payloadSize > 0)) { return -1; } toBeFilled-> size = descr->totSize; toBeFilled-> content[0] = descr->header; toBeFilled-> content[fLength_header] = descr->payloadSize; //Copies the bytes of the command, after the header and the payload size: offset = fLength_header + fLength_payloadSize; memcpy(toBeFilled->content + offset, descr->command, descr->commandSize); if(descr->payloadSize > 0) { //Copies the actual content (payload): offset += descr->commandSize; memcpy(toBeFilled->content + offset, payload, descr->payloadSize); setChecksum(toBeFilled); } return 0; }
int insertFileIdentDesc(Directory *dir, struct fileIdentDesc* fid) { uint32_t lenFid; lenFid = (sizeof(struct fileIdentDesc) + fid->lengthOfImpUse + fid->lengthFileIdent + 3) & ~3; fid->descTag.descCRCLength = lenFid - sizeof(tag); setChecksum(fid); if( dir->fe.informationLength + lenFid > dir->dataSize ) { if( !(dir->data = realloc(dir->data, dir->dataSize + 2048)) ) { fail("Realloc directory data failed\n"); } dir->dataSize += 2048; } memcpy(dir->data + dir->fe.informationLength, fid, lenFid); dir->fe.informationLength += lenFid; dir->dirDirty = 1; return CMND_OK; }
/* deleteFID() * * Remove an FID from the directory * If fileLinkCount now zero, deallocate FileEntry and any data extents */ int deleteFID(Directory * dir, struct fileIdentDesc * fid) { int rv; struct fileEntry *fe; rv = CMND_OK; // if( fid->icb.extLocation.partitionReferenceNum != pd->partitionNumber ) // return NOT_IN_RW_PARTITION; fe = readTaggedBlock(fid->icb.extLocation.logicalBlockNum, fid->icb.extLocation.partitionReferenceNum); /* check permission */ freeBlock(fid->icb.extLocation.logicalBlockNum, fid->icb.extLocation.partitionReferenceNum); if( fe->fileLinkCount > 1 ) { fe->fileLinkCount--; setChecksum(fe); if( medium == CDRW ) dirtyBlock(fid->icb.extLocation.logicalBlockNum, fid->icb.extLocation.partitionReferenceNum); else vat[fid->icb.extLocation.logicalBlockNum] = writeCDR(fe); } else { if( medium == CDR ) { if( fe->icbTag.fileType == ICBTAG_FILE_TYPE_DIRECTORY ) dir->fe.fileLinkCount--; vat[fid->icb.extLocation.logicalBlockNum] = 0xFFFFFFFF; } else { if( fe->icbTag.fileType == ICBTAG_FILE_TYPE_DIRECTORY ) { dir->fe.fileLinkCount--; ((struct logicalVolIntegrityDescImpUse*) (lvid->impUse + 2 * sizeof(uint32_t) * lvid->numOfPartitions))->numDirs--; } else { ((struct logicalVolIntegrityDescImpUse*) (lvid->impUse + 2 * sizeof(uint32_t) * lvid->numOfPartitions))->numFiles--; } /* free file data */ switch( fe->icbTag.flags & ICBTAG_FLAG_AD_MASK ) { case ICBTAG_FLAG_AD_IN_ICB: break; case ICBTAG_FLAG_AD_SHORT: freeShortExtents((short_ad*)(fe->allocDescs + fe->lengthExtendedAttr)); break; case ICBTAG_FLAG_AD_LONG: freeLongExtents((long_ad*)(fe->allocDescs + fe->lengthExtendedAttr)); break; default: printf("UDF does not use Extended Alloc Descs\n"); rv = CMND_FAILED; } /* free the File Entry itself */ markBlock(FREE, fid->icb.extLocation.logicalBlockNum); } } removeFID(dir, fid); dir->dirDirty = 1; return rv; }
bool Dbtup::scanNext(Signal* signal, ScanOpPtr scanPtr) { ScanOp& scan = *scanPtr.p; ScanPos& pos = scan.m_scanPos; Local_key& key = pos.m_key; const Uint32 bits = scan.m_bits; // table TablerecPtr tablePtr; tablePtr.i = scan.m_tableId; ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec); Tablerec& table = *tablePtr.p; // fragment FragrecordPtr fragPtr; fragPtr.i = scan.m_fragPtrI; ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord); Fragrecord& frag = *fragPtr.p; // tuple found Tuple_header* th = 0; Uint32 thbits = 0; Uint32 loop_count = 0; Uint32 scanGCI = scanPtr.p->m_scanGCI; Uint32 foundGCI; const bool mm = (bits & ScanOp::SCAN_DD); const bool lcp = (bits & ScanOp::SCAN_LCP); Uint32 lcp_list = fragPtr.p->m_lcp_keep_list; Uint32 size = table.m_offsets[mm].m_fix_header_size; if (lcp && lcp_list != RNIL) goto found_lcp_keep; switch(pos.m_get){ case ScanPos::Get_next_tuple: case ScanPos::Get_next_tuple_fs: jam(); key.m_page_idx += size; // fall through case ScanPos::Get_tuple: case ScanPos::Get_tuple_fs: jam(); /** * We need to refetch page after timeslice */ pos.m_get = ScanPos::Get_page; break; default: break; } while (true) { switch (pos.m_get) { case ScanPos::Get_next_page: // move to next page jam(); { if (! (bits & ScanOp::SCAN_DD)) pos.m_get = ScanPos::Get_next_page_mm; else pos.m_get = ScanPos::Get_next_page_dd; } continue; case ScanPos::Get_page: // get real page jam(); { if (! (bits & ScanOp::SCAN_DD)) pos.m_get = ScanPos::Get_page_mm; else pos.m_get = ScanPos::Get_page_dd; } continue; case ScanPos::Get_next_page_mm: // move to next logical TUP page jam(); { key.m_page_no++; if (key.m_page_no >= frag.noOfPages) { jam(); if ((bits & ScanOp::SCAN_NR) && (scan.m_endPage != RNIL)) { jam(); if (key.m_page_no < scan.m_endPage) { jam(); ndbout_c("scanning page %u", key.m_page_no); goto cont; } } // no more pages, scan ends pos.m_get = ScanPos::Get_undef; scan.m_state = ScanOp::Last; return true; } cont: key.m_page_idx = 0; pos.m_get = ScanPos::Get_page_mm; // clear cached value pos.m_realpid_mm = RNIL; } /*FALLTHRU*/ case ScanPos::Get_page_mm: // get TUP real page jam(); { if (pos.m_realpid_mm == RNIL) { jam(); if (key.m_page_no < frag.noOfPages) pos.m_realpid_mm = getRealpid(fragPtr.p, key.m_page_no); else { ndbassert(bits & ScanOp::SCAN_NR); goto nopage; } } PagePtr pagePtr; c_page_pool.getPtr(pagePtr, pos.m_realpid_mm); if (pagePtr.p->page_state == ZEMPTY_MM) { // skip empty page jam(); if (! (bits & ScanOp::SCAN_NR)) { pos.m_get = ScanPos::Get_next_page_mm; break; // incr loop count } else { jam(); pos.m_realpid_mm = RNIL; } } nopage: pos.m_page = pagePtr.p; pos.m_get = ScanPos::Get_tuple; } continue; case ScanPos::Get_next_page_dd: // move to next disk page jam(); { Disk_alloc_info& alloc = frag.m_disk_alloc_info; Local_fragment_extent_list list(c_extent_pool, alloc.m_extent_list); Ptr<Extent_info> ext_ptr; c_extent_pool.getPtr(ext_ptr, pos.m_extent_info_ptr_i); Extent_info* ext = ext_ptr.p; key.m_page_no++; if (key.m_page_no >= ext->m_first_page_no + alloc.m_extent_size) { // no more pages in this extent jam(); if (! list.next(ext_ptr)) { // no more extents, scan ends jam(); pos.m_get = ScanPos::Get_undef; scan.m_state = ScanOp::Last; return true; } else { // move to next extent jam(); pos.m_extent_info_ptr_i = ext_ptr.i; ext = c_extent_pool.getPtr(pos.m_extent_info_ptr_i); key.m_file_no = ext->m_key.m_file_no; key.m_page_no = ext->m_first_page_no; } } key.m_page_idx = 0; pos.m_get = ScanPos::Get_page_dd; /* read ahead for scan in disk order do read ahead every 8:th page */ if ((bits & ScanOp::SCAN_DD) && (((key.m_page_no - ext->m_first_page_no) & 7) == 0)) { jam(); // initialize PGMAN request Page_cache_client::Request preq; preq.m_page = pos.m_key; preq.m_callback = TheNULLCallback; // set maximum read ahead Uint32 read_ahead = m_max_page_read_ahead; while (true) { // prepare page read ahead in current extent Uint32 page_no = preq.m_page.m_page_no; Uint32 page_no_limit = page_no + read_ahead; Uint32 limit = ext->m_first_page_no + alloc.m_extent_size; if (page_no_limit > limit) { jam(); // read ahead crosses extent, set limit for this extent read_ahead = page_no_limit - limit; page_no_limit = limit; // and make sure we only read one extra extent next time around if (read_ahead > alloc.m_extent_size) read_ahead = alloc.m_extent_size; } else { jam(); read_ahead = 0; // no more to read ahead after this } // do read ahead pages for this extent while (page_no < page_no_limit) { // page request to PGMAN jam(); preq.m_page.m_page_no = page_no; int flags = 0; // ignore result m_pgman.get_page(signal, preq, flags); jamEntry(); page_no++; } if (!read_ahead || !list.next(ext_ptr)) { // no more extents after this or read ahead done jam(); break; } // move to next extent and initialize PGMAN request accordingly Extent_info* ext = c_extent_pool.getPtr(ext_ptr.i); preq.m_page.m_file_no = ext->m_key.m_file_no; preq.m_page.m_page_no = ext->m_first_page_no; } } // if ScanOp::SCAN_DD read ahead } /*FALLTHRU*/ case ScanPos::Get_page_dd: // get global page in PGMAN cache jam(); { // check if page is un-allocated or empty if (likely(! (bits & ScanOp::SCAN_NR))) { Tablespace_client tsman(signal, c_tsman, frag.fragTableId, frag.fragmentId, frag.m_tablespace_id); unsigned uncommitted, committed; uncommitted = committed = ~(unsigned)0; int ret = tsman.get_page_free_bits(&key, &uncommitted, &committed); ndbrequire(ret == 0); if (committed == 0 && uncommitted == 0) { // skip empty page jam(); pos.m_get = ScanPos::Get_next_page_dd; break; // incr loop count } } // page request to PGMAN Page_cache_client::Request preq; preq.m_page = pos.m_key; preq.m_callback.m_callbackData = scanPtr.i; preq.m_callback.m_callbackFunction = safe_cast(&Dbtup::disk_page_tup_scan_callback); int flags = 0; int res = m_pgman.get_page(signal, preq, flags); jamEntry(); if (res == 0) { jam(); // request queued pos.m_get = ScanPos::Get_tuple; return false; } ndbrequire(res > 0); pos.m_page = (Page*)m_pgman.m_ptr.p; } pos.m_get = ScanPos::Get_tuple; continue; // get tuple // move to next tuple case ScanPos::Get_next_tuple: case ScanPos::Get_next_tuple_fs: // move to next fixed size tuple jam(); { key.m_page_idx += size; pos.m_get = ScanPos::Get_tuple_fs; } /*FALLTHRU*/ case ScanPos::Get_tuple: case ScanPos::Get_tuple_fs: // get fixed size tuple jam(); { Fix_page* page = (Fix_page*)pos.m_page; if (key.m_page_idx + size <= Fix_page::DATA_WORDS) { pos.m_get = ScanPos::Get_next_tuple_fs; th = (Tuple_header*)&page->m_data[key.m_page_idx]; if (likely(! (bits & ScanOp::SCAN_NR))) { jam(); thbits = th->m_header_bits; if (! (thbits & Tuple_header::FREE)) { goto found_tuple; } } else { if (pos.m_realpid_mm == RNIL) { jam(); foundGCI = 0; goto found_deleted_rowid; } thbits = th->m_header_bits; if ((foundGCI = *th->get_mm_gci(tablePtr.p)) > scanGCI || foundGCI == 0) { if (! (thbits & Tuple_header::FREE)) { jam(); goto found_tuple; } else { goto found_deleted_rowid; } } else if (thbits != Fix_page::FREE_RECORD && th->m_operation_ptr_i != RNIL) { jam(); goto found_tuple; // Locked tuple... // skip free tuple } } } else { jam(); // no more tuples on this page pos.m_get = ScanPos::Get_next_page; } } break; // incr loop count found_tuple: // found possible tuple to return jam(); { // caller has already set pos.m_get to next tuple if (! (bits & ScanOp::SCAN_LCP && thbits & Tuple_header::LCP_SKIP)) { Local_key& key_mm = pos.m_key_mm; if (! (bits & ScanOp::SCAN_DD)) { key_mm = pos.m_key; // real page id is already set } else { key_mm.assref(th->m_base_record_ref); // recompute for each disk tuple pos.m_realpid_mm = getRealpid(fragPtr.p, key_mm.m_page_no); } // TUPKEYREQ handles savepoint stuff scan.m_state = ScanOp::Current; return true; } else { jam(); // clear it so that it will show up in next LCP th->m_header_bits = thbits & ~(Uint32)Tuple_header::LCP_SKIP; if (tablePtr.p->m_bits & Tablerec::TR_Checksum) { jam(); setChecksum(th, tablePtr.p); } } } break; found_deleted_rowid: jam(); { ndbassert(bits & ScanOp::SCAN_NR); Local_key& key_mm = pos.m_key_mm; if (! (bits & ScanOp::SCAN_DD)) { key_mm = pos.m_key; // caller has already set pos.m_get to next tuple // real page id is already set } else { key_mm.assref(th->m_base_record_ref); // recompute for each disk tuple pos.m_realpid_mm = getRealpid(fragPtr.p, key_mm.m_page_no); Fix_page *mmpage = (Fix_page*)c_page_pool.getPtr(pos.m_realpid_mm); th = (Tuple_header*)(mmpage->m_data + key_mm.m_page_idx); if ((foundGCI = *th->get_mm_gci(tablePtr.p)) > scanGCI || foundGCI == 0) { if (! (thbits & Tuple_header::FREE)) break; } } NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend(); conf->scanPtr = scan.m_userPtr; conf->accOperationPtr = RNIL; conf->fragId = frag.fragmentId; conf->localKey[0] = pos.m_key_mm.ref(); conf->localKey[1] = 0; conf->localKeyLength = 1; conf->gci = foundGCI; Uint32 blockNo = refToBlock(scan.m_userRef); EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, 7); jamEntry(); // TUPKEYREQ handles savepoint stuff loop_count = 32; scan.m_state = ScanOp::Next; return false; } break; // incr loop count default: ndbrequire(false); break; } if (++loop_count >= 32) break; } // TODO: at drop table we have to flush and terminate these jam(); signal->theData[0] = ZTUP_SCAN; signal->theData[1] = scanPtr.i; sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); return false; found_lcp_keep: Local_key tmp; tmp.assref(lcp_list); tmp.m_page_no = getRealpid(fragPtr.p, tmp.m_page_no); Ptr<Page> pagePtr; c_page_pool.getPtr(pagePtr, tmp.m_page_no); Tuple_header* ptr = (Tuple_header*) ((Fix_page*)pagePtr.p)->get_ptr(tmp.m_page_idx, 0); Uint32 headerbits = ptr->m_header_bits; ndbrequire(headerbits & Tuple_header::LCP_KEEP); Uint32 next = ptr->m_operation_ptr_i; ptr->m_operation_ptr_i = RNIL; ptr->m_header_bits = headerbits & ~(Uint32)Tuple_header::FREE; if (tablePtr.p->m_bits & Tablerec::TR_Checksum) { jam(); setChecksum(ptr, tablePtr.p); } NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend(); conf->scanPtr = scan.m_userPtr; conf->accOperationPtr = (Uint32)-1; conf->fragId = frag.fragmentId; conf->localKey[0] = lcp_list; conf->localKey[1] = 0; conf->localKeyLength = 1; conf->gci = 0; Uint32 blockNo = refToBlock(scan.m_userRef); EXECUTE_DIRECT(blockNo, GSN_NEXT_SCANCONF, signal, 7); fragPtr.p->m_lcp_keep_list = next; ptr->m_header_bits |= Tuple_header::FREED; // RESTORE free flag if (headerbits & Tuple_header::FREED) { if (tablePtr.p->m_attributes[MM].m_no_of_varsize) { jam(); free_var_rec(fragPtr.p, tablePtr.p, &tmp, pagePtr); } else { jam(); free_fix_rec(fragPtr.p, tablePtr.p, &tmp, (Fix_page*)pagePtr.p); } } return false; }
void TestItem::setData(const QVariant & value, int role){ switch(role) { case DurationRole: setDuration(value.toDouble()); break; case ChecksumRole: setChecksum(value.toString()); break; case DependsRole: setDepends(value.toString()); break; case TestNameRole: setTestname(value.toString()); break; case RequiresRole: setRequires(value.toString()); break; case DescriptionRole: setDescription(value.toString()); break; case CommandRole: setCommand(value.toString()); break; case EnvironRole: setEnviron(value.toString()); break; case PluginRole: setPlugin(value.toString()); break; case TypeRole: setType(value.toString()); break; case UserRole: setUser(value.toString()); break; case ViaRole: setVia(value.toString()); break; case GroupRole: setGroup(value.toString()); break; case CheckRole: setCheck(value.toBool()); break; case ObjectPathRole: setObjectpath(value.toString()); break; case RunstatusRole: setRunstatus(value.toInt()); break; case ElapsedtimeRole: setElapsedtime(value.toInt()); break; case GroupstatusRole: setGroupstatus(value.toInt()); break; case ParentNameRole: //setGroupstatus(value.toStringList())); break; case ParentIdRole: //setGroupstatus(value.toStringList()); break; case DepthRole: setDepth(value.toInt()); break; case BranchRole: setBranch(value.toBool()); break; case IOLogRole: setIo_log(value.toString()); break; case CommentsRole: setComments(value.toString()); break; case OutcomeRole: setOutcome(value.toString()); break; case RerunRole: setRerun(value.toBool()); break; } }
void TcpPacket::assemblePacket() { if (nextPacket != NULL) nextPacket->assemblePacket (); int thissize = sizeof (TCP_HEADER) + options.size; int nextsize = nextPacket != NULL ? nextPacket->getSize() : 0; setSize (thissize + nextsize); if (nextPacket != NULL) memcpy (buffer + thissize, nextPacket->getBuffer(), nextsize); // // correct header length // setHeaderlength (thissize); // // correct endianess for output buffer // header.acknum = swap32(header.acknum ); header.checksum = swap16(header.checksum ); header.destport = swap16(header.destport ); header.headerlen_flags = swap16(header.headerlen_flags ); header.sequencenum = swap32(header.sequencenum ); header.sourceport = swap16(header.sourceport ); header.urgentpointer = swap16(header.urgentpointer ); header.windowsize = swap16(header.windowsize ); // // calculate new checksum // therefore we need the PayloadPacket // setChecksum (0); if (Configuration::instance()->getReCalcChecksums ()) { if (Configuration::instance()->getSetBadChecksumsToBad () && !checksumgood) { setChecksum (RandomNumberGenerator::generate ()); } else { uint8_t* data = NULL; uint32_t datalen = 0; if (nextProtocol != Packet::PROTO_NONE && nextPacket != NULL) { data = nextPacket->getBuffer (); datalen = nextPacket->getSize (); } void* pipsource = (ipProtocol == Packet::PROTO_IP ? (void*)&sourceip : (void*)&sourceip6); void* pipdest = (ipProtocol == Packet::PROTO_IP ? (void*)&destip : (void*)&destip6 ); setChecksum (checksum (&header, pipsource, pipdest, ipProtocol, options.buf, options.size, data, datalen)); } // if (Configuration::instance()->getSetBadChecksumsToBad () && !checksumgood) { } // if (Configuration::instance()->getReCalcChecksums ()) // // copy into out buffer // header, options, data // memcpy (buffer, &header, sizeof (TCP_HEADER)); memcpy (buffer + sizeof (TCP_HEADER), options.buf, options.size); // // convert endianess back // header.acknum = swap32(header.acknum ); header.checksum = swap16(header.checksum ); header.destport = swap16(header.destport ); header.headerlen_flags = swap16(header.headerlen_flags ); header.sequencenum = swap32(header.sequencenum ); header.sourceport = swap16(header.sourceport ); header.urgentpointer = swap16(header.urgentpointer ); header.windowsize = swap16(header.windowsize ); }
void Dbtup::commit_operation(Signal* signal, Uint32 gci_hi, Uint32 gci_lo, Tuple_header* tuple_ptr, PagePtr pagePtr, Operationrec* regOperPtr, Fragrecord* regFragPtr, Tablerec* regTabPtr) { ndbassert(regOperPtr->op_type != ZDELETE); Uint32 lcpScan_ptr_i= regFragPtr->m_lcp_scan_op; Uint32 save= tuple_ptr->m_operation_ptr_i; Uint32 bits= tuple_ptr->m_header_bits; Tuple_header *disk_ptr= 0; Tuple_header *copy= get_copy_tuple(®OperPtr->m_copy_tuple_location); Uint32 copy_bits= copy->m_header_bits; Uint32 fixsize= regTabPtr->m_offsets[MM].m_fix_header_size; Uint32 mm_vars= regTabPtr->m_attributes[MM].m_no_of_varsize; Uint32 mm_dyns= regTabPtr->m_attributes[MM].m_no_of_dynamic; bool update_gci_at_commit = ! regOperPtr->op_struct.bit_field.m_gci_written; if((mm_vars+mm_dyns) == 0) { jam(); memcpy(tuple_ptr, copy, 4*fixsize); disk_ptr= (Tuple_header*)(((Uint32*)copy)+fixsize); } else { jam(); /** * Var_part_ref is only stored in *allocated* tuple * so memcpy from copy, will over write it... * hence subtle copyout/assign... */ Local_key tmp; Var_part_ref *ref= tuple_ptr->get_var_part_ref_ptr(regTabPtr); ref->copyout(&tmp); memcpy(tuple_ptr, copy, 4*fixsize); ref->assign(&tmp); PagePtr vpagePtr; if (copy_bits & Tuple_header::VAR_PART) { jam(); ndbassert(bits & Tuple_header::VAR_PART); ndbassert(tmp.m_page_no != RNIL); ndbassert(copy_bits & Tuple_header::COPY_TUPLE); Uint32 *dst= get_ptr(&vpagePtr, *ref); Var_page* vpagePtrP = (Var_page*)vpagePtr.p; Varpart_copy*vp =(Varpart_copy*)copy->get_end_of_fix_part_ptr(regTabPtr); /* The first word of shrunken tuple holds the lenght in words. */ Uint32 len = vp->m_len; memcpy(dst, vp->m_data, 4*len); if(copy_bits & Tuple_header::MM_SHRINK) { jam(); ndbassert(vpagePtrP->get_entry_len(tmp.m_page_idx) >= len); if (len) { jam(); ndbassert(regFragPtr->m_varWordsFree >= vpagePtrP->free_space); regFragPtr->m_varWordsFree -= vpagePtrP->free_space; vpagePtrP->shrink_entry(tmp.m_page_idx, len); // Adds the new free space value for the page to the fragment total. update_free_page_list(regFragPtr, vpagePtr); } else { jam(); free_var_part(regFragPtr, vpagePtr, tmp.m_page_idx); tmp.m_page_no = RNIL; ref->assign(&tmp); copy_bits &= ~(Uint32)Tuple_header::VAR_PART; } } else { jam(); ndbassert(vpagePtrP->get_entry_len(tmp.m_page_idx) == len); } /** * Find disk part after * header + fixed MM part + length word + varsize part. */ disk_ptr = (Tuple_header*)(vp->m_data + len); } else { jam(); ndbassert(tmp.m_page_no == RNIL); disk_ptr = (Tuple_header*)copy->get_end_of_fix_part_ptr(regTabPtr); } } if (regTabPtr->m_no_of_disk_attributes && (copy_bits & Tuple_header::DISK_INLINE)) { jam(); Local_key key; memcpy(&key, copy->get_disk_ref_ptr(regTabPtr), sizeof(Local_key)); Uint32 logfile_group_id= regFragPtr->m_logfile_group_id; PagePtr diskPagePtr((Tup_page*)m_pgman_ptr.p, m_pgman_ptr.i); ndbassert(diskPagePtr.p->m_page_no == key.m_page_no); ndbassert(diskPagePtr.p->m_file_no == key.m_file_no); Uint32 sz, *dst; if(copy_bits & Tuple_header::DISK_ALLOC) { jam(); disk_page_alloc(signal, regTabPtr, regFragPtr, &key, diskPagePtr, gci_hi); } if(regTabPtr->m_attributes[DD].m_no_of_varsize == 0) { jam(); sz= regTabPtr->m_offsets[DD].m_fix_header_size; dst= ((Fix_page*)diskPagePtr.p)->get_ptr(key.m_page_idx, sz); } else { jam(); dst= ((Var_page*)diskPagePtr.p)->get_ptr(key.m_page_idx); sz= ((Var_page*)diskPagePtr.p)->get_entry_len(key.m_page_idx); } if(! (copy_bits & Tuple_header::DISK_ALLOC)) { jam(); disk_page_undo_update(diskPagePtr.p, &key, dst, sz, gci_hi, logfile_group_id); } memcpy(dst, disk_ptr, 4*sz); memcpy(tuple_ptr->get_disk_ref_ptr(regTabPtr), &key, sizeof(Local_key)); ndbassert(! (disk_ptr->m_header_bits & Tuple_header::FREE)); copy_bits |= Tuple_header::DISK_PART; } if(lcpScan_ptr_i != RNIL && (bits & Tuple_header::ALLOC)) { jam(); ScanOpPtr scanOp; c_scanOpPool.getPtr(scanOp, lcpScan_ptr_i); Local_key rowid = regOperPtr->m_tuple_location; rowid.m_page_no = pagePtr.p->frag_page_id; if (!is_rowid_lcp_scanned(rowid, *scanOp.p)) { jam(); copy_bits |= Tuple_header::LCP_SKIP; } } Uint32 clear= Tuple_header::ALLOC | Tuple_header::FREE | Tuple_header::COPY_TUPLE | Tuple_header::DISK_ALLOC | Tuple_header::DISK_INLINE | Tuple_header::MM_SHRINK | Tuple_header::MM_GROWN; copy_bits &= ~(Uint32)clear; tuple_ptr->m_header_bits= copy_bits; tuple_ptr->m_operation_ptr_i= save; if (regTabPtr->m_bits & Tablerec::TR_RowGCI && update_gci_at_commit) { jam(); * tuple_ptr->get_mm_gci(regTabPtr) = gci_hi; if (regTabPtr->m_bits & Tablerec::TR_ExtraRowGCIBits) { Uint32 attrId = regTabPtr->getExtraAttrId<Tablerec::TR_ExtraRowGCIBits>(); store_extra_row_bits(attrId, regTabPtr, tuple_ptr, gci_lo, /* truncate */true); } } if (regTabPtr->m_bits & Tablerec::TR_Checksum) { jam(); setChecksum(tuple_ptr, regTabPtr); } }