void set_thread_affinity(int cpu_number)
{
int ret = 0;
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(cpu_number%cpu_online, &mask);
if ((ret = pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask)) != 0)
{
posix_error(ret, "set thread affinity failed");
}
}
static PyObject *
_uptime_secs(PyObject *self, PyObject *args)
{
int iRslt = -1;
double cur_uptime = 0.0;
struct sysinfo si;
// Make sure that no arguments were specified
if(!PyArg_ParseTuple(args, ":secs"))
return NULL;
errno = 0;
iRslt = sysinfo(&si);
if(iRslt < 0)
return posix_error();
cur_uptime = (double)(si.uptime);
#ifdef DEBUG
// If we are in debug mode, check to see if the uptime has
// been overriden.
if (override_secs != 0.0)
cur_uptime = override_secs;
#endif
// Now check for a wrap.
if (cur_uptime < (last_uptime - 1.0)) {
#ifdef VERBOSE
printf("Detected a wrap! (%lf and %lf).\n", cur_uptime, last_uptime);
#endif
// OK, we've got a wrap.
if (last_uptime > max_uptime) {
max_uptime = last_uptime;
#ifdef VERBOSE
printf("max_uptime is now set to %lf.\n", max_uptime);
#endif
}
uptime_offset += (unsigned long) max_uptime;
#ifdef VERBOSE
printf("uptime_offset is now %ld.\n", uptime_offset);
#endif
}
last_uptime = cur_uptime;
// If we've had a wrap, add the uptime_offset to the current uptime
if (uptime_offset != 0) {
cur_uptime += (double) uptime_offset;
}
#ifdef EXTRA_VERBOSE
printf("uptime_secs: Returning %lf.\n", cur_uptime);
#endif
return Py_BuildValue("d", cur_uptime);
}
static PyObject *
subterfugue_atcallstop(PyObject *self, PyObject *args)
{
int pid, stopsig, result;
if (!PyArg_Parse(args, "(ii)", &pid, &stopsig))
return NULL;
result = atcallstop(pid, stopsig);
if (result == -1)
return posix_error();
return Py_BuildValue("i", result);
}
static PyObject *
_uptime_raw_secs(PyObject *self, PyObject *args)
{
int iRslt = -1;
double cur_uptime = 0.0;
struct sysinfo si;
// Make sure that no arguments were specified:
if (!PyArg_ParseTuple(args, ":secs"))
return NULL;
errno = 0;
iRslt = sysinfo(&si);
if(iRslt < 0)
return posix_error();
cur_uptime = (double)(si.uptime);
return Py_BuildValue("d", cur_uptime);
}
void Pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr) {
int rc;
if ((rc = pthread_mutex_init(mutex, attr)) != 0)
posix_error(rc, "Pthread_mutex_init error");
}
void Pthread_mutex_unlock(pthread_mutex_t *mutex) {
int rc;
if ((rc = pthread_mutex_unlock(mutex)) != 0)
posix_error(rc, "Pthread_mutex_unlock error");
}
void Pthread_join(pthread_t tid, void **thread_return) {
int rc;
if ((rc = pthread_join(tid, thread_return)) != 0)
posix_error(rc, "Pthread_join error");
}
/* $begin detach */
void Pthread_detach(pthread_t tid) {
int rc;
if ((rc = pthread_detach(tid)) != 0)
posix_error(rc, "Pthread_detach error");
}
void Pthread_detach(pthread_t tid)
{
int rt = pthread_detach(tid);
if( rt != 0)
posix_error(rt, "pthread_detach error");
}
void Pthread_cancel(pthread_t tid) {
int rc;
if ((rc = pthread_cancel(tid)) != 0)
posix_error(rc, "Pthread_cancel error");
}
int main(int argc, char *argv[])
{
struct thread_data *threads;
struct thread_data *thread;
int i, ret, ch;
if (argc > 1)
{
if (strcmp(argv[1], "--help") == 0)
{
usage_error(argv[0]);
}
init_program_parameter(argc, argv);
}
program_parameter(argv[0]);
create_matrix(&matrix_a);
create_matrix(&matrix_b);
create_matrix(&matrix_c);
create_matrix(&matrix_d);
random_matrix(matrix_a);
random_matrix(matrix_b);
nonmal_matrix_multipy(matrix_a, matrix_b, matrix_d);
threads = (struct thread_data *)malloc(pthread_max * sizeof(struct thread_data));
if (threads == NULL)
{
unix_error("malloc threads failed");
}
cpu_online = sysconf(_SC_NPROCESSORS_CONF);
for(i = 0; i < pthread_max; i++)
{
thread = threads + i;
thread->index = i;
if ((ret = pthread_create(&thread->thread_id, NULL, thread_func, thread)) != 0)
{
posix_error(ret, "pthread_create failed");
}
}
for(i = 0; i < pthread_max; i++)
{
thread = threads + i;
if ((ret = pthread_join(thread->thread_id, NULL)) != 0)
{
posix_error(ret, "pthread_join failed");
}
}
if (matrix_equal(matrix_c, matrix_d) == 0)
{
unix_error("runtime error");
}
if (dump)
{
dump_matrix("matrix A", matrix_a);
dump_matrix("matrix B", matrix_b);
dump_matrix("matrix C", matrix_c);
dump_matrix("matrix D", matrix_d);
}
statistics(threads);
free_matrix(matrix_a);
free_matrix(matrix_b);
free_matrix(matrix_c);
free_matrix(matrix_d);
free(threads);
return 0;
}
void Pthread_cond_destroy(pthread_cond_t *cond) {
int rc;
if ((rc = pthread_cond_destroy(cond)) != 0)
posix_error(rc, "Pthread_cond_destroy");
}
bool MemFile::open (const std::string &path_, bool uncompress)
{
MEMORY mem(MAX_IMAGE_SIZE + 1);
size_t uRead = 0;
// Check if zlib is available
#ifdef HAVE_ZLIBSTAT
bool have_zlib = true;
#elif defined(HAVE_ZLIB)
bool have_zlib = CheckLibrary("zlib", "zlibVersion") && zlibVersion()[0] == ZLIB_VERSION[0];
#else
bool have_zlib = false;
#endif
#ifdef HAVE_ZLIB
// Try opening as a zip file
if (uncompress && have_zlib)
{
unzFile hfZip = unzOpen(path_.c_str());
if (hfZip)
{
int nRet;
unz_file_info sInfo;
uLong ulMaxSize = 0;
// Iterate through the contents of the zip looking for a file with a suitable size
for (nRet = unzGoToFirstFile(hfZip); nRet == UNZ_OK; nRet = unzGoToNextFile(hfZip))
{
char szFile[MAX_PATH];
// Get details of the current file
unzGetCurrentFileInfo(hfZip, &sInfo, szFile, MAX_PATH, nullptr, 0, nullptr, 0);
// Ignore directories and empty files
if (!sInfo.uncompressed_size)
continue;
// If the file extension is recognised, read the file contents
// ToDo: GetFileType doesn't really belong here?
if (GetFileType(szFile) != ftUnknown && unzOpenCurrentFile(hfZip) == UNZ_OK)
{
nRet = unzReadCurrentFile(hfZip, mem, static_cast<unsigned int>(mem.size));
unzCloseCurrentFile(hfZip);
break;
}
// Rememeber the largest uncompressed file size
if (sInfo.uncompressed_size > ulMaxSize)
ulMaxSize = sInfo.uncompressed_size;
}
// Did we fail to find a matching extension?
if (nRet == UNZ_END_OF_LIST_OF_FILE)
{
// Loop back over the archive
for (nRet = unzGoToFirstFile(hfZip); nRet == UNZ_OK; nRet = unzGoToNextFile(hfZip))
{
// Get details of the current file
unzGetCurrentFileInfo(hfZip, &sInfo, nullptr, 0, nullptr, 0, nullptr, 0);
// Open the largest file found about
if (sInfo.uncompressed_size == ulMaxSize && unzOpenCurrentFile(hfZip) == UNZ_OK)
{
nRet = unzReadCurrentFile(hfZip, mem, static_cast<unsigned int>(mem.size));
unzCloseCurrentFile(hfZip);
break;
}
}
}
// Close the zip archive
unzClose(hfZip);
// Stop if something went wrong
if (nRet < 0)
throw util::exception("zip extraction failed (", nRet, ")");
uRead = nRet;
m_compress = Compress::Zip;
}
else
{
// Open as gzipped or uncompressed
gzFile gf = gzopen(path_.c_str(), "rb");
if (gf == Z_NULL)
throw posix_error(errno, path_.c_str());
uRead = gzread(gf, mem, static_cast<unsigned>(mem.size));
m_compress = (gztell(gf) != FileSize(path_)) ? Compress::Gzip : Compress::None;
gzclose(gf);
}
}
else
#endif // HAVE_ZLIB
{
// Open as normal file if we couldn't use zlib above
FILE *f = fopen(path_.c_str(), "rb");
if (!f)
throw posix_error(errno, path_.c_str());
uRead = fread(mem, 1, mem.size, f);
fclose(f);
m_compress = Compress::None;
}
// zip compressed? (and not handled above)
if (uncompress && mem[0U] == 'P' && mem[1U] == 'K')
throw util::exception("zlib (zlib1.dll) is required for zip support");
// gzip compressed?
if (uncompress && mem[0U] == 0x1f && mem[1U] == 0x8b && mem[2U] == 0x08)
{
if (!have_zlib)
throw util::exception("zlib (zlib1.dll) is required for gzip support");
#ifdef HAVE_ZLIB
MEMORY mem2(MAX_IMAGE_SIZE + 1);
uint8_t flags = mem[3];
auto pb = mem.pb + 10, pbEnd = mem.pb + mem.size;
if (flags & 0x04) // EXTRA_FIELD
{
if (pb < pbEnd - 1)
pb += 2 + pb[0] + (pb[1] << 8);
}
if (flags & 0x08 || flags & 0x10) // ORIG_NAME or COMMENT
{
while (pb < pbEnd && *pb++);
}
if (flags & 0x02) // HEAD_CRC
pb += 2;
z_stream stream = {};
stream.next_in = pb;
stream.avail_in = (pb < pbEnd) ? static_cast<uInt>(pbEnd - pb) : 0;
stream.next_out = mem2.pb;
stream.avail_out = mem2.size;
auto zerr = inflateInit2(&stream, -MAX_WBITS);
if (zerr == Z_OK)
{
zerr = inflate(&stream, Z_FINISH);
inflateEnd(&stream);
}
if (zerr != Z_STREAM_END)
throw util::exception("gzip decompression failed (", zerr, ")");
memcpy(mem.pb, mem2.pb, uRead = stream.total_out);
m_compress = Compress::Zip;
#endif
}
// bzip2 compressed?
if (uncompress && mem[0U] == 'B' && mem[1U] == 'Z')
{
#ifdef HAVE_BZIP2
if (!CheckLibrary("bzip2", "BZ2_bzBuffToBuffDecompress"))
#endif
throw util::exception("libbz2 (bzip2.dll) is required for bzip2 support");
#ifdef HAVE_BZIP2
MEMORY mem2(MAX_IMAGE_SIZE + 1);
auto uBzRead = static_cast<unsigned>(mem2.size);
auto bzerr = BZ2_bzBuffToBuffDecompress(reinterpret_cast<char *>(mem2.pb), &uBzRead, reinterpret_cast<char *>(mem.pb), uRead, 0, 0);
if (bzerr != BZ_OK)
throw util::exception("bzip2 decompression failed (", bzerr, ")");
memcpy(mem.pb, mem2.pb, uRead = uBzRead);
m_compress = Compress::Bzip2;
#endif // HAVE_BZIP2
}
if (uRead <= MAX_IMAGE_SIZE)
return open(mem.pb, static_cast<int>(uRead), path_);
throw util::exception("file size too big");
}
void Pthread_cond_broadcast(pthread_cond_t *cond) {
int rc;
if ((rc = pthread_cond_broadcast(cond)) != 0)
posix_error(rc, "Pthread_cond_broadcast error");
}
static PyObject *
subterfugue_mainloop(PyObject *self, PyObject *args)
{
int pid, wpid, status, scno, eax, waitchannelhack;
int beforecall = -1;
if (!PyArg_Parse(args, "(ii)", &pid, &waitchannelhack))
return NULL;
numtraced++;
while (1) {
int result;
#ifndef __WALL
#define __WALL 0x40000000
#endif
wpid = wait4(-1, &status, WUNTRACED | __WALL, NULL);
if (wpid == -1)
return posix_error();
DBG("Checking pids: %d, %d\n", pid, wpid);
if (pid != wpid) /* XXX: could maybe be handled w/o giving up */
goto giveup;
DBG("This looks good\n");
if (!WIFSTOPPED(status))
goto giveup;
DBG("checking SIGTRAP\n");
if (!waitchannelhack) {
if (WSTOPSIG(status) != (SIGTRAP | 0x80))
goto giveup;
} else {
int r = atcallstop(pid, WSTOPSIG(status));
if (r == -1)
return posix_error(); /* shouldn't happen, but tell the caller */
if (!r)
goto giveup;
}
/* Only check the system call number on the before stop, because some
calls (e.g., sigreturn) stomp that number. On the after stop, by the
time we get here it "must" be okay to ignore this stop. (Skipping
these checks also speeds things up a bit.)
*/
if (beforecall) {
DBG("getting scno\n");
scno = ptrace(PTRACE_PEEKUSER, wpid, 4*ORIG_EAX, PTRACE_ARGTYPE &scno);
DBG("scno is %d (%m)\n", scno);
if (scno < 0 || scno >= MAXCALLNUMBER)
goto giveup;
DBG("looking if call_ignored\n");
if (!call_ignored[scno])
goto giveup;
eax = ptrace(PTRACE_PEEKUSER, wpid, 4*EAX, 0);
if ((eax != -ENOSYS) /* && beforecall */)
goto giveup;
}
DBG("ok, this call is ignored here\n" );
beforecall = !beforecall;
result = ptrace(PTRACE_SYSCALL, pid, 0, 0);
if (result == -1)
return posix_error(); /* shouldn't happen, but tell the caller */
numignored++;
if (!(numignored % 1000))
DBG("numignored = %d, numtraced = %d\n", numignored, numtraced);
}
giveup:
/* if beforecall is nonzero, change 'insyscall' status of _pid_ to that returned */
// fprintf( stderr, "Returning %d, %d, %d\n", wpid, status, beforecall );
return Py_BuildValue("(iii)", wpid, status, beforecall);
}
void Pthread_create(pthread_t *tidp, pthread_attr_t *attrp, void * (*routine)(void *), void *argp) {
int rc;
if ((rc = pthread_create(tidp, attrp, routine, argp)) != 0)
posix_error(rc, "Pthread_create error");
}
void Pthread_barrier_destroy(pthread_barrier_t *barrier) {
int rc;
if ((rc = pthread_barrier_destroy(barrier)) != 0)
posix_error(rc, "Pthread_barrier_destroy");
}
void Pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr) {
int rc;
if ((rc = pthread_cond_init(cond, attr)) != 0)
posix_error(rc, "Pthread_cond_init error");
}
void Pthread_join(pthread_t tid, void **thread_return)
{
int rt = pthread_join(tid, thread_return);
if( rt != 0 )
posix_error(rt, "pthread_join error");
}
void Pthread_cond_signal(pthread_cond_t *cond) {
int rc;
if ((rc = pthread_cond_signal(cond)) != 0)
posix_error(rc, "Pthread_cond_signal error");
}
void Pthread_mutex_destroy(pthread_mutex_t *mutex) {
int rc;
if ((rc = pthread_mutex_destroy(mutex)) != 0)
posix_error(rc, "Pthread_mutex_destroy");
}
void Pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
int rc;
if ((rc = pthread_cond_wait(cond, mutex)) != 0)
posix_error(rc, "Pthread_cond_wait error");
}
void Pthread_cancel(pthread_t tid)
{
int rt = pthread_cancel(tid);
if(rt != 0)
posix_error(rt, "Pthread_cancel error");
}
