int main(int argc, char * argv[])
{
struct arguments args;
parse_arguments(argc, argv, &args);
struct jpeg_compress_struct outputinfo;
JBLOCKARRAY coef_buffers[MAX_COMPONENTS];
FILE *output = setup_output(args.outputname, &outputinfo);
read_DCT(args.inputname, coef_buffers, &outputinfo);
unsigned int seed = (unsigned) strtoul(args.userPassword, NULL, 10);
node *root;
size_t usable_size = make_linked_list(coef_buffers, seed, &root);
if (args.embedFlag) {
embed(coef_buffers, args.embedMessage, root, usable_size);
write_DCT(args.outputname, coef_buffers, &outputinfo);
}
else if (args.extractFlag) {
extract(args.message_size, root, usable_size);
}
fclose(output);
return 0;
}
int main (int argc, char **argv) {
setup_output(SAMPLERATE, AFMT_U8, 1, 0x00030008);
fd_set readfds, writefds;
for (;;) {
FD_ZERO (&readfds);
FD_ZERO (&writefds);
FD_SET (1, &writefds);
FD_SET (0, &readfds);
switch (select(2, &readfds, &writefds, NULL, NULL)) {
case -1: err(1, "select");
case 0: continue;
default:
if (FD_ISSET(0, &readfds)) midirdy();
if (FD_ISSET(1, &writefds)) send(nextsample()); }}
return 0; }
// Initializes channels.
//
// Parameters:
// n_channels the number of channels
// in_format the input format code
// out_format the output format code
// sampling_rate the sampling rate
// apply_dither true to apply dither to output
//
// Returns:
// 0 if successful
// -1 if channel limit is exceeded
int
brutefir::init_channels(int n_channels,
int in_format,
int out_format,
int sampling_rate,
bool apply_dither)
{
int n;
if (n_channels > BF_MAXCHANNELS)
{
pinfo("Number of channels (%u) exceeds limit (%u).", n_channels, BF_MAXCHANNELS);
return -1;
}
bfconf->sampling_rate = sampling_rate;
bfconf->n_channels = n_channels;
// setup inputs and outputs
for (n = 0; n < bfconf->n_channels; n++)
{
setup_input(n, in_format);
setup_output(n, out_format, apply_dither);
}
// initialize overflow structure
memset(overflow, 0, sizeof(struct bfoverflow_t) * bfconf->n_channels);
memset(last_overflow, 0, sizeof(struct bfoverflow_t) * bfconf->n_channels);
for (n = 0; n < bfconf->n_channels; n++)
{
if (bfconf->outputs[n].bf.sf.isfloat)
{
overflow[n].max = 1.0;
last_overflow[n].max = 1.0;
}
else
{
overflow[n].max = get_max(bfconf->outputs[n].bf.sf.bytes);
last_overflow[n].max = get_max(bfconf->outputs[n].bf.sf.bytes);
}
}
return 0;
}
/*
* Performs the exec argument processing, all of the child forking and
* execing, and child cleanup.
* Sets exitcode to non-zero if any errors occurred.
*/
void
do_mounts(void)
{
int i, isave, cnt;
vfsent_t *vp, *vpprev, **vl;
char *newargv[ARGV_MAX];
pid_t child;
/*
* create the arg list once; the only differences among
* the calls are the options, special and mountp fields.
*/
i = 2;
if (cflg)
newargv[i++] = "-c";
if (gflg)
newargv[i++] = "-g";
if (mflg)
newargv[i++] = "-m";
if (Oflg)
newargv[i++] = "-O";
if (qflg)
newargv[i++] = "-q";
if (rflg)
newargv[i++] = "-r";
if (dashflg)
newargv[i++] = "--";
if (oflg) {
newargv[i++] = "-o";
newargv[i++] = specific_opts;
}
isave = i;
/*
* Main loop for the mount processes
*/
vl = vfsarray;
cnt = vfsarraysize;
for (vpprev = *vl; vp = *vl; vpprev = vp, vl++, cnt--) {
/*
* Check to see if we cross a mount level: e.g.,
* /a/b -> /a/b/c. If so, we need to wait for all current
* mounts to finish, rerun realpath on the remaining mount
* points, and resort the list.
*
* Also, we mount serially as long as there are lofs's
* to mount to avoid improper mount ordering.
*/
if (vp->mlevel > vpprev->mlevel || lofscnt > 0) {
vfsent_t **vlp;
while (nrun > 0 && (dowait() != -1))
;
/*
* Gads! It's possible for real path mounts points to
* change after mounts are done at a lower mount
* level.
* Thus, we need to recalculate mount levels and
* resort the list from this point.
*/
for (vlp = vl; *vlp; vlp++)
(void) setrpath(*vlp);
/*
* Sort the remaining entries based on their newly
* resolved path names.
* Do not sort if we still have lofs's to mount.
*/
if (lofscnt == 0) {
qsort((void *)vl, cnt, sizeof (vfsent_t *),
mlevelcmp);
vp = *vl;
}
}
if (vp->flag & VRPFAILED) {
fprintf(stderr, gettext(
"%s: Nonexistent mount point: %s\n"),
myname, vp->v.vfs_mountp);
vp->flag |= VNOTMOUNTED;
exitcode = 1;
continue;
}
/*
* If mount options were not specified on the command
* line, then use the ones found in the vfstab entry,
* if any.
*/
i = isave;
if (!oflg && vp->v.vfs_mntopts) {
newargv[i++] = "-o";
newargv[i++] = vp->v.vfs_mntopts;
}
newargv[i++] = vp->v.vfs_special;
newargv[i++] = vp->rpath;
newargv[i] = NULL;
/*
* This should never really fail.
*/
while (setup_iopipe(vp) == -1 && (dowait() != -1))
;
while (nrun >= maxrun && (dowait() != -1)) /* throttle */
;
if ((child = fork()) == -1) {
perror("fork");
cleanup(-1);
/* not reached */
}
if (child == 0) { /* child */
signal(SIGHUP, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
signal(SIGINT, SIG_IGN);
setup_output(vp);
doexec(vp->v.vfs_fstype, newargv);
perror("exec");
exit(1);
}
/* parent */
(void) close(vp->sopipe[WRPIPE]);
(void) close(vp->sepipe[WRPIPE]);
vp->pid = child;
nrun++;
}
/*
* Mostly done by now - wait and clean up the stragglers.
*/
cleanup(0);
}
int main(int argc, char **argv)
{
int err;
int has_set_log_format = 0;
int is_clear_log = 0;
int getLogSize = 0;
int mode = O_RDONLY;
int i;
// const char *forceFilters = NULL;
struct log_device_t* devices = NULL;
struct log_device_t* dev;
g_logformat = (log_format *)log_format_new();
if (argc == 2 && 0 == strcmp(argv[1], "--test")) {
logprint_run_tests();
exit(0);
}
if (argc == 2 && 0 == strcmp(argv[1], "--help")) {
show_help(argv[0]);
exit(0);
}
for (;;) {
int ret;
ret = getopt(argc, argv, "cdt:gsf:r:n:v:b:D");
if (ret < 0) {
break;
}
switch(ret) {
case 's':
// default to all silent
log_add_filter_rule(g_logformat, "*:s");
break;
case 'c':
is_clear_log = 1;
mode = O_WRONLY;
break;
case 'd':
g_nonblock = true;
break;
case 't':
g_nonblock = true;
g_tail_lines = atoi(optarg);
break;
case 'g':
getLogSize = 1;
break;
case 'b': {
char* buf = (char*) malloc(strlen(LOG_FILE_DIR) + strlen(optarg) + 1);
if (buf == NULL) {
fprintf(stderr,"Can't malloc LOG_FILE_DIR\n");
exit(-1);
}
strcpy(buf, LOG_FILE_DIR);
strcat(buf, optarg);
// snprintf(buf, strlen(LOG_FILE_DIR) + strlen(optarg) + 1, "%s%s", LOG_FILE_DIR, optarg);
if (devices) {
dev = devices;
while (dev->next) {
dev = dev->next;
}
dev->next = (struct log_device_t *)malloc( sizeof(struct log_device_t));
if (dev->next == NULL) {
fprintf(stderr,"Can't malloc log_device\n");
exit(-1);
}
dev->next->device = buf;
dev->next->fd = -1;
dev->next->printed = false;
dev->next->queue = NULL;
dev->next->next = NULL;
} else {
devices = (struct log_device_t *)malloc( sizeof(struct log_device_t));
if (devices == NULL) {
fprintf(stderr,"Can't malloc log_device\n");
exit(-1);
}
devices->device = buf;
devices->fd = -1;
devices->printed = false;
devices->queue = NULL;
devices->next = NULL;
}
g_dev_count++;
}
break;
case 'f':
// redirect output to a file
g_output_filename = optarg;
break;
case 'r':
// if (optarg == NULL) {
// fprintf(stderr,"optarg == null\n");
// g_log_rotate_size_kbytes = DEFAULT_LOG_ROTATE_SIZE_KBYTES;
// } else {
//long logRotateSize;
//char *lastDigit;
if (!isdigit(optarg[0])) {
fprintf(stderr,"Invalid parameter to -r\n");
show_help(argv[0]);
exit(-1);
}
g_log_rotate_size_kbytes = atoi(optarg);
// }
break;
case 'n':
if (!isdigit(optarg[0])) {
fprintf(stderr,"Invalid parameter to -r\n");
show_help(argv[0]);
exit(-1);
}
g_max_rotated_logs = atoi(optarg);
break;
case 'v':
err = set_log_format (optarg);
if (err < 0) {
fprintf(stderr,"Invalid parameter to -v\n");
show_help(argv[0]);
exit(-1);
}
has_set_log_format = 1;
break;
default:
fprintf(stderr,"Unrecognized Option\n");
show_help(argv[0]);
exit(-1);
break;
}
}
if (!devices) {
devices = (struct log_device_t *)malloc( sizeof(struct log_device_t));
if (devices == NULL) {
fprintf(stderr,"Can't malloc log_device\n");
exit(-1);
}
devices->device = strdup("/dev/"LOGGER_LOG_MAIN);
devices->fd = -1;
devices->printed = false;
devices->queue = NULL;
devices->next = NULL;
g_dev_count = 1;
int accessmode =
(mode & O_RDONLY) ? R_OK : 0
| (mode & O_WRONLY) ? W_OK : 0;
// only add this if it's available
if (0 == access("/dev/"LOGGER_LOG_SYSTEM, accessmode)) {
devices->next = (struct log_device_t *)malloc( sizeof(struct log_device_t));
if (devices->next == NULL) {
fprintf(stderr,"Can't malloc log_device\n");
exit(-1);
}
devices->next->device = strdup("/dev/"LOGGER_LOG_SYSTEM);
devices->next->fd = -1;
devices->next->printed = false;
devices->next->queue = NULL;
devices->next->next = NULL;
g_dev_count ++;
}
if (0 == access("/dev/"LOGGER_LOG_APPS, accessmode)) {
devices->next = (struct log_device_t *)malloc( sizeof(struct log_device_t));
if (devices->next == NULL) {
fprintf(stderr,"Can't malloc log_device\n");
exit(-1);
}
devices->next->device = strdup("/dev/"LOGGER_LOG_APPS);
devices->next->fd = -1;
devices->next->printed = false;
devices->next->queue = NULL;
devices->next->next = NULL;
g_dev_count ++;
}
/*
// only add this if it's available
int fd;
if ((fd = open("/dev/"LOGGER_LOG_SYSTEM, mode)) != -1) {
devices->next = (struct log_device_t *)malloc( sizeof(struct log_device_t));
devices->next->device = strdup("/dev/"LOGGER_LOG_SYSTEM);
devices->next->fd = -1;
devices->next->printed = false;
devices->next->queue = NULL;
devices->next->next = NULL;
g_dev_count ++;
close(fd);
}
*/
}
if (g_log_rotate_size_kbytes != 0 && g_output_filename == NULL)
{
fprintf(stderr,"-r requires -f as well\n");
show_help(argv[0]);
exit(-1);
}
setup_output();
if (has_set_log_format == 0) {
err = set_log_format("brief");
}
/*
const char* logFormat = getenv("DLOG_PRINTF_LOG");
if (logFormat != NULL) {
err = set_log_format("brief");
if (err < 0) {
fprintf(stderr, "invalid format in DLOG_PRINTF_LOG '%s'\n", logFormat);
}
}
}
if (forceFilters) {
err = log_add_filter_string(g_logformat, forceFilters);
if (err < 0) {
fprintf (stderr, "Invalid filter expression in -logcat option\n");
exit(0);
}
} else if (argc == optind) {
// Add from environment variable
char *env_tags_orig = getenv("DLOG_LOG_TAGS");
if (env_tags_orig != NULL) {
err = log_add_filter_string(g_logformat, env_tags_orig);
if (err < 0) {
fprintf(stderr, "Invalid filter expression in DLOG_LOG_TAGS\n");
show_help(argv[0]);
exit(-1);
}
}
} else {
// Add from commandline
*/
fprintf(stderr,"arc = %d, optind = %d ,Kb %d, rotate %d\n", argc, optind,g_log_rotate_size_kbytes,g_max_rotated_logs);
if(argc == optind )
{
// Add from environment variable
//char *env_tags_orig = getenv("DLOG_TAGS");
log_add_filter_string(g_logformat, "*:d");
}
else
{
for (i = optind ; i < argc ; i++) {
err = log_add_filter_string(g_logformat, argv[i]);
if (err < 0) {
fprintf (stderr, "Invalid filter expression '%s'\n", argv[i]);
show_help(argv[0]);
exit(-1);
}
}
}
/*
}
*/
dev = devices;
while (dev) {
dev->fd = open(dev->device, mode);
if (dev->fd < 0) {
fprintf(stderr, "Unable to open log device '%s': %s\n",
dev->device, strerror(errno));
exit(EXIT_FAILURE);
}
if (is_clear_log) {
int ret;
ret = clear_log(dev->fd);
if (ret) {
perror("ioctl");
exit(EXIT_FAILURE);
}
}
if (getLogSize) {
int size, readable;
size = get_log_size(dev->fd);
if (size < 0) {
perror("ioctl");
exit(EXIT_FAILURE);
}
readable = get_log_readable_size(dev->fd);
if (readable < 0) {
perror("ioctl");
exit(EXIT_FAILURE);
}
printf("%s: ring buffer is %dKb (%dKb consumed), "
"max entry is %db, max payload is %db\n", dev->device,
size / 1024, readable / 1024,
(int) LOGGER_ENTRY_MAX_LEN, (int) LOGGER_ENTRY_MAX_PAYLOAD);
}
dev = dev->next;
}
if (getLogSize) {
return 0;
}
if (is_clear_log) {
return 0;
}
read_log_lines(devices);
return 0;
}
int main(int argc, char *argv[]){
/* extract program name from path. e.g. /path/to/MArCd -> MArCd */
const char* separator = strrchr(argv[0], '/');
if ( separator ){
program_name = separator + 1;
} else {
program_name = argv[0];
}
default_env();
int ret;
int option_index = 0;
int op;
#ifdef HAVE_INIPARSER_H
if ( config::load(argc, argv) != 0 ){ /* passing argv so it can read -f/--config */
return 1; /* error already shown */
}
#endif
while ( (op = getopt_long(argc, argv, shortopts, longopts, &option_index)) != -1 ){
switch (op){
case '?': /* error */
exit(1);
case 0: /* long opt */
break;
case 'b': /* --daemon */
daemon_mode = 1;
break;
case 's': /* --syslog */
syslog_flag = true;
break;
case FLAG_USER: /* --user */
config::set_drop_username(optarg);
break;
case FLAG_GROUP: /* --group */
config::set_drop_group(optarg);
break;
case FLAG_DROP_PRIV: /** --drop */
drop_priv_flag = true;
break;
case FLAG_NODROP_PRIV: /** --no-drop */
drop_priv_flag = false;
break;
case 'f':
#ifndef HAVE_INIPARSER_H
fprintf(stderr, "%s: configuration files not supported (build with --with-iniparser)\n", program_name);
#endif
break;
case 'H':
strncpy(db_hostname, optarg, sizeof(db_hostname));
db_hostname[sizeof(db_hostname)-1] = '\0';
break;
case 'N':
strncpy(db_name, optarg, sizeof(db_name));
db_name[sizeof(db_name)-1] = '\0';
break;
case 'u':
strncpy(db_username, optarg, sizeof(db_username));
db_username[sizeof(db_username)-1] = '\0';
break;
case 'p':
if ( strcmp(optarg, "-") == 0 ){ /* read password from stdin */
strncpy(db_password, getpass("mysql password: "******"Invalid port given to --relay: %s. Ignored\n", optarg);
}
}
break;
case FLAG_DATADIR:
free(rrdpath);
rrdpath = strdup(optarg);
break;
case FLAG_PIDFILE:
pidfile = optarg;
break;
case 'v': /* --verbose */
verbose_flag = 1;
break;
case 'q': /* --quiet */
verbose_flag = 0;
break;
case 'd': /* --debug */
debug_flag = 1;
break;
case 'h': /* --help */
show_usage();
exit(0);
default:
if ( option_index >= 0 ){
fprintf(stderr, "flag --%s declared but not handled\n", longopts[option_index].name);
} else {
fprintf(stderr, "flag -%c declared but not handled\n", op);
}
abort();
}
}
/* database */
if ( argc > optind ){
strncpy(db_name, argv[optind], sizeof(db_name));
db_name[sizeof(db_name)-1] = '\0';
}
setup_output();
/* test if possible to drop privileges */
if ( drop_priv_flag && getuid() != 0 ){
Log::message(MAIN, "Not executing as uid=0, cannot drop privileges.\n");
drop_priv_flag = 0;
}
/* Drop privileges.
* Done before forking since unlinking requires write permission to folder so
* if it fails to write it will fail unlinking. It is also done before
* check_env so it actually check environment for the dropped user instead of
* root.
*/
if ( drop_priv_flag ){
privilege_drop();
}
/* sanity checks */
show_env();
if ( !check_env() ){
return 1;
}
if ( daemon_mode ){
/* opening file before fork since it will be a fatal error if it fails to write the pid */
FILE* fp = fopen(pidfile, "w");
if ( !fp ){
Log::fatal(MAIN, "failed to open '%s` for writing: %s\n", pidfile, strerror(errno));
return 1;
}
Log::message(MAIN, "Forking to background\n");
pid_t pid = fork();
if ( pid ){ /* parent */
fprintf(fp, "%d\n", pid);
fclose(fp);
/* change owner of pidfile */
if ( drop_priv_flag ){
if ( chown(pidfile, drop_uid, drop_gid) != 0 ){
Log::error("failed to change owner of '%s`, will probably fail to unlink it later: %s\n", pidfile, strerror(errno));
}
}
return 0;
}
fclose(fp);
}
/* initialize daemons */
pthread_barrier_t barrier;
int threads = 1;
threads += (int)have_control_daemon;
threads += (int)have_relay_daemon;
pthread_barrier_init(&barrier, NULL, threads);
control.addr = relay.addr;
if ( have_control_daemon && (ret=Daemon::instantiate<Control>(2000, &barrier)) != 0 ){
Log::fatal(MAIN, "Failed to initialize control daemon, terminating.\n");
if ( daemon_mode && unlink(pidfile) == -1 ){
Log::fatal(MAIN, "Failed to remove pidfile: %s\n", strerror(errno));
}
return ret;
}
if ( have_relay_daemon && (ret=Daemon::instantiate<Relay>(2000, &barrier)) != 0 ){
Log::fatal(MAIN, "Failed to initialize relay daemon, terminating.\n");
if ( daemon_mode && unlink(pidfile) == -1 ){
Log::fatal(MAIN, "Failed to remove pidfile: %s\n", strerror(errno));
}
return ret;
}
/* install signal handler */
signal(SIGINT, handle_signal);
signal(SIGTERM, handle_signal);
/* release all threads and wait for them to finish*/
pthread_barrier_wait(&barrier);
if ( daemon_mode ){
Log::message(MAIN, "Threads started. Going to sleep.\n");
} else {
Log::message(MAIN, "Threads started. Going to sleep. Abort with SIGINT\n");
}
Daemon::join_all();
/* cleanup */
free(rrdpath);
if ( daemon_mode && unlink(pidfile) == -1 ){
Log::fatal(MAIN, "Failed to remove pidfile: %s\n", strerror(errno));
}
Log::message(MAIN, "%s terminated.\n", program_name);
return 0;
}
/**
* Parse command line options.
*
* @param argv program arguments
*/
void read_options(int argc, char *argv[])
{
struct parsed_cmd_line_t cmd_line;
#ifdef _WIN32
int i;
vector_t *expanded_cnames;
#endif
memset(&opt, 0, sizeof(opt));
opt.mem = rsh_vector_new_simple();
opt.find_max_depth = -1;
/* initialize cmd_line */
memset(&cmd_line, 0, sizeof(cmd_line));
rsh_blocks_vector_init(&cmd_line.options);
cmd_line.argv = argv;
cmd_line.argc = argc;
/* parse command line and apply encoding options */
parse_cmdline_options(&cmd_line);
read_config();
#ifdef _WIN32
/* set default encoding if no encoding options were specified, */
/* this should be done here, even if config file was not found. */
if( (opt.flags & OPT_ENCODING) == 0 ) opt.flags |= OPT_UTF8;
#endif
/* note: encoding and -o/-l options are already applied */
IF_WINDOWS(setup_console());
setup_output(); /* setup program output */
apply_cmdline_options(&cmd_line); /* process the rest of command options */
/* options were processed, so we don't need them anymore */
rsh_blocks_vector_destroy(&cmd_line.options);
#ifdef _WIN32
expanded_cnames = rsh_vector_new_simple();
/* convert paths to internal encoding and expand wildcards. */
for(i = 0; i < cmd_line.n_files; i++) {
wchar_t* path = cmd_line.files[i];
wchar_t* p = wcschr(path, L'\0') - 1;
/* strip trailing '\','/' symbols (if not preceded by ':') */
for(; p > path && IS_PATH_SEPARATOR_W(*p) && p[-1] != L':'; p--) *p = 0;
expand_wildcards(expanded_cnames, path);
}
opt.cmd_vec = expanded_cnames;
opt.files = (char**)expanded_cnames->array;
opt.n_files = (int)expanded_cnames->size;
free(cmd_line.files);
LocalFree(cmd_line.warg);
#else
opt.files = cmd_line.files;
opt.n_files = cmd_line.n_files;
rsh_vector_add_ptr(opt.mem, opt.files);
#endif
make_final_options_checks();
set_default_sums_flags(argv[0]); /* detect default hashes from program name */
}
inline
pid_t
posix_start(const Executable& exe,
const Arguments& args,
const environment& env,
info_map& infoin,
info_map& infoout,
const posix_setup& setup)
{
pid_t pid = ::fork();
if (pid == -1) {
boost::throw_exception
(system_error("boost::process::detail::posix_start",
"fork(2) failed", errno));
} else if (pid == 0) {
#if defined(F_MAXFD)
int maxdescs = std::max(::fcntl(0, F_MAXFD), 128); // XXX
#else
int maxdescs = 128; // XXX
#endif
try {
boost::scoped_array< bool > closeflags(new bool[maxdescs]);
for (int i = 0; i < maxdescs; i++)
closeflags.get()[i] = true;
setup_input(infoin, closeflags.get(), maxdescs);
setup_output(infoout, closeflags.get(), maxdescs);
for (int i = 0; i < maxdescs; i++)
if (closeflags.get()[i])
::close(i);
setup();
} catch (const system_error& e) {
::write(STDERR_FILENO, e.what(), std::strlen(e.what()));
::write(STDERR_FILENO, "\n", 1);
::exit(EXIT_FAILURE);
}
std::pair< std::size_t, char** > argcv =
collection_to_posix_argv(args);
char** envp = environment_to_envp(env);
::execve(exe.c_str(), argcv.second, envp);
system_error e("boost::process::detail::posix_start",
"execve(2) failed", errno);
for (std::size_t i = 0; i < argcv.first; i++)
delete [] argcv.second[i];
delete [] argcv.second;
for (std::size_t i = 0; i < env.size(); i++)
delete [] envp[i];
delete [] envp;
::write(STDERR_FILENO, e.what(), std::strlen(e.what()));
::write(STDERR_FILENO, "\n", 1);
::exit(EXIT_FAILURE);
}
BOOST_ASSERT(pid > 0);
for (info_map::iterator iter = infoin.begin();
iter != infoin.end(); iter++) {
stream_info& si = (*iter).second;
if (si.m_type == stream_info::use_pipe)
si.m_pipe->rend().close();
}
for (info_map::iterator iter = infoout.begin();
iter != infoout.end(); iter++) {
stream_info& si = (*iter).second;
if (si.m_type == stream_info::use_pipe)
si.m_pipe->wend().close();
}
return pid;
}
void
setup(int pid)
{
struct perf_event_attr hw;
struct timeval tv;
int ret;
memset(&hw, 0, sizeof(hw));
hw.type = PERF_TYPE_RAW;
hw.size = sizeof(hw);
hw.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
PERF_FORMAT_TOTAL_TIME_RUNNING;
//hw.inherit = 1;
//hw.enable_on_exec = 1;
//hw.disabled = 1;
gbl.ncpus = sysconf(_SC_NPROCESSORS_ONLN);
gbl.ncores = gbl.ncpus / 4;
events = (evinfo (*)[NEVENTS])malloc(gbl.ncpus * NEVENTS * sizeof(struct evinfo));
if (events == NULL)
err(1, "Can't malloc events");
threads = (pthread_t *)malloc(gbl.ncpus*sizeof(pthread_t));
if (threads == NULL)
err(1, "Can't malloc threads");
memset(events, 0, gbl.ncpus*NEVENTS*sizeof(struct evinfo));
counters = (counter *)_mm_malloc(gbl.ncpus * sizeof(struct counter), 64);
if (counters == NULL)
err(1, "Can't malloc counters");
memset(counters, 0, gbl.ncpus * sizeof(struct counter));
lastctr = (counter *)_mm_malloc(gbl.ncpus * sizeof(struct counter), 64);
if (lastctr == NULL)
err(1, "Can't malloc lastctr");
memset(lastctr, 0, gbl.ncpus * sizeof(struct counter));
/* Could do this per thread */
for (int cpu = 0; cpu < gbl.ncpus; ++cpu)
for (int i = 0; i < NEVENTS; ++i)
{
evinfo *ep = &events[cpu][i];
hw.config = evtcodes[i];
// We'd like to use pid instead of -1 here, but apparently
// broken on KNC 2.6.38
ep->fd = perf_event_open(&hw, -1, cpu, -1, 0);
if (ep->fd == -1)
err(1, "CPU %d, event 0x%lx", cpu, hw.config);
#if 0
// We'd like to use user-mode rdpmc pattern but need
// newer kernel that exports even non-running counters
ep->buf = mmap(NULL, 2*4096, PROT_READ|PROT_WRITE, MAP_SHARED,
ep->fd, 0);
if (ep->buf == MAP_FAILED)
err(1, "CPU %d, event 0x%lx: cannot mmap buffer",
cpu, hw.config);
#endif
}
pthread_barrier_init(&barrier, NULL, gbl.ncpus);
/* Now spawn a pthread on every processor */
for (int i = 1; i < gbl.ncpus; ++i)
{
pthread_attr_t attr;
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(i, &cpuset);
pthread_attr_init(&attr);
pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset);
ret = pthread_create(&threads[i], &attr, thrstart, (void *)i);
if (ret)
err(1, "pthread_create returns %d", ret);
pthread_attr_destroy(&attr);
}
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(0, &cpuset);
sched_setaffinity(0, sizeof(cpuset), &cpuset);
setup_output();
ret = gettimeofday(&tv, 0);
if (ret != 0)
err(1, "gettimeofday");
starttime = tv.tv_sec + (double)tv.tv_usec * 1e-6;
//pthread_barrier_wait(&barrier);
}
void *Read_CT_Data(void *arg)
{
rp_pinState_t heart_beat_state;
uint32_t buff_size = RP_BUF_SIZE;
uint32_t trig_pos;
float *buff_ch1 = (float *)malloc(buff_size * sizeof(float));
float *buff_ch2 = (float *)malloc(buff_size * sizeof(float));
float val_sum_ch1,val_sum_ch2,val_ch1,val_ch2;
float tmp_val_ch1, tmp_val_ch2;
float charge_ch1;
float charge_ch2;
int counter;
clock_t start_time, diff;
int msec;
int endpoints;
int startpoints;
val_sum_ch1=0;
counter=0;
msec=0;
new_data=0;
/* Print error, if rp_Init() function failed */
if(rp_Init() != RP_OK)
{
fprintf(stderr, "Rp api init failed!n");
}
setup_output();
//rp_AcqSetDecimation(RP_DEC_8 );
rp_AcqSetSamplingRate(RP_SMP_125M);
//rp_AcqSetSamplingRate(RP_SMP_15_625M);
rp_AcqSetTriggerLevel(trig_level); //Trig level is set in Volts while in SCPI is set in mV
rp_AcqSetTriggerDelayNs(0);
//rp_AcqSetTriggerDelay(0);
rp_AcqSetAveraging(true);
rp_AcqStart();
//rp_AcqSetTriggerSrc(RP_TRIG_SRC_EXT_PE);
//rp_AcqSetTriggerSrc(RP_TRIG_SRC_CHA_NE); // Trig on signal
rp_AcqSetTriggerSrc(trig_source);
rp_acq_trig_state_t state = RP_TRIG_STATE_TRIGGERED;
// Get clock
start_time = clock();
rp_DpinSetDirection ( RP_LED4, RP_OUT);
rp_DpinSetDirection ( RP_LED3, RP_OUT);
rp_DpinSetDirection ( RP_DIO1_P, RP_OUT);
rp_AcqStart();
//Clear count_table
count_table[0]=0;
free_counter=0;
heart_beat_state=RP_LOW;
while(1)
{
// Wait for trig
while(1)
{
diff=clock()-start_time;
msec=diff*1000/CLOCKS_PER_SEC;
rp_AcqGetTriggerState(&state);
if(state == RP_TRIG_STATE_TRIGGERED)
{
usleep(10);
triggered=1;
break;
}
if (msec>2000)
{
rp_AcqStart();
rp_AcqSetTriggerSrc(trig_source);
rp_GenAmp(RP_CH_2, 0);
triggered=0;
printf("No trig for 2 s... Set output analog output to zero");
}
}
// Get data
rp_DpinSetState( RP_LED4, RP_HIGH);
rp_AcqGetWritePointerAtTrig(&trig_pos);
//printf("Trig pos: %d", trig_pos);
// Check if trig_pos is too close to buffer start/end
if ((trig_pos+num_data_points_after_trig)>(RP_BUF_SIZE-1))
{
endpoints=(RP_BUF_SIZE-1)-(trig_pos-num_data_points_before_trig);
startpoints=num_data_points_after_trig-((RP_BUF_SIZE-1)-trig_pos);
rp_AcqGetDataPosV(RP_CH_1,0,(RP_BUF_SIZE-1),buff_ch1,&buff_size); // Get entire buffer
rp_AcqGetDataPosV(RP_CH_2,0,(RP_BUF_SIZE-1),buff_ch2,&buff_size); // Get entire buffer
val_ch1=integrated_charge(buff_ch1,((RP_BUF_SIZE-1)-endpoints),(RP_BUF_SIZE-1));
tmp_val_ch1=integrated_charge(buff_ch1,0,startpoints);
val_ch2=integrated_charge(buff_ch2,((RP_BUF_SIZE-1)-endpoints),(RP_BUF_SIZE-1));
tmp_val_ch2=integrated_charge(buff_ch2,0,startpoints);
val_ch1=val_ch1+tmp_val_ch1;
val_ch2=val_ch2+tmp_val_ch2;
//Debug
//printf("High Ring Buffer overflow\n");
//printf("ch1: %f ch2: %f\n",val_ch1,val_ch2);
//printf("Trig pos: %d end %d start %d\n", trig_pos, endpoints, startpoints);
}
else if ((trig_pos-num_data_points_before_trig)<0)
{
endpoints=(trig_pos-num_data_points_before_trig);
startpoints=num_data_points_after_trig-endpoints;
rp_AcqGetDataPosV(RP_CH_1,0,(RP_BUF_SIZE-1),buff_ch1,&buff_size); // Get entire buffer
rp_AcqGetDataPosV(RP_CH_2,0,(RP_BUF_SIZE-1),buff_ch2,&buff_size); // Get entire buffer
val_ch1=integrated_charge(buff_ch1,((RP_BUF_SIZE-1)-endpoints),(RP_BUF_SIZE-1));
tmp_val_ch1=integrated_charge(buff_ch1,0,startpoints);
val_ch2=integrated_charge(buff_ch2,((RP_BUF_SIZE-1)-endpoints),(RP_BUF_SIZE-1));
tmp_val_ch2=integrated_charge(buff_ch2,0,startpoints);
val_ch1=val_ch1+tmp_val_ch1;
val_ch2=val_ch2+tmp_val_ch2;
//Debug
printf("Low Ring Buffer underrun\n");
printf("ch1: %f ch2: %f\n",val_ch1,val_ch2);
printf("Trig pos: %d end %d start %d\n", trig_pos, endpoints, startpoints);
}
else
{
rp_AcqGetDataPosV(RP_CH_1,(trig_pos-num_data_points_before_trig),(trig_pos+num_data_points_after_trig),buff_ch1,&buff_size);
rp_AcqGetDataPosV(RP_CH_2,(trig_pos-num_data_points_before_trig),(trig_pos+num_data_points_after_trig),buff_ch2,&buff_size);
val_ch1=integrated_charge(buff_ch1,0,(num_data_points_after_trig+num_data_points_before_trig));
val_ch2=integrated_charge(buff_ch2,0,(num_data_points_after_trig+num_data_points_before_trig));
}
val_sum_ch1=val_sum_ch1+val_ch1;
val_sum_ch2=val_sum_ch2+val_ch2;
counter++;
charge[0]=val_ch1+val_ch2;
//rp_DpinSetState( RP_DIO1_P, RP_HIGH);
//usleep(20);
//rp_DpinSetState( RP_DIO1_P, RP_LOW);
// Update data each s, 1050 ms to make sure the buffers update even @ 1 Hz trigger rate
if (msec>1050)
{
start_time = clock();
charge_ch1=(val_sum_ch1/(counter-1));
charge_ch2=(val_sum_ch2/(counter-1));
pthread_mutex_lock( &mutex1 );
charge[1]=charge_ch1+charge_ch2;
// Update table of volt & counters for sec 1-9
for (int i=9;i>1;i--)
{
count_table[i]=count_table[i-1]+counter;
charge[i]=charge[i-1]+charge[1];
}
count_table[1]=counter;
charge[1]=charge[1];
printf("\nNo of Triggers: %d, Time betweem (msec): %d\n", count_table[1], msec);
/* Generating amplitude */
//Check if overflow for the DAC
if (charge[1]<1)
{
rp_GenAmp(RP_CH_2, charge[1]);
}
else
{
rp_GenAmp(RP_CH_2, 1);
}
printf("Charge: %f nC, Charge Ch1: %f nC, Charge Ch2: %f nC\n",charge[1], charge_ch1,charge_ch2);
fflush(stdout);
val_sum_ch1=0;
val_sum_ch2=0;
counter=0;
free_counter++;
// Digital output heartbeat
rp_DpinGetState(RP_DIO1_P, &heart_beat_state);
if (heart_beat_state==RP_LOW)
{
rp_DpinSetState( RP_DIO1_P, RP_HIGH);
}
else
{
rp_DpinSetState( RP_DIO1_P, RP_LOW);
}
// Get FPGA temp
rp_HealthGetValue(RP_TEMP_FPGA, &fpga_temp);
printf("FPGA temp: %.01f C\n",fpga_temp);
}
new_data=1;
pthread_mutex_unlock( &mutex1 );
rp_AcqStart();
rp_AcqSetTriggerSrc(trig_source);
rp_DpinSetState( RP_LED4, RP_LOW);
}
/* Releasing resources */
fflush(stdout);
free(buff_ch1);
free(buff_ch2);
rp_Release();
return NULL;
}
