t_uns read_stdin(void)
{
int fd;
fd = 0;
if (prepare_read(&fd))
return (1);
return (0);
}
t_uns read_file(char *file)
{
int fd;
fd = open(file, O_DIRECTORY);
if (fd >= 0)
return (1);
fd = open(file, O_RDONLY);
if (fd < 0)
return (1);
if (prepare_read(&fd) == 1)
return (1);
return (0);
}
static VALUE my_recv(int io_wait, int argc, VALUE *argv, VALUE io)
{
struct io_args a;
long n;
prepare_read(&a, argc, argv, io);
kgio_autopush_recv(io);
if (a.len > 0) {
retry:
n = (long)recv(a.fd, a.ptr, a.len, MSG_DONTWAIT);
if (read_check(&a, n, "recv", io_wait) != 0)
goto retry;
}
return a.buf;
}
static VALUE my_read(int io_wait, int argc, VALUE *argv, VALUE io)
{
struct io_args a;
long n;
prepare_read(&a, argc, argv, io);
if (a.len > 0) {
set_nonblocking(a.fd);
retry:
n = (long)read(a.fd, a.ptr, a.len);
if (read_check(&a, n, "read", io_wait) != 0)
goto retry;
}
return a.buf;
}
static VALUE my_peek(int io_wait, int argc, VALUE *argv, VALUE io)
{
struct io_args a;
long n;
prepare_read(&a, argc, argv, io);
kgio_autopush_recv(io);
if (a.len > 0) {
if (peek_flags == MSG_PEEK)
set_nonblocking(a.fd);
retry:
n = (long)recv(a.fd, a.ptr, a.len, peek_flags);
if (read_check(&a, n, "recv(MSG_PEEK)", io_wait) != 0)
goto retry;
}
return a.buf;
}
int fuse_read(u32 bank, u32 word, u32 *val)
{
struct fsl_iim *regs;
u32 stat, err;
int ret;
ret = prepare_read(®s, bank, word, val, __func__);
if (ret)
return ret;
*val = iim_read32(®s->bank[bank].word[word]);
finish_access(regs, &stat, &err);
if (err & ERR_RPE) {
puts("fsl_iim fuse_read(): Read protect error\n");
return -EIO;
}
return 0;
}
int read_record (void) {
int i, c = '\t', state;
char *ptr, *end;
prepare_read();
assert (Args_per_line > 0 && Args_per_line < MAXV);
if (rptr == rend) {
return 0;
}
for (i = 0; i < Args_per_line && c != '\n'; i++) {
assert (c == '\t');
ptr = &S[i][0];
end = ptr + MAX_STRLEN - 2;
state = 0;
do {
assert (rptr < rend && ptr < end);
c = *rptr++;
if (c == '\n' || c == '\t') {
if (state == '\\') {
ptr--;
} else {
break;
}
}
if (c == '\\' && state == '\\') {
state = 0;
ptr--;
} else {
state = c;
}
*ptr++ = c;
} while (1);
*ptr = 0;
L[i] = ptr - S[i];
I[i] = atoll(S[i]);
}
assert (i == Args_per_line);
line_no++;
return 1;
}
int
Dbtup::tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag)
{
jamEntry();
// use own variables instead of globals
FragrecordPtr fragPtr;
fragPtr.i= fragPtrI;
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
TablerecPtr tablePtr;
tablePtr.i= fragPtr.p->fragTableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
Operationrec tmpOp;
tmpOp.m_tuple_location.m_page_no= pageId;
tmpOp.m_tuple_location.m_page_idx= pageIndex;
KeyReqStruct req_struct(this);
req_struct.tablePtrP = tablePtr.p;
req_struct.fragPtrP = fragPtr.p;
PagePtr page_ptr;
Uint32* ptr= get_ptr(&page_ptr, &tmpOp.m_tuple_location, tablePtr.p);
req_struct.m_page_ptr = page_ptr;
req_struct.m_tuple_ptr = (Tuple_header*)ptr;
int ret = 0;
if (! (req_struct.m_tuple_ptr->m_header_bits & Tuple_header::FREE))
{
req_struct.check_offset[MM]= tablePtr.p->get_check_offset(MM);
req_struct.check_offset[DD]= tablePtr.p->get_check_offset(DD);
Uint32 num_attr= tablePtr.p->m_no_of_attributes;
Uint32 descr_start= tablePtr.p->tabDescriptor;
TableDescriptor *tab_descr= &tableDescriptor[descr_start];
ndbrequire(descr_start + (num_attr << ZAD_LOG_SIZE) <= cnoOfTabDescrRec);
req_struct.attr_descr= tab_descr;
if(req_struct.m_tuple_ptr->m_header_bits & Tuple_header::ALLOC)
{
Uint32 opPtrI= req_struct.m_tuple_ptr->m_operation_ptr_i;
Operationrec* opPtrP= c_operation_pool.getPtr(opPtrI);
ndbassert(!opPtrP->m_copy_tuple_location.isNull());
req_struct.m_tuple_ptr=
get_copy_tuple(&opPtrP->m_copy_tuple_location);
}
prepare_read(&req_struct, tablePtr.p, false);
const Uint32* attrIds= &tableDescriptor[tablePtr.p->readKeyArray].tabDescr;
const Uint32 numAttrs= tablePtr.p->noOfKeyAttr;
// read pk attributes from original tuple
// do it
ret = readAttributes(&req_struct,
attrIds,
numAttrs,
dataOut,
ZNIL,
xfrmFlag);
// done
if (ret >= 0) {
// remove headers
Uint32 n= 0;
Uint32 i= 0;
while (n < numAttrs) {
const AttributeHeader ah(dataOut[i]);
Uint32 size= ah.getDataSize();
ndbrequire(size != 0);
for (Uint32 j= 0; j < size; j++) {
dataOut[i + j - n]= dataOut[i + j + 1];
}
n+= 1;
i+= 1 + size;
}
ndbrequire((int)i == ret);
ret -= numAttrs;
} else {
return ret;
}
}
if (tablePtr.p->m_bits & Tablerec::TR_RowGCI)
{
dataOut[ret] = *req_struct.m_tuple_ptr->get_mm_gci(tablePtr.p);
}
else
{
dataOut[ret] = 0;
}
return ret;
}
int
Dbtup::tuxReadAttrs(EmulatedJamBuffer * jamBuf,
Uint32 fragPtrI,
Uint32 pageId,
Uint32 pageIndex,
Uint32 tupVersion,
const Uint32* attrIds,
Uint32 numAttrs,
Uint32* dataOut,
bool xfrmFlag)
{
thrjamEntry(jamBuf);
// use own variables instead of globals
FragrecordPtr fragPtr;
fragPtr.i= fragPtrI;
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
TablerecPtr tablePtr;
tablePtr.i= fragPtr.p->fragTableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
// search for tuple version if not original
Operationrec tmpOp;
KeyReqStruct req_struct(jamBuf);
req_struct.tablePtrP = tablePtr.p;
req_struct.fragPtrP = fragPtr.p;
tmpOp.m_tuple_location.m_page_no= pageId;
tmpOp.m_tuple_location.m_page_idx= pageIndex;
tmpOp.op_type = ZREAD; // valgrind
setup_fixed_tuple_ref(&req_struct, &tmpOp, tablePtr.p);
setup_fixed_part(&req_struct, &tmpOp, tablePtr.p);
Tuple_header *tuple_ptr= req_struct.m_tuple_ptr;
if (tuple_ptr->get_tuple_version() != tupVersion)
{
jam();
OperationrecPtr opPtr;
opPtr.i= tuple_ptr->m_operation_ptr_i;
Uint32 loopGuard= 0;
while (opPtr.i != RNIL) {
c_operation_pool.getPtr(opPtr);
if (opPtr.p->op_struct.bit_field.tupVersion == tupVersion) {
jam();
if (!opPtr.p->m_copy_tuple_location.isNull()) {
req_struct.m_tuple_ptr=
get_copy_tuple(&opPtr.p->m_copy_tuple_location);
}
break;
}
jam();
opPtr.i= opPtr.p->prevActiveOp;
ndbrequire(++loopGuard < (1 << ZTUP_VERSION_BITS));
}
}
// read key attributes from found tuple version
// save globals
prepare_read(&req_struct, tablePtr.p, false);
// do it
int ret = readAttributes(&req_struct,
attrIds,
numAttrs,
dataOut,
ZNIL,
xfrmFlag);
// done
return ret;
}
bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr,
Operationrec* const regOperPtr,
KeyReqStruct *req_struct,
Fragrecord* const regFragPtr,
Uint32* const keyBuffer,
Uint32& noPrimKey,
Uint32* const afterBuffer,
Uint32& noAfterWords,
Uint32* const beforeBuffer,
Uint32& noBeforeWords,
bool disk)
{
noAfterWords = 0;
noBeforeWords = 0;
Uint32 readBuffer[MAX_ATTRIBUTES_IN_TABLE];
//---------------------------------------------------------------------------
// Set-up variables needed by readAttributes operPtr.p, tabptr.p
//---------------------------------------------------------------------------
operPtr.p = regOperPtr;
tabptr.i = regFragPtr->fragTableId;
ptrCheckGuard(tabptr, cnoOfTablerec, tablerec);
Tablerec* const regTabPtr = tabptr.p;
Uint32 num_attr= regTabPtr->m_no_of_attributes;
Uint32 descr_start= regTabPtr->tabDescriptor;
ndbrequire(descr_start + (num_attr << ZAD_LOG_SIZE) <= cnoOfTabDescrRec);
req_struct->check_offset[MM]= regTabPtr->get_check_offset(MM);
req_struct->check_offset[DD]= regTabPtr->get_check_offset(DD);
req_struct->attr_descr= &tableDescriptor[descr_start];
//--------------------------------------------------------------------
// Read Primary Key Values
//--------------------------------------------------------------------
Tuple_header *save0= req_struct->m_tuple_ptr;
if (regOperPtr->op_struct.op_type == ZDELETE &&
!regOperPtr->is_first_operation())
{
jam();
req_struct->m_tuple_ptr= (Tuple_header*)
c_undo_buffer.get_ptr(&req_struct->prevOpPtr.p->m_copy_tuple_location);
}
if (regTabPtr->need_expand(disk))
prepare_read(req_struct, regTabPtr, disk);
int ret = readAttributes(req_struct,
&tableDescriptor[regTabPtr->readKeyArray].tabDescr,
regTabPtr->noOfKeyAttr,
keyBuffer,
ZATTR_BUFFER_SIZE,
false);
ndbrequire(ret != -1);
noPrimKey= ret;
req_struct->m_tuple_ptr = save0;
Uint32 numAttrsToRead;
if ((regOperPtr->op_struct.op_type == ZUPDATE) &&
(trigPtr->sendOnlyChangedAttributes)) {
jam();
//--------------------------------------------------------------------
// Update that sends only changed information
//--------------------------------------------------------------------
Bitmask<MAXNROFATTRIBUTESINWORDS> attributeMask;
attributeMask = trigPtr->attributeMask;
attributeMask.bitAND(req_struct->changeMask);
numAttrsToRead = setAttrIds(attributeMask, regTabPtr->m_no_of_attributes,
&readBuffer[0]);
} else if ((regOperPtr->op_struct.op_type == ZDELETE) &&
(!trigPtr->sendBeforeValues)) {
jam();
//--------------------------------------------------------------------
// Delete without sending before values only read Primary Key
//--------------------------------------------------------------------
return true;
} else {
jam();
//--------------------------------------------------------------------
// All others send all attributes that are monitored, except:
// Omit unchanged blob inlines on update i.e.
// attributeMask & ~ (blobAttributeMask & ~ changeMask)
//--------------------------------------------------------------------
Bitmask<MAXNROFATTRIBUTESINWORDS> attributeMask;
attributeMask = trigPtr->attributeMask;
if (regOperPtr->op_struct.op_type == ZUPDATE) {
Bitmask<MAXNROFATTRIBUTESINWORDS> tmpMask = regTabPtr->blobAttributeMask;
tmpMask.bitANDC(req_struct->changeMask);
attributeMask.bitANDC(tmpMask);
}
numAttrsToRead = setAttrIds(attributeMask, regTabPtr->m_no_of_attributes,
&readBuffer[0]);
}
ndbrequire(numAttrsToRead < MAX_ATTRIBUTES_IN_TABLE);
//--------------------------------------------------------------------
// Read Main tuple values
//--------------------------------------------------------------------
if (regOperPtr->op_struct.op_type != ZDELETE)
{
jam();
int ret = readAttributes(req_struct,
&readBuffer[0],
numAttrsToRead,
afterBuffer,
ZATTR_BUFFER_SIZE,
false);
ndbrequire(ret != -1);
noAfterWords= ret;
} else {
jam();
noAfterWords = 0;
}
//--------------------------------------------------------------------
// Read Copy tuple values for UPDATE's
//--------------------------------------------------------------------
// Initialise pagep and tuple offset for read of copy tuple
//--------------------------------------------------------------------
if ((regOperPtr->op_struct.op_type == ZUPDATE ||
regOperPtr->op_struct.op_type == ZDELETE) &&
(trigPtr->sendBeforeValues)) {
jam();
Tuple_header *save= req_struct->m_tuple_ptr;
PagePtr tmp;
if(regOperPtr->is_first_operation())
{
Uint32 *ptr= get_ptr(&tmp, ®OperPtr->m_tuple_location, regTabPtr);
req_struct->m_tuple_ptr= (Tuple_header*)ptr;
}
else
{
Uint32 *ptr=
c_undo_buffer.get_ptr(&req_struct->prevOpPtr.p->m_copy_tuple_location);
req_struct->m_tuple_ptr= (Tuple_header*)ptr;
}
if (regTabPtr->need_expand(disk))
prepare_read(req_struct, regTabPtr, disk);
int ret = readAttributes(req_struct,
&readBuffer[0],
numAttrsToRead,
beforeBuffer,
ZATTR_BUFFER_SIZE,
false);
req_struct->m_tuple_ptr= save;
ndbrequire(ret != -1);
noBeforeWords = ret;
if (trigPtr->m_receiverBlock != SUMA &&
(noAfterWords == noBeforeWords) &&
(memcmp(afterBuffer, beforeBuffer, noAfterWords << 2) == 0)) {
//--------------------------------------------------------------------
// Although a trigger was fired it was not necessary since the old
// value and the new value was exactly the same
//--------------------------------------------------------------------
jam();
//XXX does this work with collations?
return false;
}
}
return true;
}
int
Dbtup::tuxReadAttrs(Uint32 fragPtrI,
Uint32 pageId,
Uint32 pageIndex,
Uint32 tupVersion,
const Uint32* attrIds,
Uint32 numAttrs,
Uint32* dataOut)
{
jamEntry();
// use own variables instead of globals
FragrecordPtr fragPtr;
fragPtr.i= fragPtrI;
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
TablerecPtr tablePtr;
tablePtr.i= fragPtr.p->fragTableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
// search for tuple version if not original
Operationrec tmpOp;
KeyReqStruct req_struct;
tmpOp.m_tuple_location.m_page_no= pageId;
tmpOp.m_tuple_location.m_page_idx= pageIndex;
setup_fixed_part(&req_struct, &tmpOp, tablePtr.p);
Tuple_header *tuple_ptr= req_struct.m_tuple_ptr;
if (tuple_ptr->get_tuple_version() != tupVersion)
{
jam();
OperationrecPtr opPtr;
opPtr.i= tuple_ptr->m_operation_ptr_i;
Uint32 loopGuard= 0;
while (opPtr.i != RNIL) {
c_operation_pool.getPtr(opPtr);
if (opPtr.p->tupVersion == tupVersion) {
jam();
if (!opPtr.p->m_copy_tuple_location.isNull()) {
req_struct.m_tuple_ptr= (Tuple_header*)
c_undo_buffer.get_ptr(&opPtr.p->m_copy_tuple_location);
}
break;
}
jam();
opPtr.i= opPtr.p->prevActiveOp;
ndbrequire(++loopGuard < (1 << ZTUP_VERSION_BITS));
}
}
// read key attributes from found tuple version
// save globals
TablerecPtr tabptr_old= tabptr;
FragrecordPtr fragptr_old= fragptr;
OperationrecPtr operPtr_old= operPtr;
// new globals
tabptr= tablePtr;
fragptr= fragPtr;
operPtr.i= RNIL;
operPtr.p= NULL;
prepare_read(&req_struct, tablePtr.p, false);
// do it
int ret = readAttributes(&req_struct,
attrIds,
numAttrs,
dataOut,
ZNIL,
true);
// restore globals
tabptr= tabptr_old;
fragptr= fragptr_old;
operPtr= operPtr_old;
// done
if (ret == -1) {
ret = terrorCode ? (-(int)terrorCode) : -1;
}
return ret;
}
