void* readdir(void *d) {
# if !CAM_DRYOS
return _readdir(d);
#else
// for DRYOS cameras A650, A720 do something with this! - sizeof(de[]) must be >= sizeof(struct dirent): 'static char de[40];'
static char de[40];
_ReadFastDir(d, &de);
return de[0]? &de : (void*)0;
#endif
}
/*---------------------------------------------------------------------------*/
static int
s_opendir(struct cfs_dir *p, const char *n)
{
struct cpc_dir *cpcdir = (struct cpc_dir *)p;
char *buffer = malloc(2048);
if (buffer)
{
cpcdir->buffer = buffer;
cpcdir->ptr = buffer;
_readdir(buffer);
return 0;
}
return 1;
}
int
readdir(const char *fusepath,
void *buf,
fuse_fill_dir_t filler,
off_t offset,
fuse_file_info *fi)
{
const fuse_context *fc = fuse_get_context();
const Config &config = Config::get(fc);
const ugid::Set ugid(fc->uid,fc->gid);
const rwlock::ReadGuard readlock(&config.srcmountslock);
return _readdir(config.srcmounts,
fusepath,
buf,
filler);
}
SDL_bool dr_load_driver_dir(char *dirname) {
DIR *pdir;
struct stat buf;
struct SceIoDirent *pfile;
if (!(pdir=_opendir (dirname))) {
printf("Couldn't find %s\n",dirname);
return SDL_FALSE;
}
while(pfile=_readdir(pdir)) {
char *filename=alloca(strlen(pfile->d_name)+strlen(dirname)+2);
sprintf(filename,"%s/%s",dirname,pfile->d_name);
sceIoGetstat(filename,&buf);
if (S_ISREG(buf.st_mode)) {
dr_load_driver(filename);
}
}
_closedir(pdir);
return SDL_TRUE;
}
int readline(char *buf, int size) {
int idx;
int len;
int key;
int i;
int done;
int hist_idx;
int dir;
if (size <= 0) {
errno = EINVAL;
return -1;
}
idx = 0;
len = 0;
done = 0;
hist_idx = history_len;
while (!done) {
fflush(stdout);
key = getkey();
if (key < 0) return key;
if (key == KEY_TAB) {
int start;
int end;
int split;
char mask[MAXPATH];
struct direntry dirent;
start = idx;
while (start > 0 && !delimchar(buf[start - 1])) start--;
end = split = start;
while (end < len && !delimchar(buf[end])) {
if (buf[end] == PS1 || buf[end] == PS2) split = end + 1;
end++;
}
dir = find_dir(buf, start, end, split, mask);
if (dir >= 0) {
while (_readdir(dir, &dirent, 1) > 0) {
int newlen = len - (end - split) + dirent.namelen;
if (like(dirent.name, mask) && newlen < size - 1) {
memmove(buf + split + dirent.namelen, buf + end, len - end);
memcpy(buf + split, dirent.name, dirent.namelen);
while (idx < split) putchar(buf[idx++]);
while (idx > split) {
putchar('\b');
idx--;
}
for (i = split; i < newlen; i++) putchar(buf[i]);
if (newlen < len) {
for (i = newlen; i < len; i++) putchar(' ');
for (i = newlen; i < len; i++) putchar('\b');
}
end = split + dirent.namelen;
len = newlen;
idx = end;
for (i = end; i < len; i++) putchar('\b');
fflush(stdout);
key = getkey();
if (key < 0) break;
if (key != KEY_TAB) break;
}
}
close(dir);
if (key < 0) return key;
}
}
switch (key) {
case KEY_LEFT:
if (idx > 0) {
putchar('\b');
idx--;
}
break;
case KEY_RIGHT:
if (idx < len) {
putchar(buf[idx]);
idx++;
}
break;
case KEY_CTRL_LEFT:
if (idx > 0) {
putchar('\b');
idx--;
}
while (idx > 0 && buf[idx - 1] != ' ') {
putchar('\b');
idx--;
}
break;
case KEY_CTRL_RIGHT:
while (idx < len && buf[idx] != ' ') {
putchar(buf[idx]);
idx++;
}
if (idx < len) {
putchar(buf[idx]);
idx++;
}
break;
case KEY_HOME:
while (idx > 0) {
putchar('\b');
idx--;
}
break;
case KEY_END:
while (idx < len) {
putchar(buf[idx]);
idx++;
}
break;
case KEY_DEL:
if (idx < len) {
len--;
memmove(buf + idx, buf + idx + 1, len - idx);
for (i = idx; i < len; i++) putchar(buf[i]);
putchar(' ');
putchar('\b');
for (i = idx; i < len; i++) putchar('\b');
}
break;
case KEY_INS:
insmode = !insmode;
break;
case KEY_BACKSPACE:
if (idx > 0) {
putchar('\b');
idx--;
len--;
memmove(buf + idx, buf + idx + 1, len - idx);
for (i = idx; i < len; i++) putchar(buf[i]);
putchar(' ');
putchar('\b');
for (i = idx; i < len; i++) putchar('\b');
}
break;
case KEY_ESC:
if (_break_on_escape) {
buf[len] = 0;
errno = EINTR;
return -1;
} else {
for (i = 0; i < idx; i++) putchar('\b');
for (i = 0; i < len; i++) putchar(' ');
for (i = 0; i < len; i++) putchar('\b');
idx = len = 0;
}
break;
case KEY_EOF:
if (len == 0) return -1;
break;
case KEY_ENTER:
putchar('\r');
putchar('\n');
done = 1;
break;
case KEY_UP:
if (hist_idx > 0) {
hist_idx--;
for (i = 0; i < idx; i++) putchar('\b');
for (i = 0; i < len; i++) putchar(' ');
for (i = 0; i < len; i++) putchar('\b');
len = strlen(history[hist_idx]);
if (len > size - 1) len = size - 1;
idx = len;
memcpy(buf, history[hist_idx], len);
for (i = 0; i < len; i++) putchar(buf[i]);
}
break;
case KEY_DOWN:
if (hist_idx < history_len - 1) {
hist_idx++;
for (i = 0; i < idx; i++) putchar('\b');
for (i = 0; i < len; i++) putchar(' ');
for (i = 0; i < len; i++) putchar('\b');
len = strlen(history[hist_idx]);
if (len > size - 1) len = size - 1;
idx = len;
memcpy(buf, history[hist_idx], len);
for (i = 0; i < len; i++) putchar(buf[i]);
}
break;
case KEY_UNKNOWN:
break;
default:
if (key >= 0x20 && key <= 0xFF) {
if (insmode) {
if (len < size - 1) {
if (idx < len) memmove(buf + idx + 1, buf + idx, len - idx);
buf[idx] = key;
len++;
for (i = idx; i < len; i++) putchar(buf[i]);
idx++;
for (i = idx; i < len; i++) putchar('\b');
}
} else {
if (idx < size - 1) {
buf[idx] = key;
putchar(buf[idx]);
if (idx == len) len++;
idx++;
}
}
}
}
}
buf[len] = 0;
add_to_history(buf);
return len;
}
static void syscall_handler(struct intr_frame *f) {
int status;
const char *cmdline, *f_name;
unsigned f_size, position, size;
uint32_t fd;
mapid_t mapping;
struct supp_table *st;
struct thread* t = thread_current();
/* Retrieve syscall number */
uint32_t sys_no = read4(f, 0);
void *buffer;
pid_t pid;
/* The following is for page fault in syscall.
* Set the thread's syscall status as true.
* Store the current esp in the thread's esp field */
t->syscall = true;
t->esp = f->esp;
/* Note after each syscall is about to finish, we will
* set the thread's syscall status back to false. */
switch (sys_no) {
case SYS_HALT:
halt();
t->syscall = false;
t->esp = NULL;
break;
case SYS_EXIT:
status = (int) read4(f, 4);
exit(status);
t->syscall = false;
t->esp = NULL;
break;
case SYS_EXEC:
cmdline = (const char*) read4(f, 4);
f->eax = (uint32_t) exec(cmdline);
break;
case SYS_WAIT:
pid = (pid_t) read4(f, 4);
f->eax = (uint32_t) wait(pid);
t->syscall = false;
t->esp = NULL;
break;
case SYS_CREATE:
f_name = (const char*) read4(f, 4);
f_size = (unsigned) read4(f, 8);
f->eax = (uint32_t) create(f_name, f_size);
t->syscall = false;
t->esp = NULL;
break;
case SYS_REMOVE:
f_name = (const char*) read4(f, 4);
f->eax = (uint32_t) remove(f_name);
t->syscall = false;
t->esp = NULL;
break;
case SYS_OPEN:
f_name = (const char*) read4(f, 4);
f->eax = (uint32_t) open(f_name);
break;
case SYS_FILESIZE:
fd = (uint32_t) read4(f, 4);
f->eax = (uint32_t) filesize(fd);
t->syscall = false;
t->esp = NULL;
break;
case SYS_READ:
fd = (uint32_t) read4(f, 4);
buffer = (void*) read4(f, 8);
size = (unsigned) read4(f, 12);
f->eax = (uint32_t) read(fd, buffer, size);
t->syscall = false;
t->esp = NULL;
break;
case SYS_WRITE:
fd = (uint32_t) read4(f, 4);
buffer = (void*) read4(f, 8);
size = (unsigned) read4(f, 12);
f->eax = (uint32_t) write(fd, buffer, size);
t->syscall = false;
t->esp = NULL;
break;
case SYS_SEEK:
fd = (uint32_t) read4(f, 4);
position = (unsigned) read4(f, 8);
seek(fd, position);
t->syscall = false;
t->esp = NULL;
break;
case SYS_TELL:
fd = (uint32_t) read4(f, 4);
f->eax = (uint32_t) tell(fd);
t->syscall = false;
t->esp = NULL;
break;
case SYS_CLOSE:
fd = (uint32_t) read4(f, 4);
close(fd);
t->syscall = false;
t->esp = NULL;
break;
case SYS_MMAP:
fd = (uint32_t) read4(f, 4);
buffer = (void*) read4(f, 8);
f->eax = (uint32_t) mmap(fd, buffer);
t->syscall = false;
t->esp = NULL;
break;
case SYS_MUNMAP:
mapping = (mapid_t) read4(f, 4);
munmap(mapping);
t->syscall = false;
t->esp = NULL;
break;
case SYS_ISDIR:
fd = (uint32_t) read4(f, 4);
f->eax = (uint32_t) _isdir(fd);
t->syscall = false;
t->esp = NULL;
break;
case SYS_INUMBER:
fd = (uint32_t) read4(f,4);
f->eax = (uint32_t) _inumber(fd);
t->syscall = false;
t->esp = NULL;
break;
case SYS_CHDIR:
f_name = (const char*) read4(f,4);
f->eax = (uint32_t) _chdir(f_name);
t->syscall = false;
t->esp = NULL;
break;
case SYS_MKDIR:
f_name = (const char*) read4(f,4);
f->eax = (uint32_t) _mkdir(f_name);
t->syscall = false;
t->esp = NULL;
break;
case SYS_READDIR:
fd = (uint32_t) read4(f,4);
f_name = (char*) read4(f, 8);
f->eax = (uint32_t) _readdir(fd, f_name);
t->syscall = false;
t->esp = NULL;
break;
default:
exit(-1);
t->syscall = false;
t->esp = NULL;
break;
}
}
int main(int argc, char** argv) {
ARGS optarg = arg_parse(argc, argv);
if (strcmp(optarg.program, "") == 0 ||
strcmp(optarg.genome, "") == 0 ||
strcmp(optarg.data, "") == 0) {
echo_usage(argv);
return -1;
}
MPI_Init(NULL, NULL);
int world_rank;
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
int world_size;
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
int* nfiles_copy = (int*)malloc(sizeof(int));
assert(nfiles_copy != NULL);
/* Root */
char *flist;
int nfiles = 0;
if (world_rank == 0) {
_readdir(optarg.genome, &flist, &nfiles);
*nfiles_copy = nfiles;
//list_filenames(flist, world_rank, nfiles);
}
MPI_Barrier(MPI_COMM_WORLD);
MPI_Bcast(nfiles_copy, 1, MPI_INT, 0, MPI_COMM_WORLD);
// add 1 to prevent missing a file when scatter splits entire memory.
div_t div_result = div(*nfiles_copy, world_size);
int num_per_node = div_result.quot;
int remainder = div_result.rem;
if (*nfiles_copy < world_size) {
num_per_node = 1;
remainder = 0;
}
int bytes_per_node = NAME_MAX;
bytes_per_node *= num_per_node;
char *sub_results = (char *)malloc(sizeof(char) * bytes_per_node);
assert(sub_results != NULL);
//memset(sub_results + (num_per_node - 1) * NAME_MAX, '\0', NAME_MAX);
MPI_Scatter(flist, bytes_per_node , MPI_BYTE, sub_results,
bytes_per_node, MPI_BYTE, 0, MPI_COMM_WORLD);
run_mgescan_cmd(sub_results, optarg, num_per_node);
if ( remainder && world_rank == 0) {
run_mgescan_cmd(flist + (bytes_per_node * world_size), optarg, remainder);
}
//MPI_Gather(&sub_avg, 1, MPI_FLOAT, sub_avgs, 1, MPI_FLOAT, 0, MPI_COMM_WORLD);
// Clean up
if (world_rank == 0)
free(flist);
free(sub_results);
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
}
/**
* Interrupt 80h. Handles the system calls.
*
* @param regs Pointer to struct containing micro's registers.
*/
void int80(registers* regs) {
switch (regs->eax) {
case _SYS_READ:
regs->eax = _read((unsigned int)regs->ebx, (char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_WRITE:
regs->eax = _write((unsigned int)regs->ebx, (const char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_TIME:
regs->eax = _time((time_t*)translate(regs->ebx));
break;
case _SYS_IOCTL:
regs->eax = _ioctl(regs->ebx, regs->ecx, (void*)translate(regs->edx));
break;
case _SYS_TICKS:
regs->eax = _getTicksSinceStart();
break;
case _SYS_YIELD:
// This just makes sure we call the scheduler again, for now
break;
case _SYS_EXIT:
_exit();
break;
case _SYS_GETPID:
regs->eax = _getpid();
break;
case _SYS_GETPPID:
regs->eax = _getppid();
break;
case _SYS_RUN:
regs->eax = _run((EntryPoint) translate(regs->ebx), (char*) translate(regs->ecx), regs->edx);
break;
case _SYS_WAIT:
regs->eax = _wait();
break;
case _SYS_KILL:
_kill((pid_t) regs->ebx);
break;
case _SYS_PINFO:
regs->eax = _pinfo((struct ProcessInfo*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_SLEEP:
_sleep(regs->ebx);
break;
case _SYS_NICE:
regs->eax = _nice(regs->ebx);
break;
case _SYS_RENICE:
regs->eax = _renice(regs->ebx, regs->ecx);
break;
case _SYS_CLOSE:
regs->eax = _close(regs->ebx);
break;
case _SYS_OPEN:
regs->eax = _open((char*)translate(regs->ebx), regs->ecx, regs->edx);
break;
case _SYS_CREAT:
regs->eax = _creat((char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_MKDIR:
regs->eax = _mkdir((const char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_RMDIR:
regs->eax = _rmdir((const char*)translate(regs->ebx));
break;
case _SYS_UNLINK:
regs->eax = _unlink((const char*)translate(regs->ebx));
break;
case _SYS_RENAME:
regs->eax = _rename((const char*)translate(regs->ebx), (const char*)translate(regs->ecx));
break;
case _SYS_CHDIR:
regs->eax = _chdir((const char*)translate(regs->ebx));
break;
case _SYS_GETCWD:
regs->eax = _getcwd((char*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_READDIR:
regs->eax = _readdir(regs->ebx, (struct fs_DirectoryEntry*)translate(regs->ecx), regs->edx);
break;
case _SYS_SETPPERSONA:
_setProcessPersona(regs->ebx, regs->ecx, regs->edx);
break;
case _SYS_GETPPERSONA:
_getProcessPersona(regs->ebx, (int*)translate(regs->ecx), (int*) translate(regs->edx));
break;
case _SYS_SYMLINK:
regs->eax = _symlink((const char *)translate(regs->ebx), (const char *)translate(regs->ecx));
break;
case _SYS_MKFIFO:
regs->eax = _mkfifo((const char*)translate(regs->ebx));
break;
case _SYS_CHMOD:
regs->eax = _chmod(regs->ebx, (const char*)translate(regs->ecx));
break;
case _SYS_STAT:
regs->eax = _stat((const char*)translate(regs->ebx), (struct stat*)translate(regs->ecx));
break;
case _SYS_CHOWN:
regs->eax = _chown((const char*)translate(regs->ebx));
break;
case _SYS_LOG:
_loglevel(regs->ebx);
break;
case _SYS_STACKSIZE:
regs->eax = _stacksize();
}
}
