void LOADERDECL TexCoord_ReadDirect()
{
for (int i = 0; i != N; ++i)
DataWrite(TCScale(DataRead<T>()));
LOG_TEX<N>();
++tcIndex;
}
/* Procedure servicing the ioctl */
long c2_ioctl (struct file *filp,
unsigned int cmd, unsigned long arg)
{
//TODO: Locking is probably required since we don't run under BKL anymore.
// Although it isn't possible to open the c2 device twice, a single
// process with multiple threads might be abble to issue simultaneous
// ioctls() --DI
long buf;
unsigned char cbuf;
int err=0,ret;
if (_IOC_TYPE(cmd) != C2_IOC_MAGIC) return -ENOTTY;
if (_IOC_NR(cmd) > C2_IOC_MAXNR) return -ENOTTY;
if (_IOC_DIR(cmd) & _IOC_READ)
err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
else if (_IOC_DIR(cmd) & _IOC_WRITE)
err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
if (err) return -EFAULT;
switch(_IOC_NR(cmd)) {
case _IOC_NR(C2_IOCRESET):
//printk(KERN_ERR "C2_IOCRESET");
C2CK_reset();
return 0;
case _IOC_NR(C2_IOCAWRITE):
ret = __get_user(cbuf, (unsigned char *)arg);
//printk(KERN_ERR "C2_IOCAWRITE: address=%u\n", cbuf);
AddressWrite(cbuf);
return ret;
case _IOC_NR(C2_IOCDWRITE):
ret = __get_user(buf, (long *)arg);
//printk(KERN_ERR "C2_IOCDWRITE: len=%u, data=%u\n", (_IOC_SIZE(cmd)-1) & 3, buf);
return DataWrite((_IOC_SIZE(cmd)-1) & 3, buf);
case _IOC_NR(C2_IOCAREAD):
cbuf=AddressRead();
//printk(KERN_ERR "C2_IOCAREAD: address=%u\n", cbuf);
ret = __put_user(cbuf, (unsigned char *)arg);
return ret;
case _IOC_NR(C2_IOCDREAD):
ret = DataRead((_IOC_SIZE(cmd)-1) & 3, &buf);
if(ret) return ret;
//printk(KERN_ERR "C2_IOCDREAD: len=%u, data=%u\n", (_IOC_SIZE(cmd)-1) & 3, buf);
ret = __put_user(buf, (long *)arg);
return ret;
case _IOC_NR(C2_IOCQRESET):
//printk(KERN_ERR "C2_IOCQRESET");
C2CK_ENA();
C2CK_low_pulse(); /* a "quick reset" is just a low pulse, less than 20us */
C2CK_DIS();
return 0;
case _IOC_NR(C2_IOCIRQCHK):
//printk(KERN_ERR "C2_IOCIRQCHK");
return CheckForInterrupts();
default:
return -ENOTTY;
}
}
void LOADERDECL TexCoord_ReadIndex()
{
static_assert(!std::numeric_limits<I>::is_signed, "Only unsigned I is sane!");
auto const index = DataRead<I>();
auto const data = reinterpret_cast<const T*>(cached_arraybases[ARRAY_TEXCOORD0 + tcIndex]
+ (index * arraystrides[ARRAY_TEXCOORD0 + tcIndex]));
for (int i = 0; i != N; ++i)
DataWrite(TCScale(Common::FromBigEndian(data[i])));
LOG_TEX<N>();
++tcIndex;
}
/**
Process asynchronous requests
*/
TInt DCrashDriverChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)
{
Kern::Printf("DCrashDriverChannel::DoRequest");
TInt err = KErrNone;
switch(aReqNo)
{
case RKernelCrashDrv::EPrefetchAbort:
{
err = StartInfLoop();
if(err != KErrNone)
return err;
PrefetchAbort();
break;
}
case RKernelCrashDrv::EDataRead:
{
err = StartInfLoop();
if(err != KErrNone)
return err;
DataRead();
break;
}
case RKernelCrashDrv::EDataWrite:
{
err = StartInfLoop();
if(err != KErrNone)
return err;
DataWrite();
break;
}
case RKernelCrashDrv::EUndefInst:
{
err = StartInfLoop();
if(err != KErrNone)
return err;
UndefinedInst();
break;
}
case RKernelCrashDrv::EDivByZero:
{
err = StartInfLoop();
if(err != KErrNone)
return err;
DivByZero();
break;
}
case RKernelCrashDrv::EStackOverflow:
{
err = StartInfLoop();
if(err != KErrNone)
return err;
StackOverFlow();
break;
}
case RKernelCrashDrv::ETestSCMConfigInsertMethod:
{
//read the argmuents
HBuf8* tmp = HBuf8::New(KMaxBufferSize);
TInt err = Kern::ThreadDesRead(iClient, a2, *tmp, 0, 0 );
if (err != KErrNone || tmp->MaxLength() < KMaxBufferSize)
{
Kern::Printf("Unable to read argument or buffer too small");
// We could not read information from the user, so the a2 argument is probably wrong
Kern::RequestComplete(iClient, aStatus, KErrArgument);
return KErrArgument;
}
//run the test and gather the results
TBool pass;
//run test
//TestConfigInsertL(pass, *tmp);
//write the results back to client thread
err = Kern::ThreadRawWrite(iClient, a1, (TUint8*)&pass, sizeof(TBool), iClient);
if(err != KErrNone)
{
Kern::Printf("Unable to write data back to client");
// We could not read information from the user, so the a2 argument is probably wrong
Kern::RequestComplete(iClient, aStatus, KErrArgument);
return err;
}
//and write the buffer back...
err = Kern::ThreadDesWrite(iClient, a2, *tmp, 0, 0, iClient);
if(err != KErrNone)
{
Kern::Printf("Unable to write data back to client");
// We could not read information from the user, so the a2 argument is probably wrong
Kern::RequestComplete(iClient, aStatus, KErrArgument);
return err;
}
break;
}
default:
{
err=KErrNotSupported;
break;
}
}
return err;
}
__forceinline void _SetCol(VertexLoader* loader, u32 val)
{
DataWrite(val);
loader->m_colIndex++;
}
static void TexMtx_Write_Float3(VertexLoader* loader)
{
DataWrite(0.f);
DataWrite(0.f);
DataWrite(float(loader->m_curtexmtx[loader->m_texmtxwrite++]));
}
/*
* Specifically for 454 data this reassigns confidence values to bases in
* a run of the same base type.
* It also reassigns confidence values of pads to be the minimum confidence
* of the surrounding base call.
*/
void reassign_confidence_values(GapIO *io, int cnum) {
GContigs c;
GReadings r;
int rnum;
int scores[1000]; /* FIXME: check if we overflow! */
contig_read(io, cnum, c);
for (rnum = c.left; rnum; rnum = r.right) {
char last = 0;
char *seq;
int1 *conf;
int i, j, k;
int cl, cr;
gel_read(io, rnum, r);
seq = TextAllocRead(io, r.sequence);
conf = DataAllocRead(io, r.confidence, 1);
/* Rearrange confidence in runs of bases */
for (i = 0; i < r.length; i++) {
/* Find first non-pad, at 'i' */
while (i < r.length && seq[i] == '*')
i++;
k = 0;
scores[k++] = conf[i];
last = seq[i];
/* Count how many there are. First diff base at 'j' */
j = i+1;
while (j < r.length && (seq[j] == '*' || seq[j] == last)) {
if (seq[j] != '*')
scores[k++] = conf[j];
j++;
}
if (k != 1) {
/* We have a run of k items (from >='i' and <'j') */
qsort(scores, k, sizeof(*scores), isort);
/* Reassign */
j = i; k = 0;
while (j < r.length && (seq[j] == '*' || seq[j] == last)) {
if (seq[j] != '*')
conf[j] = scores[k++];
j++;
}
}
i = j-1;
}
/* Reassign confidences to pads */
cl = 0;
for (i = 0; i < r.length; i++) {
if (seq[i] == '*') {
for (j = i+1; j < r.length && seq[j] == '*'; j++)
;
cr = j < r.length ? conf[j] : 0;
/* conf[i] = MIN(cl, cr); */
conf[i] = (cl+cr)/2;
} else {
cl = conf[i];
}
}
DataWrite(io, r.confidence, conf, r.length, 1);
xfree(seq);
xfree(conf);
}
}
/*
* Takes a multiple alignment and updates the on-disk data structures to
* match. This needs to correct confidence values, original positions and
* tags too.
*/
void update_io(GapIO *io, int cnum, MALIGN *malign) {
GContigs c;
GReadings r, lastr;
CONTIGL *cl;
int lastrnum = 0;
int rnum;
contig_read(io, cnum, c);
for (cl = malign->contigl; cl; cl = cl->next) {
char *seq;
rnum = cl->id;
gel_read(io, rnum, r);
seq = TextAllocRead(io, r.sequence);
/* Link this->left and this->left->right. Save this->left */
io_lnbr(io, rnum) = lastrnum;
r.left = lastrnum;
if (lastrnum) {
io_rnbr(io, lastrnum) = rnum;
lastr.right = rnum;
gel_write(io, lastrnum, lastr);
} else {
io_clnbr(io, cnum) = rnum;
c.left = rnum;
}
/* Check if sequence has changed. If so assign a new one */
if (memcmp(seq+r.start, cl->mseg->seq, cl->mseg->length) != 0) {
int newlen = r.start + (r.length+1 - r.end) + cl->mseg->length;
int i, j, np;
int1 *conf;
int2 *opos;
char *newseq = (char *)malloc(newlen+1);
int1 *newconf = (int1 *)malloc(newlen+1);
int2 *newopos = (int2 *)malloc((newlen+1)*2);
conf = DataAllocRead(io, r.confidence, 1);
opos = DataAllocRead(io, r.orig_positions, 2);
/* Copy from 1 to r.start (base coords) */
for (j = 0; j < r.start; j++) {
newseq[j] = seq[j];
newconf[j] = conf[j];
newopos[j] = opos[j];
}
memcpy(&newseq[j], cl->mseg->seq, cl->mseg->length);
/*
* Step through both old and new sequences working out how
* they differ. This will (*should*) be entire pad movements.
* i = index to old seq
* j = index to new seq
* np = number of pads added minus removed from old seq.
*/
np = 0;
for (i = j; i < r.length && j < r.start + cl->mseg->length;) {
if (toupper(newseq[j]) == toupper(seq[i]) ||
(seq[i] == '.' && newseq[j] == 'N')) {
newconf[j] = conf[i];
newopos[j] = opos[i];
i++, j++;
continue;
}
/* Pad removed */
if (seq[i] == '*') {
i++;
if (io_length(io, rnum) < 0) {
tag_shift_for_delete(io, rnum, r.length - i + 1);
} else {
tag_shift_for_delete(io, rnum, i+np--);
}
continue;
}
/* Pad created */
if (newseq[j] == '*') {
int k;
int cl = 0, cr = 0;
for (k = i-1; k >= 0; k--) {
if (seq[k] != '*') {
cl = conf[k];
break;
}
}
for (k = i+1; k < r.length; k++) {
if (seq[k] != '*') {
cr = conf[k];
break;
}
}
newconf[j] = MIN(cl, cr); /* min conf of neighbours */
newopos[j] = 0;
j++;
if (io_length(io, rnum) < 0) {
tag_shift_for_insert(io, rnum, r.length - i + 1);
} else {
tag_shift_for_insert(io, rnum, i+ ++np);
}
continue;
}
fprintf(stderr, "Alignment introduced non-pad character");
abort();
}
/* Pads previously at the end of the reading & now removed */
for (; i < r.start + r.sequence_length;) {
if (seq[i] == '*') {
i++;
if (io_length(io, rnum) < 0) {
tag_shift_for_delete(io, rnum, r.length - i + 1);
} else {
tag_shift_for_delete(io, rnum, i+np--);
}
} else {
/* Error: clipped data that wasn't a pad */
abort();
}
}
/* Should only be pads remaining in newseq, if anything */
for (; j < r.start + cl->mseg->length; j++) {
if (newseq[j] != '*') {
fprintf(stderr, "Alignment introduced non-pad character");
abort();
}
newconf[j] = 0;
newopos[j] = 0;
}
/* Same for remaining data in seq - only pads */
for (; i < r.end-1; i++) {
if (seq[i] != '*') {
fprintf(stderr, "Alignment skipped non-pad character");
abort();
}
}
/* Append on the right hand cutoff data */
for (; i < r.length; i++, j++) {
newseq[j] = seq[i];
newconf[j] = conf[i];
newopos[j] = opos[i];
}
if (j != newlen) {
abort();
}
r.length = j;
TextWrite(io, r.sequence, newseq, r.length);
DataWrite(io, r.confidence, newconf, r.length, 1);
DataWrite(io, r.orig_positions, newopos, r.length * 2, 2);
xfree(conf);
xfree(newconf);
xfree(opos);
xfree(newopos);
xfree(newseq);
}
r.position = cl->mseg->offset + 1;
r.sequence_length = cl->mseg->length;
r.end = r.start + r.sequence_length + 1;
lastr = r;
lastrnum = rnum;
io_relpos(io, rnum) = r.position;
io_length(io, rnum) = io_length(io, rnum) < 0 ? -r.sequence_length
: +r.sequence_length;
xfree(seq);
}
if (lastrnum) {
io_rnbr(io, lastrnum) = 0;
lastr.right = 0;
gel_write(io, lastrnum, lastr);
}
c.length = malign->length;
c.right = lastrnum;
io_clength(io, cnum) = c.left;
io_crnbr(io, cnum) = c.right;
contig_write(io, cnum, c);
io_clength(io, cnum) = c.length;
update_consensus_tags(io, cnum, malign);
}
static void LOADERDECL TexMtx_Write_Float(VertexLoader* loader)
{
DataWrite(float(loader->m_curtexmtx[loader->m_texmtxwrite++]));
}
__forceinline void _SetCol(u32 val)
{
DataWrite(val);
colIndex++;
}
void
OSocketWeb::SL_DataAvailable()
{
g_oMutex.lock(); // Make sure all signals SI_MessageAvailable() are synchronized
int cbDataAvailable = bytesAvailable(); // Read only once the number of bytes available. This is important to prevent 'thread starvation' in the case the socket data arrives faster than the web socket can handle it. By readin the bytes available once, we are guaranteed this 'state machine' method will eventually exit.
switch (m_eSocketState)
{
case eSocketState_WaitingForHandshake:
readAll(); // Flush the handshake
m_eSocketState = eSocketState_WaitingForFrameHeader;
// Fall Through //
case eSocketState_WaitingForFrameHeader:
WaitingForFrameHeader:
cbDataAvailable -= 2;
if (cbDataAvailable >= 0)
{
BYTE rgbFrameHeader[2];
read(OUT (char *)rgbFrameHeader, sizeof(rgbFrameHeader));
m_bFrameHeader0_kfFragmentFinal = (rgbFrameHeader[0] & d_bFrameHeader0_kfFragmentFinal);
const BYTE bOpcode = (rgbFrameHeader[0] & d_bFrameHeader0_kmFragmentOpcode);
if (bOpcode != eOpcode_zContinue)
m_bFrameHeader0_eOpcode = bOpcode;
m_bFrameHeader1_kfPayloadMasked = (rgbFrameHeader[1] & d_bFrameHeader1_kfPayloadMasked);
m_cblFrameData = (rgbFrameHeader[1] & d_bFrameHeader1_kmPayloadLength);
// MessageLog_AppendTextFormatCo(COX_MakeBold(d_coBlue), "WebSocket Header: [0]=0x$x [1]=0x$x (Frame = $L bytes, $L bytes remaining)\n", rgbFrameHeader[0], rgbFrameHeader[1], m_cblFrameData, bytesAvailable());
switch (m_cblFrameData)
{
case d_bFrameHeader1_kePayloadLength16:
m_eSocketState = eSocketState_WaitingForFrameHeaderPayload16;
goto WaitingForFrameHeaderPayload16;
case d_bFrameHeader1_kePayloadLength64:
m_eSocketState = eSocketState_WaitingForFrameHeaderPayload64;
goto WaitingForFrameHeaderPayload64;
} // switch
m_eSocketState = eSocketState_WaitingForFrameHeaderMask;
goto WaitingForFrameHeaderMask;
}
break;
case eSocketState_WaitingForFrameHeaderPayload16:
WaitingForFrameHeaderPayload16:
cbDataAvailable -= sizeof(quint16);
if (cbDataAvailable >= 0)
{
quint16 cbwFrameData;
read(OUT (char *)&cbwFrameData, sizeof(cbwFrameData));
m_cblFrameData = qFromBigEndian(cbwFrameData);
m_eSocketState = eSocketState_WaitingForFrameHeaderMask;
//MessageLog_AppendTextFormatCo(COX_MakeBold(d_coRed), "WebSocket Payload16: $L bytes\n", m_cblFrameData);
goto WaitingForFrameHeaderMask;
}
break;
case eSocketState_WaitingForFrameHeaderPayload64:
WaitingForFrameHeaderPayload64:
cbDataAvailable -= sizeof(quint64);
if (cbDataAvailable >= 0)
{
quint64 cblFrameData;
read(OUT (char *)&cblFrameData, sizeof(cblFrameData));
m_cblFrameData = qFromBigEndian(cblFrameData);
MessageLog_AppendTextFormatCo(COX_MakeBold(d_coRed), "WebSocket Payload64: $L bytes\n", m_cblFrameData);
m_eSocketState = eSocketState_WaitingForFrameHeaderMask;
goto WaitingForFrameHeaderMask;
}
break;
case eSocketState_WaitingForFrameHeaderMask:
WaitingForFrameHeaderMask:
if (m_bFrameHeader1_kfPayloadMasked)
{
MessageLog_AppendTextFormatCo(d_coRed, "Frame is masked\n");
cbDataAvailable -= sizeof(m_rgbFrameMask);
if (cbDataAvailable < 0)
break;
read(OUT (char *)m_rgbFrameMask, sizeof(m_rgbFrameMask));
}
m_eSocketState = eSocketState_WaitingForFrameDataPayload;
// Fall Through //
case eSocketState_WaitingForFrameDataPayload:
cbDataAvailable -= m_cblFrameData;
if (cbDataAvailable >= 0)
{
BYTE * pbData = m_binFrameData.PbeAllocateExtraDataWithVirtualNullTerminator(m_cblFrameData);
const int cbDataRead = read(OUT (char *)pbData, m_cblFrameData); // Read the data from the socket
if (cbDataRead != m_cblFrameData)
MessageLog_AppendTextFormatSev(eSeverityErrorWarning, "WebSocket: cbDataRead=$I, m_cblFrameData=$L\n", cbDataRead, m_cblFrameData);
// MessageLog_AppendTextFormatCo(d_coBlueDark, "$s\n", pbData);
if (m_bFrameHeader0_kfFragmentFinal)
{
// Check if there are any special opcodes the socket can handle automatically
switch (m_bFrameHeader0_eOpcode)
{
case eOpcode_DataText:
case eOpcode_DataBinary:
emit SI_MessageAvailable(INOUT m_binFrameData); // Both text and binary are treated the same, as Cambrian uses UTF-8 for text
break;
case eOpcode_Ping:
DataWrite(INOUT m_binFrameData, eOpcode_Pong); // Respond to the ping request
break;
case eOpcode_Close:
// Close the socket
break;
} // switch
m_binFrameData.Empty();
} // if
m_eSocketState = eSocketState_WaitingForFrameHeader;
goto WaitingForFrameHeader;
}
break;
} // switch
g_oMutex.unlock();
} // SL_DataAvailable()
void
OSocketWeb::DataWrite(IN_MOD_INV CBin & binData, EOpcode eOpcode)
{
DataWrite(binData.PbGetData(), binData.CbGetData(), eOpcode);
}
static void SetCol(VertexLoader* loader, u32 val)
{
DataWrite(val);
loader->m_colIndex++;
}
