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);
}
