// load a 256x256 RGB .RAW file as a texture
// http://www.nullterminator.net/gltexture.html
GLuint gl_load_texture_raw(const char * filename, u_int width, u_int height, u_int alpha) {
char* data;
FILE* file;
printf("loading raw texture [%s]\n", filename);
// open texture data
file = fopen(filename, "rb");
if ( file == NULL ) return 0;
// allocate buffer
// width = 256;
// height = 256;
width = 512;
height = 512;
data = (char*) malloc(width * height * (alpha ? 4 : 3));
if (data == NULL)
pexit(errno, "gl_load_texture_raw: can't allocate space for image data");
// read texture data
fread(data, width * height * (alpha ? 4 : 3), 1, file );
fclose(file);
return gl_load_texture_from_data(data, 512, 512, (alpha ? 4 : 3));
}
/*
* this is the body for all kproc's
*/
static void
linkproc(void)
{
spllo();
up->kpfun(up->kparg);
pexit("kproc exiting", 0);
}
void *merge(void *hnd, c4snet_data_t *OutFile, c4snet_data_t *Result,
int X, c4snet_data_t *Out, int N, int B, int K, int J, int I)
{
const int P = N / B;
if (verbose) {
printf("%s: %p, %p, X=%d, %p, N=%d, B=%d, (%d, %d, %d)\n",
__func__, OutFile, Result, X, Out, N, B, K, J, I);
}
if (compute) {
c4snet_data_t **result = C4SNetGetData(Result);
assert(result[J + I * P] == NULL);
result[J + I * P] = Out;
}
if (X > 1) {
C4SNetOut(hnd, 1, OutFile, Result, X - 1);
}
else if (compute) {
struct timespec end;
if (clock_gettime(CLOCK_REALTIME, &end)) {
pexit("clock_gettime");
}
printf("Time for size %d x %d : %lf sec\n", N, N, delta_time(begin, end));
write_matrix(Result, N, B, OutFile);
C4SNetOut(hnd, 2, C4SNetCreate(CTYPE_char, 5, "Done."));
C4SNetFree(OutFile);
C4SNetFree(Result);
}
return hnd;
}
/* Read a block. */
void
get_block(block_t n, void *buf)
{
ssize_t k;
/* First access returns a zero block */
if (read_and_set(n) == 0) {
memcpy(buf, zero, block_size);
return;
}
if (lseek64(fd, mul64u(n, block_size), SEEK_SET, NULL) == (off_t)(-1))
pexit("get_block couldn't seek");
k = read(fd, buf, block_size);
if (k != block_size)
pexit("get_block couldn't read block #%u", (unsigned)n);
}
int
main() {
logInfo("Parent", "creating child");
switch (fork()) {
case -1:
pexit("fork");
break;
case 0:
/* child code: give a chance for parent finish itself (very basic means of
* process synchronization */
logInfo("Child", "child created, waiting parent to finish");
sleep(5);
char msg[BUFSIZ];
snprintf(msg, BUFSIZ, "parent PID = %ld", (long) getppid());
logInfo("Child", msg);
break;
default:
/* parent: nothing to do but finish */
logInfo("Parent", "finishing up");
exit(EXIT_SUCCESS);
}
/* only child should get to this point */
exit(EXIT_SUCCESS);
}
void toggle_lock_cursor(tile* t) {
u_int r;
u_int new_lock = cursor_lock;
if (NULL == t)
pexit(EFAULT, "lock_cursor: got NULL tile");
r = get_robot_at(t);
switch(cursor_lock) {
case CURSOR_LOCK_NONE:
if (ROBOT_NONE != r) {
new_lock = CURSOR_LOCK_ROBOT;
cursor_lock_robot = r;
} else {
printf("nothing to lock onto\n");
}
break;
case CURSOR_LOCK_ROBOT:
if ((ROBOT_NONE == r) ||
(cursor_lock_robot == r)) {
// place_robot(cursor_lock_robot, t);
new_lock = CURSOR_LOCK_NONE;
cursor_lock_robot = ROBOT_NONE;
compile_robots();
} else {
printf("can't place a robot over another robot\n");
}
break;
}
cursor_lock = new_lock;
}
uintptr
sysexits(va_list list)
{
char *status;
char *inval = "invalid exit string";
char buf[ERRMAX];
status = va_arg(list, char*);
if(status != nil){
if(waserror())
status = inval;
else{
validaddr((uintptr)status, 1, 0);
if(vmemchr(status, 0, ERRMAX) == 0){
memmove(buf, status, ERRMAX);
buf[ERRMAX-1] = 0;
status = buf;
}
poperror();
}
}
pexit(status, 1);
return 0; /* not reached */
}
int
main(int argc, char *argv[]) {
int fd, newfd;
int numWritten;
Bool useDup2;
if (argc < 2 || argc > 3) {
helpAndLeave(argv[0], EXIT_FAILURE);
}
fd = (int) atol(argv[1]);
newfd = -1; /* if not using dup2, this variable will not be used */
if (argc == 3) {
useDup2 = TRUE;
newfd = (int) atol(argv[2]);
} else {
useDup2 = FALSE;
}
newfd = duplicate(fd, newfd, useDup2);
numWritten = write(newfd, writeStr, sizeof(writeStr));
if (numWritten == -1) {
pexit("write");
}
safeClose(fd);
safeClose(newfd);
printf("Done. Written %d bytes to the new file descriptor #%d\n", numWritten, newfd);
return EXIT_SUCCESS;
}
static void
vt6102lproc(void* arg)
{
Ctlr *ctlr;
Ether *edev;
MiiPhy *phy;
edev = arg;
ctlr = edev->ctlr;
for(;;){
if(ctlr->mii == nil || ctlr->mii->curphy == nil)
break;
if(miistatus(ctlr->mii) < 0)
goto enable;
phy = ctlr->mii->curphy;
ilock(&ctlr->clock);
if(phy->fd)
ctlr->cr |= Fdx;
else
ctlr->cr &= ~Fdx;
csr16w(ctlr, Cr, ctlr->cr);
iunlock(&ctlr->clock);
enable:
ctlr->lwakeup = 0;
vt6102imr(ctlr, Srci);
ctlr->lsleep++;
sleep(&ctlr->lrendez, vt6102wakeup, &ctlr->lwakeup);
}
pexit("vt6102lproc: done", 1);
}
static void
loopbackread(void *a)
{
Ipifc *ifc;
Block *bp;
LB *lb;
ifc = a;
lb = ifc->arg;
lb->readp = up; /* hide identity under a rock for unbind */
if(waserror()){
lb->readp = 0;
pexit("hangup", 1);
}
for(;;){
bp = qbread(lb->q, Maxtu);
if(bp == nil)
continue;
ifc->in++;
if(!canrlock(ifc)){
freeb(bp);
continue;
}
if(waserror()){
runlock(ifc);
nexterror();
}
if(ifc->lifc == nil)
freeb(bp);
else
ipiput4(lb->f, ifc, bp);
runlock(ifc);
poperror();
}
}
/* Insert one bit into the bitmap */
void
insert_bit(block_t map, bit_t bit)
{
int boff, w, s;
unsigned int bits_per_block;
block_t map_block;
bitchunk_t *buf;
buf = alloc_block();
bits_per_block = FS_BITS_PER_BLOCK(block_size);
map_block = map + bit / bits_per_block;
if (map_block >= inode_offset)
pexit("insertbit invades inodes area - this cannot happen");
boff = bit % bits_per_block;
assert(boff >=0);
assert(boff < FS_BITS_PER_BLOCK(block_size));
get_block(map_block, buf);
w = boff / FS_BITCHUNK_BITS;
s = boff % FS_BITCHUNK_BITS;
buf[w] |= (1 << s);
put_block(map_block, buf);
free(buf);
}
/* Increment the file-size in inode n */
void
incr_size(ino_t n, size_t count)
{
block_t b;
int off;
b = ((n - 1) / inodes_per_block) + inode_offset;
off = (n - 1) % inodes_per_block;
{
struct inode *inodes;
assert(inodes_per_block * sizeof(*inodes) == block_size);
if(!(inodes = alloc_block()))
err(1, "couldn't allocate a block of inodes");
get_block(b, inodes);
/* Check overflow; avoid compiler spurious warnings */
if (inodes[off].i_size+(int)count < inodes[off].i_size ||
inodes[off].i_size > MAX_MAX_SIZE-(int)count)
pexit("File has become too big to be handled by MFS");
inodes[off].i_size += count;
put_block(b, inodes);
free(inodes);
}
}
void * mem_alloc_align_func(size_t size,
size_t align
#if defined(MEMDBG_ON)
,
char * file,
int line
#endif
)
{
void * ptr = NULL;
#if defined(MEMDBG_ON)
ptr = (char *) MEMDBG_alloc_align(size, align, file, line);
#elif HAVE_POSIX_MEMALIGN
if (posix_memalign(&ptr, align, size)) pexit("posix_memalign");
#elif HAVE_ALIGNED_ALLOC
/* According to the Linux man page, "size should be a multiple of
alignment", whatever they mean with "should"... This does not
make any sense whatsoever but we round it up to comply. */
size = ((size + (align - 1)) / align) * align;
if (!(ptr = aligned_alloc(align, size))) pexit("aligned_alloc");
#elif HAVE_MEMALIGN
/* Let's just pray this implementation can actually free it */
#if defined(__sparc__) || defined(__sparc) || defined(sparc) \
|| defined(__sparcv9)
if (!(ptr = memalign(align, size)))
#else
if (!(ptr = memalign(&ptr, align, size)))
#endif
perror("memalign");
#elif HAVE___MINGW_ALIGNED_MALLOC
if (!(ptr = __mingw_aligned_malloc(size, align)))
perror("__mingw_aligned_malloc");
#elif HAVE__ALIGNED_MALLOC
if (!(ptr = _aligned_malloc(size, align))) perror("aligned_malloc");
#elif AC_BUILT
#error No suitable aligned alloc found, please report to john-dev mailing list (state your OS details).
/* we need an aligned alloc function for legacy builds */
#elif _ISOC11_SOURCE
size = ((size + (align - 1)) / align) * align;
if (!(ptr = aligned_alloc(align, size))) perror("aligned_alloc");
#else
if (posix_memalign(&ptr, align, size)) perror("posix_memalign");
#endif
return ptr;
}
static void
w_timer(void* arg)
{
Ether* ether = (Ether*) arg;
Ctlr* ctlr = (Ctlr*)ether->ctlr;
ctlr->timerproc = up;
for(;;) {
tsleep(&up->sleep, return0, 0, MSperTick);
ctlr = (Ctlr*)ether->ctlr;
if(ctlr == 0)
break;
if((ctlr->state & (Attached|Power)) != (Attached|Power))
continue;
ctlr->ticks++;
ilock(ctlr);
// Seems that the card gets frames BUT does
// not send the interrupt; this is a problem because
// I suspect it runs out of receive buffers and
// stops receiving until a transmit watchdog
// reenables the card.
// The problem is serious because it leads to
// poor rtts.
// This can be seen clearly by commenting out
// the next if and doing a ping: it will stop
// receiving (although the icmp replies are being
// issued from the remote) after a few seconds.
// Of course this `bug' could be because I'm reading
// the card frames in the wrong way; due to the
// lack of documentation I cannot know.
if(csr_ins(ctlr, WR_EvSts)&WEvs) {
ctlr->tickintr++;
w_intr(ether);
}
if((ctlr->ticks % 10) == 0) {
if(ctlr->txtmout && --ctlr->txtmout == 0) {
ctlr->nwatchdogs++;
w_txdone(ctlr, WTxErrEv);
if(w_enable(ether)) {
DEBUG("wavelan: wdog enable failed\n");
}
w_txstart(ether);
}
if((ctlr->ticks % 120) == 0)
if(ctlr->txbusy == 0)
w_cmd(ctlr, WCmdEnquire, WTyp_Stats);
if(ctlr->scanticks > 0)
if((ctlr->ticks % ctlr->scanticks) == 0)
if(ctlr->txbusy == 0)
w_cmd(ctlr, WCmdEnquire, WTyp_Scan);
}
iunlock(ctlr);
}
pexit("terminated", 0);
}
static void
linkproc(void)
{
Proc *up = externup();
spllo();
up->kpfun(up->kparg);
pexit("kproc dying", 0);
}
static void *
thread_function(void *arg) {
int tid = *((int *) arg);
if (one_time_init(&control, init_function) == -1)
pexit("one_time_init");
printf("%d: value of shared variable: %d\n", tid, to_be_initialized);
return NULL;
}
static void log_file_flush(struct log_file *f)
{
int count;
if (f->fd < 0) return;
count = f->ptr - f->buffer;
if (count <= 0) return;
#if defined(LOCK_EX) && OS_FLOCK
if (flock(f->fd, LOCK_EX)) pexit("flock");
#endif
if (write_loop(f->fd, f->buffer, count) < 0) pexit("write");
f->ptr = f->buffer;
#if defined(LOCK_EX) && OS_FLOCK
if (flock(f->fd, LOCK_UN)) pexit("flock");
#endif
}
static void log_file_fsync(struct log_file *f)
{
if (f->fd < 0) return;
log_file_flush(f);
#if !defined(__CYGWIN32__) && !defined(__MINGW32__) && !defined(_MSC_VER)
if (fsync(f->fd)) pexit("fsync");
#endif
}
static void log_file_fsync(struct log_file *f)
{
if (f->fd < 0) return;
log_file_flush(f);
#if HAVE_WINDOWS_H==0
if (fsync(f->fd)) pexit("fsync");
#endif
}
static void log_file_fsync(struct log_file *f)
{
if (f->fd < 0) return;
log_file_flush(f);
#ifndef __CYGWIN32__
if (fsync(f->fd)) pexit("fsync");
#endif
}
void * decompose (void *hnd, c4snet_data_t *InFile, c4snet_data_t *OutFile,
int a_size, int bs)
{
int p, i, j;
double *array;
tile *atiles, *ltiles;
char *infile;
if (bs <= 0) {
fprintf (stderr, "A block size must be greater than 0\n");
exit (1);
}
if (a_size <= 0) {
fprintf (stderr, "The dimension of matrix must be greater than 0\n");
exit (1);
}
if (a_size % bs) {
fprintf(stderr,
"matrix size %d is not a multiple of the block size %d\n",
a_size, bs);
exit(1);
}
p = a_size / bs;
/* Get the input filename as a string. */
infile = chars_to_string(InFile);
outfile = chars_to_string(OutFile);
C4SNetFree(InFile);
C4SNetFree(OutFile);
array = SNetMemAlloc(a_size * a_size * sizeof(double));
read_matrix(a_size, array, infile);
free(infile);
if (clock_gettime(CLOCK_REALTIME, &begin)) {
pexit("clock_gettime");
}
atiles = (tile *) malloc (sizeof (tile) * p * p);
ltiles = (tile *) malloc (sizeof (tile) * p * p);
memset (atiles, 0, sizeof (tile) * p * p);
memset (ltiles, 0, sizeof (tile) * p * p);
for (i = 0; i < p; i++)
for (j = 0; j <= i; j++) {
atiles[j * p + i] = (double *) malloc (sizeof (double) * bs * bs);
ltiles[j * p + i] = (double *) malloc (sizeof (double) * bs * bs);
int ai, aj, ti, tj;
for (ai = i * bs, ti = 0; ti < bs; ai++, ti++)
for (aj = j * bs, tj = 0; tj < bs; aj++, tj++)
atiles[j * p + i][tj * bs + ti] = array[aj * a_size + ai];
}
C4SNetOut (hnd, 1, C4SNetCreate (CTYPE_char, sizeof (void *), &atiles),
C4SNetCreate (CTYPE_char, sizeof (void *), <iles), bs, p, 0);
free(array);
return hnd;
}
static void
linkproc(void)
{
spllo();
if (waserror())
print("error() underflow: %r\n");
else (*up->kpfun)(up->arg);
pexit("end proc", 1);
}
int ChangeMacAddr()
{
struct ifreq ifr;
struct sockaddr_in *sin = (void *) &ifr.ifr_ifru.ifru_addr;
int s;
unsigned char ClientHwAddr[ETHER_ADDR_LEN];
memset(&ifr, 0, sizeof(ifr));
memcpy(ifr.ifr_name,"eth0\0",5);
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s < 0) {
pexit("stream socket");
}
ClientHwAddr[0] = 0x00;
ClientHwAddr[1] = 0x88;
ClientHwAddr[2] = 0x12;
ClientHwAddr[3] = 0x34;
ClientHwAddr[4] = 0x56;
ClientHwAddr[5] = 0x78;
memcpy(ifr.ifr_hwaddr.sa_data, ClientHwAddr, ETHER_ADDR_LEN);
if ( ioctl(s,SIOCSIFHWADDR,&ifr) )
{
printf("ioctl SIOCSIFHWADDR: %d\n",errno);
close(s);
pexit("ioctl SIOCGIFHWADDR");
}
printf("Set HW addr success\n");
if ( ioctl(s,SIOCGIFHWADDR,&ifr) )
{
printf("ioctl SIOCGIFHWADDR: %d\n",errno);
close(s);
pexit("ioctl SIOCGIFHWADDR");
}
if ( ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER )
{
printf("interface %s is not Ethernet %x\n",ifr.ifr_name,ifr.ifr_hwaddr.sa_family);
}
memcpy(ClientHwAddr,ifr.ifr_hwaddr.sa_data,ETHER_ADDR_LEN);
printf("%02x:%02x:%02x:%02x:%02x:%02x\n",ClientHwAddr[0],ClientHwAddr[1],ClientHwAddr[2],ClientHwAddr[3],ClientHwAddr[4],
ClientHwAddr[5]);
}
int
main() {
char *login;
if ((login = _getlogin()) == NULL)
pexit("_getlogin");
printf("%s\n", login);
exit(EXIT_SUCCESS);
}
static void
logInfo(const char *who, const char *message) {
char buf[BUFSIZ];
int size;
size = snprintf(buf, BUFSIZ, "[%s %ld] %s\n", who, (long) getpid(), message);
if (write(STDOUT_FILENO, buf, size) == -1) {
pexit("write");
}
}
static void rec_format_error(char *fn)
{
if (fn && errno && ferror(rec_file))
pexit("%s", fn);
else {
fprintf(stderr, "Incorrect crash recovery file: %s\n",
path_expand(rec_name));
error();
}
}
static void restore_line_number(void)
{
char line[LINE_BUFFER_SIZE];
if (skip_lines(rec_pos, line)) {
if (ferror(word_file))
pexit("fgets");
fprintf(stderr, "fgets: Unexpected EOF\n");
error();
}
}
copyfile()
{
extern int fout[];
register int c;
(void) close(1);
if (creat(firstname, 0644) != 1) {
perror(firstname);
pexit(ERRS);
}
if (lseek(fout[0], (off_t)0, 0) == -1)
perror("copyfile: lseek"), panic("copyfile");
while ((c = read(fout[0], &fout[3], 512)) > 0) {
if (write(1, &fout[3], c) != c) {
perror(firstname);
pexit(ERRS);
}
}
}
int
main() {
/* read and write pipes file descriptions, from the perspective of the parent process */
int writePfd[2], readPfd[2];
long childPid;
/* create read and write pipes */
if (pipe(writePfd) == -1)
pexit("pipe");
if (pipe(readPfd) == -1)
pexit("pipe");
childPid = fork();
switch (childPid) {
case -1:
pexit("fork");
case 0:
/* child process: closes the write end of the write pipe, and the read end of the read pipe. */
if (close(writePfd[1]) == -1)
pexit("close write end of write pipe - child");
if (close(readPfd[0]) == -1)
pexit("close read end of read pipe - child");
childLoop(writePfd[0], readPfd[1]);
/* child loop is finished: this means that the parent process received EOF,
* and the write end of writePfd was closed */
_exit(EXIT_SUCCESS);
default:
/* parent process: closes the read end of the write pipe, and the write end of the read pipe */
if (close(writePfd[0]) == -1)
pexit("close read end of write pipe - parent");
if (close(readPfd[1]) == -1)
pexit("close write end of read pipe - parent");
parentLoop(readPfd[0], writePfd[1]);
/* EOF received. Close write end of writePfd */
if (close(writePfd[1]) == -1)
pexit("close write end of write pipe - parent");
printf("\n");
}
/* parent: wait for the child to die and terminate */
wait(NULL);
exit(EXIT_SUCCESS);
}
static void log_file_done(struct log_file *f)
{
if (f->fd < 0) return;
log_file_fsync(f);
if (close(f->fd)) pexit("close");
f->fd = -1;
MEM_FREE(f->buffer);
}
