static void test_invalid_mem(void) { unsigned long *p; tst_resm(TINFO, "test_invalid_mem -1"); TEST(ltp_syscall(__NR_migrate_pages, 0, sane_max_node, -1, -1)); check_ret(-1); check_errno(EFAULT); tst_resm(TINFO, "test_invalid_mem invalid prot"); p = mmap(NULL, getpagesize(), PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); if (p == MAP_FAILED) tst_brkm(TBROK | TERRNO, cleanup, "mmap"); TEST(ltp_syscall(__NR_migrate_pages, 0, sane_max_node, p, p)); check_ret(-1); check_errno(EFAULT); if (munmap(p, getpagesize()) < 0) tst_brkm(TBROK | TERRNO, cleanup, "munmap"); tst_resm(TINFO, "test_invalid_mem unmmaped"); TEST(ltp_syscall(__NR_migrate_pages, 0, sane_max_node, p, p)); check_ret(-1); check_errno(EFAULT); }
int display_current_settings (int DEV) { int tvmode=-1, aspect=-1, audio=-1, spu=-1; if((ioctl(DEV, EM8300_IOCTL_GET_VIDEOMODE, &tvmode)) == -1) check_errno("Cannot read tvmode"); if((ioctl(DEV, EM8300_IOCTL_GET_ASPECTRATIO, &aspect)) == -1) check_errno("Cannot read aspect"); if((ioctl(DEV, EM8300_IOCTL_GET_AUDIOMODE, &audio)) == -1) check_errno("Cannot read audio"); if((ioctl(DEV, EM8300_IOCTL_GET_SPUMODE, &spu)) == -1) check_errno("Cannot read spu"); printf("Video\tAspect\tAudio\tSpu\t\n"); switch(tvmode) { case EM8300_VIDEOMODE_PAL: printf("PAL\t"); break; case EM8300_VIDEOMODE_PAL60: printf("PAL60\t"); break; case EM8300_VIDEOMODE_NTSC: printf("NTSC\t"); break; default: printf("???\t"); } switch(aspect) { case EM8300_ASPECTRATIO_4_3: printf("4:3\t"); break; case EM8300_ASPECTRATIO_16_9: printf("16:9\t"); break; default: printf("???\t"); } switch(audio) { case EM8300_AUDIOMODE_ANALOG: printf("ANALOG\t"); break; case EM8300_AUDIOMODE_DIGITALPCM: printf("PCM\t"); break; case EM8300_AUDIOMODE_DIGITALAC3: printf("AC3\t"); break; default: printf("???\t"); } switch(spu) { case EM8300_SPUMODE_OFF: printf("OFF\n"); break; case EM8300_SPUMODE_ON: printf("ON\n"); break; default: printf("???\n"); } return 0; }
enum ach_status ach_open( ach_channel_t *chan, const char *channel_name, ach_attr_t *attr ) { ach_header_t * shm; size_t len; int fd = -1; if( attr ) memcpy( &chan->attr, attr, sizeof(chan->attr) ); else memset( &chan->attr, 0, sizeof(chan->attr) ); if( attr && attr->map_anon ) { shm = attr->shm; len = sizeof(ach_header_t) + sizeof(ach_index_t)*shm->index_cnt + shm->data_size; }else { if( ! channel_name_ok( channel_name ) ) return ACH_INVALID_NAME; /* open shm */ if( ! channel_name_ok( channel_name ) ) return ACH_INVALID_NAME; if( (fd = fd_for_channel_name( channel_name, 0 )) < 0 ) { return check_errno(); } if( (shm = (ach_header_t*) mmap (NULL, sizeof(ach_header_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0ul) ) == MAP_FAILED ) return ACH_FAILED_SYSCALL; if( ACH_SHM_MAGIC_NUM != shm->magic ) return ACH_BAD_SHM_FILE; /* calculate mmaping size */ len = sizeof(ach_header_t) + sizeof(ach_index_t)*shm->index_cnt + shm->data_size; /* remap */ if( -1 == munmap( shm, sizeof(ach_header_t) ) ) return check_errno(); if( (shm = (ach_header_t*) mmap( NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0ul) ) == MAP_FAILED ) return check_errno(); } /* Check guard bytes */ { enum ach_status r = check_guards(shm); if( ACH_OK != r ) return r; } /* initialize struct */ chan->fd = fd; chan->len = len; chan->shm = shm; chan->seq_num = 0; chan->next_index = 1; chan->cancel = 0; return ACH_OK; }
bool client_t::read_complete(int socket) { // NOTE: not bothering to think about htonl and friends here because // I demand all clients use little-endian byte ordering. assert(bytes_read < sizeof(log_packet)); uint8_t *pb = reinterpret_cast<uint8_t*>(&log_packet); int ret = 0; if (bytes_read < payload_length_known_offset) { errno = 0; ret = ::read(socket, pb + bytes_read, payload_length_known_offset - bytes_read); if (ret == 0) { bytes_read = 0; return true; } if (ret == -1) { if (errno == EAGAIN) { assert(0); return false; } check_errno(); bytes_read = 0; return true; } bytes_read += ret; } if (bytes_read >= payload_length_known_offset) { const int total_packet_size = sizeof(log_packet) - sizeof(log_packet.payload) + log_packet.payload_length; ret = ::read(socket, pb + bytes_read, total_packet_size - bytes_read); if (ret == 0) { bytes_read = 0; return true; } if (ret == -1) { if (errno == EAGAIN) return false; check_errno(); return true; } bytes_read += ret; } return complete(); }
static void test_invalid_masksize(void) { tst_resm(TINFO, "test_invalid_masksize"); TEST(ltp_syscall(__NR_migrate_pages, 0, -1, sane_old_nodes, sane_new_nodes)); check_ret(-1); check_errno(EINVAL); }
static void test_invalid_pid(void) { pid_t invalid_pid = -1; tst_resm(TINFO, "test_invalid_pid -1"); TEST(ltp_syscall(__NR_migrate_pages, invalid_pid, sane_max_node, sane_old_nodes, sane_new_nodes)); check_ret(-1); check_errno(ESRCH); tst_resm(TINFO, "test_invalid_pid unused pid"); invalid_pid = tst_get_unused_pid(cleanup); TEST(ltp_syscall(__NR_migrate_pages, invalid_pid, sane_max_node, sane_old_nodes, sane_new_nodes)); check_ret(-1); check_errno(ESRCH); }
void set_non_blocking(int socket) { assert(socket != -1); if (fcntl(socket, F_SETFL, fcntl(socket, F_GETFL) | O_NONBLOCK) < 0) { check_errno(); log(log_error, "unable to set non-blocking mode on socket %d\n", socket); } }
static void test_invalid_fd(void) { int fd[2]; tst_resm(TINFO, "test_invalid_fd pipe"); if (pipe(fd) < 0) tst_resm(TBROK | TERRNO, "Failed to create pipe"); TEST(ltp_syscall(__NR_readahead, fd[0], 0, getpagesize())); check_ret(-1); check_errno(EINVAL); close(fd[0]); close(fd[1]); tst_resm(TINFO, "test_invalid_fd socket"); fd[0] = socket(AF_INET, SOCK_STREAM, 0); if (fd[0] < 0) tst_resm(TBROK | TERRNO, "Failed to create socket"); TEST(ltp_syscall(__NR_readahead, fd[0], 0, getpagesize())); check_ret(-1); check_errno(EINVAL); close(fd[0]); }
/*===========================================================================*/ FILE *open_input_using_big_buffer(char *filename) { off_t bytes; stat_t statinf; int fnum; FILE *ans; /*-------------------------------------------------------*/ /*------------------------------------ open & get file size */ #ifdef BUGGY fprintf(stderr,"open file=\"%s\"\n",filename); #endif ans=fopen_read_only(filename); if (ans==((FILE *) NULL)) check_errno(E_CANNOTOPEN,filename); fnum = fileno(ans); fstat(fnum,&statinf); bytes=statinf.st_size; #ifdef BUGGY if (bytes<80){ fprintf(stderr,"**** error, statinf.st_size=0x%lx\n",(unsigned long) statinf.st_size); bytes=(off_t) 0x4000;} #endif #ifdef MSDOS if (bytes>65530L) bytes=65530L; #endif fclose(ans); /*------------------------------------ re-open and allocate buffer */ ans=fopen_read_only(filename); if (ans==((FILE *) NULL)) check_errno(E_CANNOTOPEN,filename); big_input_file_buffer=(unsigned char *) g_malloc(bytes); if (big_input_file_buffer==((unsigned char *) NULL)) big_input_file_buffer=(unsigned char *) g_malloc(bytes=((off_t) 0x4000)); /* 16K */ /*------------------------------------ use big buffer instead of system */ if (big_input_file_buffer!=((unsigned char *) NULL)){ setvbuf(ans,(char *) big_input_file_buffer,_IOFBF,(size_t) bytes);} /*-------------------------------------------------------*/ return(ans); }
void run_server(const char* IP_ADDR, int PORT_NUMBER, int MAX_BACKLOG) { int socket_d = socket(AF_INET, SOCK_STREAM, 0); if (socket_d == -1) { check_errno("socket"); } struct sockaddr_in local_addr; local_addr.sin_family = AF_INET; local_addr.sin_port = htons(PORT_NUMBER); local_addr.sin_addr.s_addr = inet_addr(IP_ADDR); if (!bind(socket_d, (const struct sockaddr*) &local_addr, sizeof(struct sockaddr_in))) { check_errno("bind"); } while (!listen(socket_d, MAX_BACKLOG)) { struct sockaddr_in remote_addr; socklen_t addr_len = sizeof(struct sockaddr_in); int rs = accept(socket_d, (struct sockaddr*) &remote_addr, &addr_len); if (rs == -1) { check_errno("accept"); } if (fork() == 0) { close(socket_d); fprintf(stderr, "Connected: %s:%d\n", inet_ntoa(remote_addr.sin_addr), (int) ntohs(remote_addr.sin_port)); transfer_data(rs); finalaze_socket(rs); fprintf(stderr, "Closed: %s:%d\n", inet_ntoa(remote_addr.sin_addr), (int) ntohs(remote_addr.sin_port)); exit(0); } close(rs); } close(socket_d); check_errno("listen"); }
static void test_bad_fd(void) { char tempname[PATH_MAX] = "readahead01_XXXXXX"; int fd; tst_resm(TINFO, "test_bad_fd -1"); TEST(ltp_syscall(__NR_readahead, -1, 0, getpagesize())); check_ret(-1); check_errno(EBADF); tst_resm(TINFO, "test_bad_fd O_WRONLY"); fd = mkstemp(tempname); if (fd == -1) tst_resm(TBROK | TERRNO, "mkstemp failed"); close(fd); fd = open(tempname, O_WRONLY); if (fd == -1) tst_resm(TBROK | TERRNO, "Failed to open testfile"); TEST(ltp_syscall(__NR_readahead, fd, 0, getpagesize())); check_ret(-1); check_errno(EBADF); close(fd); unlink(tempname); }
int32_t get_canonical_name(const std::string& documentRoot, const T& s, T& fname) { char resolved_path[PATH_MAX]; fname.reserve(documentRoot.length()+1+s.length()); fname.append(documentRoot.data(), documentRoot.length()); fname.append(1, '/'); fname.append(s); char* nname = realpath(fname.c_str(), resolved_path); if (nname) { fname.assign(nname); return 0; } int32_t rc = check_errno(); std::cerr << "fail to realpath [" << s << "]" << std::endl; return rc; }
static void test_invalid_nodes(void) { int *nodes; int num_nodes, ret, i; int invalid_node = 0; unsigned long *old_nodes, *new_nodes; tst_resm(TINFO, "test_invalid_nodes"); ret = get_allowed_nodes_arr(NH_MEMS, &num_nodes, &nodes); if (ret < 0) tst_brkm(TBROK | TERRNO, cleanup, "get_allowed_nodes_arr: %d", ret); /* get first node which is not in nodes */ for (i = 0; i < num_nodes; i++, invalid_node++) if (invalid_node != nodes[i]) break; if (invalid_node < sane_max_node) { old_nodes = SAFE_MALLOC(NULL, sane_nodemask_size); new_nodes = SAFE_MALLOC(NULL, sane_nodemask_size); memcpy(old_nodes, sane_old_nodes, sane_nodemask_size); memset(new_nodes, 0, sane_nodemask_size); set_bit(new_nodes, invalid_node, 1); TEST(ltp_syscall(__NR_migrate_pages, 0, sane_max_node, old_nodes, new_nodes)); check_ret(-1); check_errno(EINVAL); free(old_nodes); free(new_nodes); } else { tst_resm(TCONF, "All possible nodes are present"); } free(nodes); }
static void test_invalid_perm(void) { char nobody_uid[] = "nobody"; struct passwd *ltpuser; int status; pid_t child_pid; pid_t parent_pid; int ret = 0; tst_resm(TINFO, "test_invalid_perm"); parent_pid = getpid(); fflush(stdout); child_pid = fork(); switch (child_pid) { case -1: tst_brkm(TBROK | TERRNO, cleanup, "fork"); break; case 0: ltpuser = getpwnam(nobody_uid); if (ltpuser == NULL) tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed"); if (setuid(ltpuser->pw_uid) == -1) tst_brkm(TBROK | TERRNO, NULL, "setuid(%u) failed", ltpuser->pw_uid); TEST(ltp_syscall(__NR_migrate_pages, parent_pid, sane_max_node, sane_old_nodes, sane_new_nodes)); ret |= check_ret(-1); ret |= check_errno(EPERM); exit(ret); default: if (waitpid(child_pid, &status, 0) == -1) tst_brkm(TBROK | TERRNO, cleanup, "waitpid"); if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) tst_resm(TFAIL, "child returns %d", status); } }
static int testsig(void) { enum ach_status r; /* Fork 0 */ pid_t pid_p = fork(); check_errno( "Fork 0", pid_p ); /* GP: wait */ if( pid_p ) { return testsig_gp(pid_p); } /* Parent */ /* Create Kernel Channel */ { ach_create_attr_t attr; ach_create_attr_init(&attr); attr.map = ACH_MAP_KERNEL; r = ach_unlink(OPT_CHAN); if( ! ach_status_match(r, ACH_MASK_OK | ACH_MASK_ENOENT) ) { fail_ach( "unlink before create", r ); } r = ach_unlink(OPT_CHAN); if( ACH_ENOENT != r ) fail_ach( "unlink noent", r ); check_ach( "ach_create", ach_create( OPT_CHAN, opt_msg_cnt, opt_msg_size, &attr ) ); } /* Open Kernel Channel */ struct ach_channel chan; { for(;;) { usleep(1000); /* Race against udev */ r = ach_open( &chan, OPT_CHAN, NULL ); if( ACH_EACCES == r ) continue; else if (ACH_OK == r) break; else fail_ach("ach_open", r); } } /* Install Parent sighandler */ sighandler_install(); /* fork 1 */ pid_t pid_c = fork(); check_errno( "fork 1", pid_c ); if( pid_c ) { /* Parent: */ for(;;) { usleep(10000); /* Racy... */ check_errno( "kill child", kill( pid_c, SIGUSR1) ); usleep(10000); int i = 42; check_ach( "put to child", ach_put( &chan, &i, sizeof(i) ) ); int status; pid_t wp = waitpid( pid_c, &status, WNOHANG ); if( wp ) { if( wp != pid_c ) { fail_errno("Wait 1"); } else if( WIFEXITED(status) && (0 == WEXITSTATUS(status)) ) { exit(EXIT_SUCCESS); } else { fprintf(stderr, "Child 1 failed\n"); exit(EXIT_FAILURE); } } } } else { /* child */ sig_atomic_t s0, s1; int i; do { size_t frame_size; s0 = count_sigusr1; r = ach_get(&chan, &i, sizeof(i), &frame_size, NULL, ACH_O_WAIT ); s1 = count_sigusr1; check_ach("child sig get", r); } while( s1 == s0 || s1 < 10 ); /* This is racy... */ printf("done: %s, %d,%d,%d\n", ach_result_to_string(r), s0, s1, i); exit(EXIT_SUCCESS); } return 0; }
int main(void) { decimal *dec, *din; char buf[BUFSIZE]; long l; int i, j, k, q, r, count = 0; double dbl; decimal **decarr = (decimal **) calloc(1, sizeof(decimal)); ECPGdebug(1, stderr); for (i = 0; decs[i]; i++) { dec = PGTYPESdecimal_new(); r = deccvasc(decs[i], strlen(decs[i]), dec); if (r) { check_errno(); printf("dec[%d,0]: r: %d\n", i, r); PGTYPESdecimal_free(dec); continue; } decarr = realloc(decarr, sizeof(decimal *) * (count + 1)); decarr[count++] = dec; r = dectoasc(dec, buf, BUFSIZE-1, -1); if (r < 0) check_errno(); printf("dec[%d,1]: r: %d, %s\n", i, r, buf); r = dectoasc(dec, buf, BUFSIZE-1, 0); if (r < 0) check_errno(); printf("dec[%d,2]: r: %d, %s\n", i, r, buf); r = dectoasc(dec, buf, BUFSIZE-1, 1); if (r < 0) check_errno(); printf("dec[%d,3]: r: %d, %s\n", i, r, buf); r = dectoasc(dec, buf, BUFSIZE-1, 2); if (r < 0) check_errno(); printf("dec[%d,4]: r: %d, %s\n", i, r, buf); din = PGTYPESdecimal_new(); r = dectoasc(din, buf, BUFSIZE-1, 2); if (r < 0) check_errno(); printf("dec[%d,5]: r: %d, %s\n", i, r, buf); r = dectolong(dec, &l); if (r) check_errno(); printf("dec[%d,6]: %ld (r: %d)\n", i, r?0L:l, r); if (r == 0) { r = deccvlong(l, din); if (r) check_errno(); dectoasc(din, buf, BUFSIZE-1, 2); q = deccmp(dec, din); printf("dec[%d,7]: %s (r: %d - cmp: %d)\n", i, buf, r, q); } r = dectoint(dec, &k); if (r) check_errno(); printf("dec[%d,8]: %d (r: %d)\n", i, r?0:k, r); if (r == 0) { r = deccvint(k, din); if (r) check_errno(); dectoasc(din, buf, BUFSIZE-1, 2); q = deccmp(dec, din); printf("dec[%d,9]: %s (r: %d - cmp: %d)\n", i, buf, r, q); } if (i != 6) { /* underflow does not work reliable on several archs, so not testing it here */ /* this is a libc problem since we only call strtod() */ r = dectodbl(dec, &dbl); if (r) check_errno(); printf("dec[%d,10]: %g (r: %d)\n", i, r?0.0:dbl, r); } PGTYPESdecimal_free(din); printf("\n"); } /* add a NULL value */ dec = PGTYPESdecimal_new(); decarr = realloc(decarr, sizeof(decimal *) * (count + 1)); decarr[count++] = dec; rsetnull(CDECIMALTYPE, (char *) decarr[count-1]); printf("dec[%d]: %sNULL\n", count-1, risnull(CDECIMALTYPE, (char *) decarr[count-1]) ? "" : "NOT "); printf("dec[0]: %sNULL\n", risnull(CDECIMALTYPE, (char *) decarr[0]) ? "" : "NOT "); r = dectoasc(decarr[3], buf, -1, -1); check_errno(); printf("dectoasc with len == -1: r: %d\n", r); r = dectoasc(decarr[3], buf, 0, -1); check_errno(); printf("dectoasc with len == 0: r: %d\n", r); for (i = 0; i < count; i++) { for (j = 0; j < count; j++) { decimal a, s, m, d; int c; c = deccmp(decarr[i], decarr[j]); printf("dec[c,%d,%d]: %d\n", i, j, c); r = decadd(decarr[i], decarr[j], &a); if (r) { check_errno(); printf("r: %d\n", r); } else { dectoasc(&a, buf, BUFSIZE-1, -1); printf("dec[a,%d,%d]: %s\n", i, j, buf); } r = decsub(decarr[i], decarr[j], &s); if (r) { check_errno(); printf("r: %d\n", r); } else { dectoasc(&s, buf, BUFSIZE-1, -1); printf("dec[s,%d,%d]: %s\n", i, j, buf); } r = decmul(decarr[i], decarr[j], &m); if (r) { check_errno(); printf("r: %d\n", r); } else { dectoasc(&m, buf, BUFSIZE-1, -1); printf("dec[m,%d,%d]: %s\n", i, j, buf); } r = decdiv(decarr[i], decarr[j], &d); if (r) { check_errno(); printf("r: %d\n", r); } else { dectoasc(&d, buf, BUFSIZE-1, -1); printf("dec[d,%d,%d]: %s\n", i, j, buf); } } } for (i = 0; i < count; i++) { dectoasc(decarr[i], buf, BUFSIZE-1, -1); printf("%d: %s\n", i, buf); PGTYPESdecimal_free(decarr[i]); } free(decarr); return 0; }
int main(int argc, char * argv[]) { int UCODE; /* file descriptor for ucode file */ int DEV; /* file descriptor for em8300 device*/ struct stat s; em8300_microcode_t em8300_microcode; int opened_one,i,optindex; char * opt; char ucode_file[200]; // bad hardcoded value ;-) /* Vars to hold desired setings - init to -1 so we can see which were requested to be set explicitly by the user and which should be left alone */ int tvmode=-1, aspect=-1, audio=-1, spu=-1, upload=0, display_only=0; char * devs[] = {"/dev/em8300-0","/dev/em8300-1","/dev/em8300-2","/dev/em8300-3"}; int number_of_devs=4; /* Populate with default location - user can override below. */ sprintf(ucode_file,FIRMWARE_DIR "/em8300.bin"); /* Read microcode file */ if (argc == 1) { /* behave as em8300init with no arguments */ /* just upload the microcode from the default location and exit */ upload=1; } else { /* parse the command line arguments here */ optindex = 1; while (optindex < argc) { opt = argv[optindex++]; if (opt[0] == '-' && opt[1] != '\0') { switch(opt[1]) { case 'p': if(opt[2]=='6') tvmode = EM8300_VIDEOMODE_PAL60; else tvmode = EM8300_VIDEOMODE_PAL; break; case 'n': tvmode = EM8300_VIDEOMODE_NTSC; break; case 'd': audio = EM8300_AUDIOMODE_DIGITALPCM; break; case 'a': audio = EM8300_AUDIOMODE_ANALOG; break; case '3': audio = EM8300_AUDIOMODE_DIGITALAC3; break; case 'w': aspect = EM8300_ASPECTRATIO_16_9; break; case 'o': aspect = EM8300_ASPECTRATIO_4_3; break; case 'S': spu = EM8300_SPUMODE_ON; break; case 's': spu = EM8300_SPUMODE_OFF; break; case 'q': display_only=1; break; case 'f': if(opt[2] == '\0') sprintf(ucode_file,"%s", argv[optindex++]); else sprintf(ucode_file,"%s",opt+2); upload=1; printf("Using microcode file %s\n",ucode_file); break; default: printf("Unknown option -%c \n\n",opt[1]); printf("Usage: em8300setup [-q]|[all other options]\n\nWhere options are one of the following (latter options will override previously\nspecified options for the same control):\n\n"); printf(" -p, -p6, -n\tSet display mode to pal, pal60, ntsc\n"); printf(" -a, -d, -3\tSet audio mode to analog, digitalpcm, digital ac3\n"); printf(" -o, -w\tSet aspect ratio to normal[4:3], widescreen[16:9]\n"); printf(" -S, -s\tSet spu mode On(S), Off(s)\n"); printf(" -f <filename>\tSpecify alternate location of microcode\n\t\t(Defaults to " FIRMWARE_DIR "/em8300.bin)\n"); printf(" -q\t\tQuery the current settings for all of the above and\n\t\texit without making any changes\n"); printf(" <none>\tPassing no option (except -f) causes the microcode\n\t\tto be loaded\n"); exit(1); } } } } if(upload && !display_only) { UCODE = open(ucode_file,O_RDONLY); if(UCODE <0) { printf("Unable to open microcode file \"%s\" for reading\n", ucode_file); exit(1); } if(fstat(UCODE, &s ) <0) { printf("Unable to fstat ucode file\n"); exit(1); } /* Alloc space for microcode and length structure */ em8300_microcode.ucode = (char*) malloc(s.st_size * sizeof(char) ); if (em8300_microcode.ucode == NULL) { printf("Unable to malloc() space for ucode\n"); exit(1); } if ((i=read(UCODE,em8300_microcode.ucode,s.st_size)) < 1) { printf("Unable to read data from microcode file\n"); } close(UCODE); } /* Open the device */ opened_one = 0; for (i=0 ; i<number_of_devs; i++) { if ((DEV=open(devs[i],O_RDWR))== -1) { if (!opened_one) { printf("Can't open %s\n",devs[i]); exit(1); } /* exit normally if at least one card has been initialized */ exit(0); } opened_one = 1; if(upload && !display_only) { /* Prepare ioctl */ em8300_microcode.ucode_size = s.st_size; if(ioctl(DEV, EM8300_IOCTL_INIT, &em8300_microcode) == -1) { printf("Microcode upload to %s failed: \n",devs[i]); close(DEV); exit(1); } printf("Microcode uploaded to %s\n",devs[i]); } if(display_only) { display_current_settings(DEV); close(DEV); exit(0); } if(tvmode!=-1) { printf("Setting tvmode = %i\n",tvmode); if(ioctl(DEV, EM8300_IOCTL_SET_VIDEOMODE, &tvmode) == -1) check_errno("Unable to set videomode"); } if(aspect!=-1) { printf("Setting aspect = %i\n",aspect); if(ioctl(DEV, EM8300_IOCTL_SET_ASPECTRATIO, &aspect) == -1) check_errno("Unable to set aspect ratio"); } if(audio!=-1) { printf("Setting audio = %i\n",audio); if(ioctl(DEV, EM8300_IOCTL_SET_AUDIOMODE, &audio) == -1) check_errno("Unable to set audio mode"); } if(spu!=-1) { printf("Setting spu = %i\n",spu); if(ioctl(DEV, EM8300_IOCTL_SET_SPUMODE, &spu) == -1) check_errno("Unable to set spu mode"); } printf("Current settings are:\n"); display_current_settings(DEV); close(DEV); } exit(0); }
enum ach_status ach_create( const char *channel_name, size_t frame_cnt, size_t frame_size, ach_create_attr_t *attr) { ach_header_t *shm; int fd; size_t len; /* fixme: truncate */ /* open shm */ { len = sizeof( ach_header_t) + frame_cnt*sizeof( ach_index_t ) + frame_cnt*frame_size + 3*sizeof(uint64_t); if( attr && attr->map_anon ) { /* anonymous (heap) */ shm = (ach_header_t *) malloc( len ); fd = -1; }else { int oflag = O_EXCL | O_CREAT; /* shm */ if( ! channel_name_ok( channel_name ) ) return ACH_INVALID_NAME; if( attr ) { if( attr->truncate ) oflag &= ~O_EXCL; } if( (fd = fd_for_channel_name( channel_name, oflag )) < 0 ) { return check_errno();; } { /* make file proper size */ /* FreeBSD needs ftruncate before mmap, Linux can do either order */ int r; int i = 0; do { r = ftruncate( fd, (off_t) len ); }while(-1 == r && EINTR == errno && i++ < ACH_INTR_RETRY); if( -1 == r ) { DEBUG_PERROR( "ftruncate"); return ACH_FAILED_SYSCALL; } } /* mmap */ if( (shm = (ach_header_t *)mmap( NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0) ) == MAP_FAILED ) { DEBUG_PERROR("mmap"); DEBUGF("mmap failed %s, len: %"PRIuPTR", fd: %d\n", strerror(errno), len, fd); return ACH_FAILED_SYSCALL; } } memset( shm, 0, len ); shm->len = len; } { /* initialize synchronization */ { /* initialize condition variables */ int r; pthread_condattr_t cond_attr; if( (r = pthread_condattr_init(&cond_attr)) ) { DEBUG_PERROR("pthread_condattr_init"); return ACH_FAILED_SYSCALL; } /* Process Shared */ if( ! (attr && attr->map_anon) ) { /* Set shared if not anonymous mapping Default will be private. */ if( (r = pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED)) ) { DEBUG_PERROR("pthread_condattr_setpshared"); return ACH_FAILED_SYSCALL; } } /* Clock */ if( attr && attr->set_clock ) { if( (r = pthread_condattr_setclock(&cond_attr, attr->clock)) ) { DEBUG_PERROR("pthread_condattr_setclock"); return ACH_FAILED_SYSCALL; } } else { if( (r = pthread_condattr_setclock(&cond_attr, ACH_DEFAULT_CLOCK)) ) { DEBUG_PERROR("pthread_condattr_setclock"); return ACH_FAILED_SYSCALL; } } if( (r = pthread_cond_init(&shm->sync.cond, &cond_attr)) ) { DEBUG_PERROR("pthread_cond_init"); return ACH_FAILED_SYSCALL; } if( (r = pthread_condattr_destroy(&cond_attr)) ) { DEBUG_PERROR("pthread_condattr_destroy"); return ACH_FAILED_SYSCALL; } } { /* initialize mutex */ int r; pthread_mutexattr_t mutex_attr; if( (r = pthread_mutexattr_init(&mutex_attr)) ) { DEBUG_PERROR("pthread_mutexattr_init"); return ACH_FAILED_SYSCALL; } if( (r = pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED)) ) { DEBUG_PERROR("pthread_mutexattr_setpshared"); return ACH_FAILED_SYSCALL; } /* Error Checking Mutex */ #ifdef PTHREAD_MUTEX_ERRORCHECK_NP if( (r = pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_ERRORCHECK_NP)) ) { DEBUG_PERROR("pthread_mutexattr_settype"); return ACH_FAILED_SYSCALL; } #endif /* Priority Inheritance Mutex */ #ifdef PTHREAD_PRIO_INHERIT if( (r = pthread_mutexattr_setprotocol(&mutex_attr, PTHREAD_PRIO_INHERIT)) ) { DEBUG_PERROR("pthread_mutexattr_setprotocol"); return ACH_FAILED_SYSCALL; } #endif if( (r = pthread_mutex_init(&shm->sync.mutex, &mutex_attr)) ) { DEBUG_PERROR("pthread_mutexattr_init"); return ACH_FAILED_SYSCALL; } if( (r = pthread_mutexattr_destroy(&mutex_attr)) ) { DEBUG_PERROR("pthread_mutexattr_destroy"); return ACH_FAILED_SYSCALL; } } } /* initialize name */ strncpy( shm->name, channel_name, ACH_CHAN_NAME_MAX ); /* initialize counts */ shm->index_cnt = frame_cnt; shm->index_head = 0; shm->index_free = frame_cnt; shm->data_head = 0; shm->data_free = frame_cnt * frame_size; shm->data_size = frame_cnt * frame_size; assert( sizeof( ach_header_t ) + shm->index_free * sizeof( ach_index_t ) + shm->data_free + 3*sizeof(uint64_t) == len ); *ACH_SHM_GUARD_HEADER(shm) = ACH_SHM_GUARD_HEADER_NUM; *ACH_SHM_GUARD_INDEX(shm) = ACH_SHM_GUARD_INDEX_NUM; *ACH_SHM_GUARD_DATA(shm) = ACH_SHM_GUARD_DATA_NUM; shm->magic = ACH_SHM_MAGIC_NUM; if( attr && attr->map_anon ) { attr->shm = shm; } else { int r; /* remove mapping */ r = munmap(shm, len); if( 0 != r ){ DEBUG_PERROR("munmap"); return ACH_FAILED_SYSCALL; } /* close file */ int i = 0; do { IFDEBUG( i ? DEBUGF("Retrying close()\n"):0 ); r = close(fd); }while( -1 == r && EINTR == errno && i++ < ACH_INTR_RETRY ); if( -1 == r ){ DEBUG_PERROR("close"); return ACH_FAILED_SYSCALL; } } return ACH_OK; }
int main(void) { char *text="error\n"; char *endptr; numeric *num, *nin; decimal *dec; long l; int i, j, k, q, r, count = 0; double d; numeric **numarr = (numeric **) calloc(1, sizeof(numeric)); ECPGdebug(1, stderr); for (i = 0; nums[i]; i++) { num = PGTYPESnumeric_from_asc(nums[i], &endptr); if (!num) check_errno(); if (endptr != NULL) { printf("endptr of %d is not NULL\n", i); if (*endptr != '\0') printf("*endptr of %d is not \\0\n", i); } if (!num) continue; numarr = realloc(numarr, sizeof(numeric *) * (count + 1)); numarr[count++] = num; text = PGTYPESnumeric_to_asc(num, -1); if (!text) check_errno(); printf("num[%d,1]: %s\n", i, text); free(text); text = PGTYPESnumeric_to_asc(num, 0); if (!text) check_errno(); printf("num[%d,2]: %s\n", i, text); free(text); text = PGTYPESnumeric_to_asc(num, 1); if (!text) check_errno(); printf("num[%d,3]: %s\n", i, text); free(text); text = PGTYPESnumeric_to_asc(num, 2); if (!text) check_errno(); printf("num[%d,4]: %s\n", i, text); free(text); nin = PGTYPESnumeric_new(); text = PGTYPESnumeric_to_asc(nin, 2); if (!text) check_errno(); printf("num[%d,5]: %s\n", i, text); free(text); r = PGTYPESnumeric_to_long(num, &l); if (r) check_errno(); printf("num[%d,6]: %ld (r: %d)\n", i, r?0L:l, r); if (r == 0) { r = PGTYPESnumeric_from_long(l, nin); if (r) check_errno(); text = PGTYPESnumeric_to_asc(nin, 2); q = PGTYPESnumeric_cmp(num, nin); printf("num[%d,7]: %s (r: %d - cmp: %d)\n", i, text, r, q); free(text); } r = PGTYPESnumeric_to_int(num, &k); if (r) check_errno(); printf("num[%d,8]: %d (r: %d)\n", i, r?0:k, r); if (r == 0) { r = PGTYPESnumeric_from_int(k, nin); if (r) check_errno(); text = PGTYPESnumeric_to_asc(nin, 2); q = PGTYPESnumeric_cmp(num, nin); printf("num[%d,9]: %s (r: %d - cmp: %d)\n", i, text, r, q); free(text); } r = PGTYPESnumeric_to_double(num, &d); if (r) check_errno(); printf("num[%d,10]: %g (r: %d)\n", i, r?0.0:d, r); /* do not test double to numeric because * - extra digits are different on different architectures * - PGTYPESnumeric_from_double internally calls PGTYPESnumeric_from_asc anyway */ dec = PGTYPESdecimal_new(); r = PGTYPESnumeric_to_decimal(num, dec); if (r) check_errno(); /* we have no special routine for outputting decimal, it would * convert to a numeric anyway */ printf("num[%d,11]: - (r: %d)\n", i, r); if (r == 0) { r = PGTYPESnumeric_from_decimal(dec, nin); if (r) check_errno(); text = PGTYPESnumeric_to_asc(nin, 2); q = PGTYPESnumeric_cmp(num, nin); printf("num[%d,12]: %s (r: %d - cmp: %d)\n", i, text, r, q); free(text); } PGTYPESdecimal_free(dec); PGTYPESnumeric_free(nin); printf("\n"); } for (i = 0; i < count; i++) { for (j = 0; j < count; j++) { numeric* a = PGTYPESnumeric_new(); numeric* s = PGTYPESnumeric_new(); numeric* m = PGTYPESnumeric_new(); numeric* d = PGTYPESnumeric_new(); r = PGTYPESnumeric_add(numarr[i], numarr[j], a); if (r) { check_errno(); printf("r: %d\n", r); } else { text = PGTYPESnumeric_to_asc(a, 10); printf("num[a,%d,%d]: %s\n", i, j, text); free(text); } r = PGTYPESnumeric_sub(numarr[i], numarr[j], s); if (r) { check_errno(); printf("r: %d\n", r); } else { text = PGTYPESnumeric_to_asc(s, 10); printf("num[s,%d,%d]: %s\n", i, j, text); free(text); } r = PGTYPESnumeric_mul(numarr[i], numarr[j], m); if (r) { check_errno(); printf("r: %d\n", r); } else { text = PGTYPESnumeric_to_asc(m, 10); printf("num[m,%d,%d]: %s\n", i, j, text); free(text); } r = PGTYPESnumeric_div(numarr[i], numarr[j], d); if (r) { check_errno(); printf("r: %d\n", r); } else { text = PGTYPESnumeric_to_asc(d, 10); printf("num[d,%d,%d]: %s\n", i, j, text); free(text); } } } for (i = 0; i < count; i++) { text = PGTYPESnumeric_to_asc(numarr[i], -1); printf("%d: %s\n", i, text); free(text); } return (0); }