static int debugger_wait(debugger_state *debugger, int *status, int options, int (*syscall)(debugger_state *debugger, pid_t child), int (*normal_return)(debugger_state *debugger, pid_t unused), int (*wait_return)(debugger_state *debugger, pid_t unused)) { if(debugger->real_wait){ debugger->handle_trace = normal_return; syscall_continue(debugger->pid); debugger->real_wait = 0; return(1); } debugger->wait_status_ptr = status; debugger->wait_options = options; if((debugger->debugee != NULL) && debugger->debugee->event){ syscall_continue(debugger->pid); wait_for_stop(debugger->pid, SIGTRAP, PTRACE_SYSCALL, NULL); (*wait_return)(debugger, -1); return(0); } else if(debugger->wait_options & WNOHANG){ syscall_cancel(debugger->pid, 0); debugger->handle_trace = syscall; return(0); } else { syscall_pause(debugger->pid); debugger->handle_trace = wait_return; debugger->waiting = 1; } return(1); }
void attach_process(int pid) { if((ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) || (ptrace(PTRACE_CONT, pid, 0, 0) < 0)) tracer_panic("OP_FORK failed to attach pid"); wait_for_stop(pid, SIGSTOP, PTRACE_CONT, NULL); if(ptrace(PTRACE_CONT, pid, 0, 0) < 0) tracer_panic("OP_FORK failed to continue process"); }
int clone_and_wait(int (*fn)(void *), void *arg, void *sp, int flags) { int pid; pid = clone(fn, sp, flags, arg); if(pid < 0) return(-1); wait_for_stop(pid, SIGSTOP, PTRACE_CONT, NULL); ptrace(PTRACE_CONT, pid, 0, 0); return(pid); }
void syscall_cancel(pid_t pid, int result) { if((ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET, __NR_getpid) < 0) || (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0) || (wait_for_stop(pid, SIGTRAP, PTRACE_SYSCALL, NULL) < 0) || (ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_RET_OFFSET, result) < 0) || (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0)) printk("ptproxy: couldn't cancel syscall: errno = %d\n", errno); }
int outer_tramp(void *arg) { struct tramp *t; int sig = sigkill; t = arg; t->pid = clone(t->tramp, (void *) t->temp_stack + page_size()/2, t->flags, t->tramp_data); if(t->pid > 0) wait_for_stop(t->pid, SIGSTOP, PTRACE_CONT, NULL); kill(os_getpid(), sig); _exit(0); }
int schedule_reading() { int *read_schedule,re_try = 0; long read_wait; modbus_t *sdl; double sdl_data; uint16_t *rd_data_registers; modbus_t *rd_ctx; read_schedule = (int*)malloc(6*sizeof(int)); rd_data_registers = (uint16_t*)malloc(2*sizeof(uint16_t)); read_schedule = check_time(read_schedule); if((read_schedule[4]>=3) && (read_schedule[4]<=10)) { enable(0); initbus(1); sleep(1); rd_ctx= modbusconnection(rd_ctx); sleep(1); gotoposition(rd_ctx, 0,rd_data_registers); setconfig(9,0); wait_for_stop(rd_ctx,rd_data_registers); initbus(0); sdl_sample: sdl = sdl_connection(sdl); if(sdl == NULL) { if(re_try < 3){re_try++;goto sdl_sample;} else { login("Failed in connecting in sample duration"); setsdl(30000,-100000); } } else { sdl_read_sensor(sdl,1,0); sleep(30); sample_save_data(sdl); } modbus_close(sdl); } return 1; }
static void dump_thread(log_t* log, pid_t tid, bool attached, bool* detach_failed, int* total_sleep_time_usec) { char path[PATH_MAX]; char threadnamebuf[1024]; char* threadname = NULL; FILE* fp; snprintf(path, sizeof(path), "/proc/%d/comm", tid); if ((fp = fopen(path, "r"))) { threadname = fgets(threadnamebuf, sizeof(threadnamebuf), fp); fclose(fp); if (threadname) { size_t len = strlen(threadname); if (len && threadname[len - 1] == '\n') { threadname[len - 1] = '\0'; } } } _LOG(log, SCOPE_AT_FAULT, "\n\"%s\" sysTid=%d\n", threadname ? threadname : "<unknown>", tid); if (!attached && ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) { _LOG(log, SCOPE_AT_FAULT, "Could not attach to thread: %s\n", strerror(errno)); return; } wait_for_stop(tid, total_sleep_time_usec); backtrace_context_t context; if (!backtrace_create_context(&context, tid, -1, 0)) { _LOG(log, SCOPE_AT_FAULT, "Could not create backtrace context.\n"); } else { dump_backtrace_to_log(&context, log, SCOPE_AT_FAULT, " "); backtrace_destroy_context(&context); } if (!attached && ptrace(PTRACE_DETACH, tid, 0, 0) != 0) { LOG("ptrace detach from %d failed: %s\n", tid, strerror(errno)); *detach_failed = true; } }
int start_child() { pid_t mypid = getpid(); setpgid(mypid, mypid); pid_t child; child = fork(); switch (child) { case 0: close(pipe_fd[1]); dup2(pipe_fd[0],0); if (proc_stat.argc > 0) { return execvp(proc_stat.path, proc_stat.argv); } else { char *b = NULL; b = malloc((sizeof("exec ") - 1) + strlen(proc_stat.path) + 1); strcpy(b, "exec "); strcat(b, proc_stat.path); return execl("/bin/sh", "sh", "-c", b, (char *) NULL); } case -1: fprintf(stderr, "launch: fork failed: %s\n", strerror(errno)); return -1; default: close(pipe_fd[0]); proc_stat.pid = child; int a=1; mylog("start child pid=%d",child); if(wait_for_service()){ proc_stat.running = RUNNING; wait_for_stop(); clean_child(); }else{ clean_child(); } } }
static void dump_thread( log_t* log, pid_t tid, bool attached, bool* detach_failed, int* total_sleep_time_usec) { char path[PATH_MAX]; char threadnamebuf[1024]; char* threadname = NULL; FILE* fp; snprintf(path, sizeof(path), "/proc/%d/comm", tid); if ((fp = fopen(path, "r"))) { threadname = fgets(threadnamebuf, sizeof(threadnamebuf), fp); fclose(fp); if (threadname) { size_t len = strlen(threadname); if (len && threadname[len - 1] == '\n') { threadname[len - 1] = '\0'; } } } _LOG(log, logtype::BACKTRACE, "\n\"%s\" sysTid=%d\n", threadname ? threadname : "<unknown>", tid); if (!attached && ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) { _LOG(log, logtype::BACKTRACE, "Could not attach to thread: %s\n", strerror(errno)); return; } wait_for_stop(tid, total_sleep_time_usec); UniquePtr<Backtrace> backtrace(Backtrace::Create(tid, BACKTRACE_CURRENT_THREAD)); if (backtrace->Unwind(0)) { dump_backtrace_to_log(backtrace.get(), log, " "); } if (!attached && ptrace(PTRACE_DETACH, tid, 0, 0) != 0) { _LOG(log, logtype::ERROR, "ptrace detach from %d failed: %s\n", tid, strerror(errno)); *detach_failed = true; } }
/*! * @brief Berechnet aktuelle Mittelwerte und Varianzen und prueft nach dt ms auf bessere Bewertung * @param dt Zeit in ms bevor eine neue Bewertung erstellt wird * @param pid_param Zeiger auf den veraenderlichen PID-Parameter * @param step Wert, um den *pid_param inkrementiert wird * Neue beste Parameter werden gespeichert und vor jeder Parameteraenderung wird der Bot kurz angehalten. * Bei neuem besten Wert werden die bisher besten Parameter per LOG ausgegeben */ static void compare_weightings(const uint16_t dt, int8_t * pid_param, const int8_t step) { /* Mittelwerte und Varianzen aktualisieren */ float weight = calc_weighting(); /* nach dt ms aktuelle Bewertung mit bisher bester vergleichen */ if (timer_ms_passed_32(&ticks, dt)) { uint32_t dt_real = TIMER_GET_TICKCOUNT_32 - ticks_start; weight = weight / (float)dt_real * (dt*1000.0f/176.0f); // Bewertung normieren if (best_weight >= weight) { /* Verbesserung => die aktuellen Parameter merken */ best_weight = weight; best_Kp = Kp; best_Ki = Ki; best_Kd = Kd; /* User per LOG informieren */ LOG_INFO("Kp=%d\tKi=%d\tKd=%d\tnach %u s", best_Kp, best_Ki, best_Kd, TICKS_TO_MS(TIMER_GET_TICKCOUNT_32)/1000); // uint32_t weight_int = weight * 1000000.0f; LOG_DEBUG("weight=%lu", (uint32_t)(weight * 1000000.0f)); } /* neuen Parameter einstellen und Nachlauf abwarten */ *pid_param = (int8_t) (*pid_param + step); // uint32_t weight_int = weight * 1000000.0f; // LOG_DEBUG("weight=%lu", weight_int); wait_for_stop(); /* alten Daten verwerfen */ clear_weighting(); /* verbleibende Zeit aktualisieren */ cal_pid_ete -= dt / 1000; } }
int attach_child(pid_t pid, const char *pty, int force_stdio) { struct ptrace_child child; child_addr_t scratch_page = -1; int *child_tty_fds = NULL, n_fds, child_fd, statfd = -1; int i; int err = 0; long page_size = sysconf(_SC_PAGE_SIZE); #ifdef __linux__ char stat_path[PATH_MAX]; #endif if ((err = check_pgroup(pid))) { return err; } if ((err = preflight_check(pid))) { return err; } debug("Using tty: %s", pty); if ((err = copy_tty_state(pid, pty))) { if (err == ENOTTY && !force_stdio) { error("Target is not connected to a terminal.\n" " Use -s to force attaching anyways."); return err; } } #ifdef __linux__ snprintf(stat_path, sizeof stat_path, "/proc/%d/stat", pid); statfd = open(stat_path, O_RDONLY); if (statfd < 0) { error("Unable to open %s: %s", stat_path, strerror(errno)); return -statfd; } #endif kill(pid, SIGTSTP); wait_for_stop(pid, statfd); if ((err = grab_pid(pid, &child, &scratch_page))) { goto out_cont; } if (force_stdio) { child_tty_fds = malloc(3 * sizeof(int)); if (!child_tty_fds) { err = ENOMEM; goto out_unmap; } n_fds = 3; child_tty_fds[0] = 0; child_tty_fds[1] = 1; child_tty_fds[2] = 2; } else { child_tty_fds = get_child_tty_fds(&child, statfd, &n_fds); if (!child_tty_fds) { err = child.error; goto out_unmap; } } if (ptrace_memcpy_to_child(&child, scratch_page, pty, strlen(pty) + 1)) { err = child.error; error("Unable to memcpy the pty path to child."); goto out_free_fds; } child_fd = do_syscall(&child, openat, -1, scratch_page, O_RDWR | O_NOCTTY, 0, 0, 0); if (child_fd < 0) { err = child_fd; error("Unable to open the tty in the child."); goto out_free_fds; } debug("Opened the new tty in the child: %d", child_fd); err = ignore_hup(&child, scratch_page); if (err < 0) goto out_close; err = do_syscall(&child, getsid, 0, 0, 0, 0, 0, 0); if (err != child.pid) { debug("Target is not a session leader, attempting to setsid."); err = do_setsid(&child); } else { do_syscall(&child, ioctl, child_tty_fds[0], TIOCNOTTY, 0, 0, 0, 0); } if (err < 0) goto out_close; err = do_syscall(&child, ioctl, child_fd, TIOCSCTTY, 1, 0, 0, 0); if (err != 0) { /* Seems to be returning >0 for error */ error("Unable to set controlling terminal: %s", strerror(err)); goto out_close; } debug("Set the controlling tty"); for (i = 0; i < n_fds; i++) { err = do_dup2(&child, child_fd, child_tty_fds[i]); if (err < 0) error("Problem moving child fd number %d to new tty: %s", child_tty_fds[i], strerror(errno)); } err = 0; out_close: do_syscall(&child, close, child_fd, 0, 0, 0, 0, 0); out_free_fds: free(child_tty_fds); out_unmap: do_unmap(&child, scratch_page, page_size); ptrace_restore_regs(&child); ptrace_detach_child(&child); if (err == 0) { kill(child.pid, SIGSTOP); wait_for_stop(child.pid, statfd); } kill(child.pid, SIGWINCH); out_cont: kill(child.pid, SIGCONT); #ifdef __linux__ close(statfd); #endif return err < 0 ? -err : err; }
int attach_child(pid_t pid, const char *pty, int force_stdio) { struct ptrace_child child; unsigned long scratch_page = -1; int *child_tty_fds = NULL, n_fds, child_fd, statfd; int i; int err = 0; long page_size = sysconf(_SC_PAGE_SIZE); char stat_path[PATH_MAX]; long mmap_syscall; if ((err = copy_tty_state(pid, pty))) { if (err == ENOTTY && !force_stdio) { error("Target is not connected to a terminal.\n" " Use -s to force attaching anyways."); return err; } } snprintf(stat_path, sizeof stat_path, "/proc/%d/stat", pid); statfd = open(stat_path, O_RDONLY); if (statfd < 0) { error("Unable to open %s: %s", stat_path, strerror(errno)); return -statfd; } kill(pid, SIGTSTP); wait_for_stop(pid, statfd); if (ptrace_attach_child(&child, pid)) { err = child.error; goto out_cont; } if (ptrace_advance_to_state(&child, ptrace_at_syscall)) { err = child.error; goto out_detach; } if (ptrace_save_regs(&child)) { err = child.error; goto out_detach; } mmap_syscall = ptrace_syscall_numbers(&child)->nr_mmap2; if (mmap_syscall == -1) mmap_syscall = ptrace_syscall_numbers(&child)->nr_mmap; scratch_page = ptrace_remote_syscall(&child, mmap_syscall, 0, page_size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, 0, 0); if (scratch_page > (unsigned long)-1000) { err = -(signed long)scratch_page; goto out_unmap; } debug("Allocated scratch page: %lx", scratch_page); if (force_stdio) { child_tty_fds = malloc(3 * sizeof(int)); if (!child_tty_fds) { err = ENOMEM; goto out_unmap; } n_fds = 3; child_tty_fds[0] = 0; child_tty_fds[1] = 1; child_tty_fds[2] = 2; } else { child_tty_fds = get_child_tty_fds(&child, statfd, &n_fds); if (!child_tty_fds) { err = child.error; goto out_unmap; } } if (ptrace_memcpy_to_child(&child, scratch_page, pty, strlen(pty)+1)) { err = child.error; error("Unable to memcpy the pty path to child."); goto out_free_fds; } child_fd = do_syscall(&child, open, scratch_page, O_RDWR|O_NOCTTY, 0, 0, 0, 0); if (child_fd < 0) { err = child_fd; error("Unable to open the tty in the child."); goto out_free_fds; } debug("Opened the new tty in the child: %d", child_fd); err = ignore_hup(&child, scratch_page); if (err < 0) goto out_close; err = do_syscall(&child, getsid, 0, 0, 0, 0, 0, 0); if (err != child.pid) { debug("Target is not a session leader, attempting to setsid."); err = do_setsid(&child); } else { do_syscall(&child, ioctl, child_tty_fds[0], TIOCNOTTY, 0, 0, 0, 0); } if (err < 0) goto out_close; err = do_syscall(&child, ioctl, child_fd, TIOCSCTTY, 0, 0, 0, 0); if (err < 0) { error("Unable to set controlling terminal."); goto out_close; } debug("Set the controlling tty"); for (i = 0; i < n_fds; i++) do_syscall(&child, dup2, child_fd, child_tty_fds[i], 0, 0, 0, 0); err = 0; out_close: do_syscall(&child, close, child_fd, 0, 0, 0, 0, 0); out_free_fds: free(child_tty_fds); out_unmap: do_unmap(&child, scratch_page, page_size); ptrace_restore_regs(&child); out_detach: ptrace_detach_child(&child); if (err == 0) { kill(child.pid, SIGSTOP); wait_for_stop(child.pid, statfd); } kill(child.pid, SIGWINCH); out_cont: kill(child.pid, SIGCONT); close(statfd); return err < 0 ? -err : err; }
int main(int argc, char **argv, char **envp) { if (argc < 3) { printUsage("Not enough arguments."); return EXIT_SUCCESS; } unsigned long long entrypoint = get_elf_entry(argv[2]); pid_t pid; pid = fork(); if (pid < 0) { printf("Fork failed.\n"); return EXIT_FAILURE; } else if (pid == 0) { /* We are the child. */ ptrace(PTRACE_TRACEME, 0, NULL, NULL); kill(getpid(), SIGSTOP); execve(argv[2], argv+2, envp); /* Apparently the execve causes a SIGTRAP to be sent. */ } else { /* We are the parent. */ /* Wait for execve to finish. */ wait_for_stop(pid); //long ret = 0; //ret = ptrace(PTRACE_ATTACH, pid, 0, 0); //if (ret != 0) { // perror("Failed ptrace() attach."); // exit(EXIT_FAILURE); //} //wait_for_stop(pid); struct user_regs_struct regs; //ptrace(PTRACE_SYSCALL, pid, 0, 0); //wait_for_stop(pid); //long syscall = ptrace(PTRACE_PEEKUSER, pid, sizeof(long)*ORIG_EAX); //printf("EAX: %ld\n", syscall); //ptrace(PTRACE_SYSCALL, pid, 0, 0); //wait_for_stop(pid); //ptrace(PTRACE_GETREGS, pid, NULL, ®s); //printf("EAX: %lx\n", regs.rax); int hit_entrypoint = 0; FILE *output = fopen(argv[1], "w"); if (output == NULL) { perror("Error opening output file."); return EXIT_FAILURE; } while (ptrace(PTRACE_SINGLESTEP, pid, 0, 0) == 0) { wait_for_stop(pid); if (ptrace(PTRACE_GETREGS, pid, NULL, ®s) != 0) { perror("Error getting regs."); } if (regs.rip == entrypoint) { hit_entrypoint = 1; } if (hit_entrypoint) { fprintf(output, "%llx\n", regs.rip); // XXX } } fclose(output); perror("wat"); } return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { uint8_t *tab_rp_bits; uint16_t *tab_rp_registers; uint16_t *rd_position_registers; uint16_t *tab_rp_registers_bad; modbus_t *ctx; /*********************************************************************** * feedback is used to store the return value of every called function * rc is used to store the return value of the modbus command * resend is used to define the resend times if the command is failed * i is used for the loop parameter * insert_bit is used to indicate the calibarate function if there is value to set * num is used to store the number of data blocks in database * use_backend is used to indicate the modbus mode is rtu * next_option is used to take the command options * pre_step, curr_step are used to indicate the previous step number and current position step number * pre_length and value indicate the latest posiotion in database and current position * SLEN is a kind of struct used to store the database blocks ************************************************************************/ int feedback,i; int insert_bit, nb_points,num =0; int next_option; long curr_step; long pystep = -1; double value; double pdepth,pspacing,pdwell,pinterval; double profiled,stopped; double depth,dwell,spacing,interval; double last_position; int profilebit =0,feedback1,feedback2; int modbus=0; int motor_stop = 0; char * command_arg = ""; char * return_value; double in_position = 0; SLEN *examp; ARF *config, *profile,*off_set; modbus_mapping_t *mb_mapping; int ShmID; int *ShmPTR; int stop_indicator = 0; key_t MyKey; MyKey = ftok(".", 's'); ShmID = shmget(MyKey, sizeof(int), IPC_CREAT | 0666); ShmPTR = (int *) shmat(ShmID, NULL, 0); tab_rp_registers = (uint16_t *) malloc(4 * sizeof(uint16_t)); rd_position_registers = (uint16_t *) malloc(2 * sizeof(uint16_t)); tab_rp_registers_bad = (uint16_t *) malloc(2 * sizeof(uint16_t)); config = (ARF*)malloc( 10 * sizeof(ARF) ); if ( config == NULL ) { printf("Error: Out of Memory, use ./master reset to reset memory\n"); exit(1); } const char *const short_options = "hd::u::l:p::cD::w::s::i::gSmt::"; const struct option long_options[] = { { "help", 0,NULL, 'h'}, { "down", 2,NULL, 'd'}, { "up", 2,NULL, 'u'}, { "length", 1,NULL, 'l'}, { "position", 2,NULL, 'p'}, { "count", 0,NULL, 'c'}, { "Depth", 2,NULL, 'D'}, { "well", 2,NULL, 'w'}, { "spacing", 2,NULL, 's'}, { "interval", 2,NULL, 'i'}, { "go", 0,NULL, 'g'}, { "System", 0,NULL, 'S'}, { "motor", 0,NULL, 'm'}, { "time", 2,NULL, 't'}, { NULL, 0, NULL, 0 }, }; if (argc < 2) { print_comusage (stderr, 1); return_value = json_option("status:",-1); return return_value; } program_name = argv[0]; /*Get the first argument that passed through main function but does not contain*/ command_name = argv[1]; if(argc > 2) { command_arg = argv[2]; } /******************************************************************************************* * The next three command_name are used to control the motor through modbus (need modbus) * ********************************************************************************************/ if ( strcmp(command_name, "go") == 0 ) { double curr_position; char *recd = (char*)malloc(10*sizeof(char)); double offset; int re_send = 0; *ShmPTR = 0; modbus = 0; next_option = getopt_long (argc, argv, short_options, long_options, NULL); if (next_option == -1) print_comusage (stderr, 1); while (next_option != -1) { switch (next_option) { case 'h': print_comusage(stdout, 0); case 'd': godown: enable(0); initbus(1); /* sleep(1); ctx = modbusconnection(ctx); modbus = 1; feedback = godown(ctx); if((feedback == -1)&&(re_send <1)) { enable(0); initbus(0); re_send++; goto godown; } return_value = json_option("status",feedback); printf("%s\n",return_value); */ feedback = process_go_down(1); if((feedback == 0) && (re_send < 1)) { printf("get false recycle power\n"); enable(0); initbus(0); re_send++; goto godown; } return_value = json_option("status",feedback); printf("%s\n",return_value); break; case 'u': goup: enable(0); initbus(1); /* sleep(1); ctx = modbusconnection(ctx); modbus = 1; feedback = goup(ctx); if((feedback == -1)&&(re_send <1)) { enable(0); initbus(0); re_send++; goto goup; } */ feedback = process_go_up(1); if((feedback == 0) && (re_send < 1)) { printf("Get false recycle power\n"); enable(0); initbus(0); re_send++; goto goup; } return_value = json_option("status",feedback); printf("%s\n",return_value); break; case 'p': enable(0); initbus(1); sleep(1); ctx = modbusconnection(ctx); modbus = 1; in_position = atof(optarg); off_set = (ARF*)malloc(15*sizeof(ARF)); off_set = getconfig(&num,off_set); offset = off_set[10].value; in_position = in_position - offset; //printf("inposition is %f offset is %f\n",in_position,offset); free(off_set); //system("/home/sampler/kingkong.sh"); gotoposition: if (in_position <= 0) { if( process_read_home_switch(1) == 0) { feedback = process_go_home(1); } else feedback = 1; } else { pystep = process_read_step(1); curr_position = process_position(pystep); if ( !(( (in_position -0.1) <= curr_position ) && ( curr_position <= (in_position + 0.1) )) ) { feedback = process_go_position(1,in_position); return_value = json_option("status",feedback); } } if((feedback == 0)&&(re_send <1)) { printf("get false recycle power"); enable(0); initbus(0); enable(0); initbus(1); re_send++; goto gotoposition; } break; case '?': print_comusage (stderr, 1); default: abort (); } next_option = getopt_long (argc, argv, short_options, long_options, NULL); } //If the go command is failed, then exit the current process and power off the controller if(feedback == 0) { printf("1\n"); //*ShmPTR = 1; enable(0); initbus(0); return_value = json_option("status",-1); return return_value; } do{ usleep(5000); stop_indicator = process_check(1); }while(stop_indicator != 0); //printf("stop\n"); sleep(1); pystep = process_read_step(1); curr_position = process_position(pystep); //printf("cur position is %f\n",curr_position); if(curr_position != -1) { login("Go to command set last position"); curr_position = curr_position + offset; setconfig(9,curr_position); // In order to avoid "Read status command shutdown the power by accident enable(0); initbus(0); return_value = json_option("status",1); } else return_value = json_option("status",-1); } if ( strcmp(command_name, "stop") == 0 ) { if(check_power() == 1) { /*sleep(1); ctx = modbusconnection(ctx); modbus = 1; feedback = stop(ctx); if(feedback == -1)stop(ctx); */ process_stop(1); } } if ( strcmp(command_name, "position") == 0 ) { login("Check position command"); int resend = 0; double temp_position,offset; char *rec = (char*)malloc(10*sizeof(char)); stop_indicator = *ShmPTR; uint16_t * position_registers = (uint16_t *) malloc(2 * sizeof(uint16_t)); off_set = (ARF*)malloc(15*sizeof(ARF)); off_set = getconfig(&num,off_set); offset = off_set[10].value; checkposition: if (check_power()== 1) { ctx = modbusconnection(ctx); modbus = 1; temp_position = checkposition(ctx,position_registers); sprintf(rec,"The position read is %f",temp_position); login(rec); if(temp_position != -1) { login("Check position set last position"); //This sentence is used to show the position with offset temp_position = temp_position + offset; feedback = setconfig(9,temp_position); } else { if(resend < 2) { resend++; goto checkposition; } else return -100; } } else { config = getconfig(&num,config); temp_position = config[8].value; } return_value = json_float_option("status",temp_position); printf("%s\n",return_value); } /*********************************************************************** * 0: motor is stopped * * 1: motor is going down * * 2: motor is going up * * 3: motor is ramp up * * 4: motor is ramp down * * (need modbus) * * * ************************************************************************/ if(strcmp(command_name, "status") == 0) { stop_indicator = *ShmPTR; if (check_power()== 1) { sleep(1); ctx = modbusconnection(ctx); modbus = 1; next_option = getopt_long (argc, argv, short_options, long_options, NULL); if(next_option == -1) print_comusage (stderr, 1); while(next_option != -1) { switch (next_option) { case 'h': print_comusage(stdout, 0); case 'S': feedback = checksystemstatus(ctx,tab_rp_registers); return_value = json_option("status",feedback); break; case 'm': feedback = checkmotorstatus(ctx,tab_rp_registers); return_value = json_option("status",feedback); break; case '?': print_comusage (stderr, 1); default: abort (); } next_option = getopt_long (argc, argv, short_options, long_options, NULL); } if(feedback == -1) { return_value = json_option("status",0); } } else { return_value = json_option("status",0); //login("Check status from database"); } printf("%s\n",return_value); } /**************************************************************************************** * The next three command_name are used to control the database through sqlite3 * *****************************************************************************************/ if ( strcmp(command_name, "factory_default") == 0 ) { feedback1 = reset(0); feedback2 = dbinit(0); if ( (feedback1 == 1) && (feedback2 == 1)) { return_value = json_float_option("status",1); printf("%s\n",return_value); } else { return_value = json_float_option("status",-1); printf("%s\n",return_value); } } if ( strcmp(command_name, "reset") == 0 ) { feedback = reset(0); if(feedback == 1) { feedback = expected_time_reset(); } return_value = json_float_option("status",feedback); printf("%s\n",return_value); } if ( strcmp(command_name, "init") == 0 ) { feedback = -1; if ( strcmp(command_arg, "all") == 0 ) { feedback = dbinit(0); if(feedback == 1) { feedback = expected_time_init(); } } if ( strcmp(command_arg, "calibrate" ) == 0 ) { setconfig(6,0); feedback = dbinit(1); } if ( strcmp(command_arg, "configure" ) == 0 ) { feedback = dbinit(2); } if ( feedback == -1 ) { return_value = json_float_option("status",-1); print_comusage (stderr, 1); } else return_value = json_float_option("status",feedback); printf("%s\n",return_value); } if ( strcmp(command_name,"get") == 0 ) { examp = getall(&num,examp); return_value = json_array_option(num,examp); free(examp); printf("%s",return_value); } if ( strcmp(command_name,"set_offset") == 0 ) { double offset; next_option = getopt_long (argc, argv, short_options, long_options, NULL); if ( next_option == -1 ) print_comusage (stderr, 1); while( next_option != -1 ) { switch (next_option) { case 'h': print_comusage(stdout, 0); case 'l': if(optarg!=0)offset = strtod(optarg,NULL); insert_bit = 1; break; case '?': print_comusage (stderr, 1); default: abort (); } next_option = getopt_long (argc, argv, short_options, long_options, NULL); } feedback = setconfig(11,offset); return_value = json_option("status",feedback); printf("%s",return_value); } if ( strcmp(command_name,"get_offset") == 0 ) { double offset; off_set = (ARF*)malloc(15*sizeof(ARF)); off_set = getconfig(&num,off_set); offset = off_set[10].value; return_value = json_float_option("status",offset); printf("%s",return_value); free(off_set); } /************************************************************************** * The next three command_name are used to calibrate (need modbus) * ***************************************************************************/ if ( strcmp(command_name, "calibrate") == 0 ) { double calibrate; enable(0); initbus(1); sleep(1); ctx = modbusconnection(ctx); modbus = 1; next_option = getopt_long (argc, argv, short_options, long_options, NULL); if ( next_option == -1 ) print_comusage (stderr, 1); config = getconfig(&num,config); calibrate = config[5].value; if ( calibrate == 0 ) { reset(1); setconfig(6,1.0); set(num,0,0); } while( next_option != -1 ) { switch (next_option) { case 'h': print_comusage(stdout, 0); case 'l': if(optarg!=0)value = atof(optarg); insert_bit = 1; break; case 'c': getall(&num,examp); return_value = json_option("status",num); printf("%s\n",return_value); break; case '?': print_comusage (stderr, 1); default: abort (); } next_option = getopt_long (argc, argv, short_options, long_options, NULL); } if ( insert_bit == 1 ) { curr_step = checksteps(ctx,rd_position_registers); if ( curr_step < 0 ) curr_step =0;//do not need feedback = checkvalue(curr_step,value); if ( feedback == 1 ) { feedback = set(num,curr_step,value); return_value = json_option("status",feedback); } else { return_value = json_option("status",-1); } } /*if ( checkmotorstatus(ctx,tab_rp_registers) == 0 ) { enable(0); initbus(0); }*/ printf("%s\n",return_value); } /*********************************************************************** * The following functions are used for profile * * * ************************************************************************/ if ( strcmp(command_name, "profile") == 0 ) { next_option = getopt_long (argc, argv, short_options, long_options, NULL); if ( next_option == -1 ) print_comusage (stderr, 1); while ( next_option != -1 ) { switch (next_option) { case 'h': print_comusage(stdout, 0); case 'd': if(optarg!=0)depth = atof(optarg); profilebit = 1; break; case 's': if(optarg!=0)spacing = atof(optarg); profilebit = 1; break; case 'w': if(optarg!=0)dwell = atof(optarg); profilebit = 1; break; case 'i': //if(optarg!=0)interval = atof(optarg); if(optarg!=0)interval = strtod(optarg,NULL); profilebit = 1; break; case '?': print_comusage (stderr, 1); default: abort (); } next_option = getopt_long (argc, argv, short_options, long_options, NULL); } if ( profilebit == 1 ) { feedback = set_profile(depth,spacing,dwell,interval); } //Want to get the expected profile time and save it in database profile_time_check(interval); return_value = json_float_option("status",feedback); printf("%s\n",return_value); } if ( strcmp(command_name, "profileget" ) == 0) { profile = getconfig(&num,config); return_value = json_profile_option(num-2,profile); free(profile); printf("%s",return_value); } if ( strcmp(command_name, "profile_check" ) == 0) { int *expected_profile_time; long remain_profile_time; config = getconfig(&num,config); pinterval = config[3].value; if(pinterval == 0) { printf("-999\n"); return -999; } expected_profile_time = (int*)malloc(10*sizeof(int)); if(expected_profile_time == NULL){printf("error\n");exit(1);} expected_time_get(expected_profile_time); remain_profile_time = auto_run(0,expected_profile_time); if(remain_profile_time <=0 )remain_profile_time = 0; printf("%d\n",remain_profile_time); free(expected_profile_time); return remain_profile_time; } if ( strcmp(command_name, "profile_reset") == 0 ) { //feedback = dbinit(2); //reading_hourly(); system("ps aux | grep -e 'master profilego' | grep -v grep | awk '{print $2}' | xargs -i kill {}"); feedback = set_profile(0,0,0,0); return_value = json_float_option("status",feedback); printf("%s\n",return_value); } if ( strcmp(command_name, "profilego") == 0 ) { double stayposition, curr_position,tmp,cal_position; double sdl_read,offset; long wait_time,motor_status; int year; time_t fail_time; int stop_check = -1; int count,fini_count,re_try1 = 0,re_power1 =0,re_try = 0,re_send=0; int i=1,sample = 0,profile_times,sample_indicator; int * expected_tm, *curr_time,inter_val; setconfig(10,0); profile: /* The following eight lines are used to get profile arguments from database */ config = getconfig(&num,config); pdepth = config[0].value; pspacing = config[1].value; pdwell = config[2].value; pinterval = config[3].value; profiled = config[4].value; sample = config[9].value; offset = config[10].value; profile_times = 1+(pdepth - offset)/pspacing; // Caculate the profile times inter_val = (int)pinterval; if(pinterval == 0){schedule_reading();goto profile;} if(profiled == 0 ) { config = getconfig(&num,config); pdepth = config[0].value; pspacing = config[1].value; pdwell = config[2].value; pinterval = config[3].value; profiled = config[4].value; sample = config[9].value; /* The following part are used to get the expected profile time and compare with current time */ expected_tm = (int*)malloc(10*sizeof(int)); curr_time = (int*)malloc(10*sizeof(int)); if(curr_time == NULL){printf("error\n");exit(1);} if(expected_tm == NULL){printf("error\n");exit(1);} do{ config = getconfig(&num,config); sample = config[9].value; expected_time_get(expected_tm); wait_time= auto_run(0,expected_tm); curr_time = check_time(curr_time); sample_indicator = curr_time[3]%inter_val; printf("Wait for next profile\n"); //because the board will boot up 3 minutes after clock time if(wait_time < -600) { profile_time_check(pinterval); goto profile; } sleep(1); }while(wait_time>0); free(expected_tm); four_minute_delay: sleep(1); curr_time = check_time(curr_time); if((curr_time[4]>=4) &&(curr_time[4]<=10))goto start_profile; if(curr_time[4]<4)goto four_minute_delay; if(curr_time[4]>10)goto profile; } start_profile: enable(0); initbus(1); sleep(1); ctx = modbusconnection(ctx); if(ctx == NULL)goto profile; modbus = 1; sleep(9); if ( profiled == 0 ) { if (process_syncclock() == 0) { login("Failed in connectting with SDL"); return; } if (process_expression(3,1,profile_times,0) == 0) { login("Failed in send profile to SDL"); return; } login("Start Profiling"); if( process_read_home_switch(1) == 0) { gotoposition(ctx, 0,rd_position_registers); //Do not need to check if it is home because we want it home anyway do{ usleep(5000); stop_check = process_check(1); }while(stop_check != 0); if(process_pass_through_check() == 0)initbus(0); setconfig(5,1); //Set the profile flag sleep(pdwell); } else { setconfig(5,1); sleep(pdwell); } } enable(0); initbus(1); sleep(1); ctx = modbusconnection(ctx); /* This following part is used to determine where is destination */ curr_position = checkposition(ctx,tab_rp_registers) + offset; cal_position = i*pspacing + offset; if ( cal_position < pdepth ) { stayposition = cal_position; } else stayposition = pdepth; i++; stayposition = stayposition - offset; gotoposition(ctx,stayposition,tab_rp_registers); position1: sleep(1); ctx = modbusconnection(ctx); curr_position = checkposition(ctx,tab_rp_registers) + offset; if(curr_position == -1) { if(re_power1 < 3) { if(re_try1 < 2) { sleep(3); re_try1++; goto position1; } else { re_try1 = 0; enable(0); initbus(0); sleep(3); initbus(1); sleep(1); re_power1++; goto position1; } } else { enable(0); initbus(0); enable(1); re_power1 = 0; return -1; } } if (!((stayposition -0.1) <= curr_position ) && (curr_position <= (stayposition + 0.1)))goto position1; wait_for_stop(ctx, tab_rp_registers); //Here check position in order to determine if it is destination now curr_position = checkposition(ctx,tab_rp_registers)+offset; setconfig(9,curr_position); printf("Go to sleep for dwell time\n"); if(process_pass_through_check() == 0)initbus(0); // Add this part to check if it is passing command sleep(pdwell); if (((pdepth -0.1) <= curr_position) && (curr_position <= (pdepth + 0.1))) { setconfig(5,0); //Set profile flag here to avoid reprofile if something wrong happens during following profile_time_check(pinterval); // Set next profile time enable(0); initbus(1); ctx = modbusconnection(ctx); gotoposition(ctx,0,rd_position_registers); // After finish profile, go home wait_for_stop(ctx, tab_rp_registers); sleep(1); enable(0); if(process_pass_through_check() == 0) initbus(0); //Check is pass through enable(1); setconfig(9,offset); //Save the position 0 sleep(40); goto profile; } goto profile; } /*********************************************************************** * The next three command_name are used * * to control the date and time * ************************************************************************/ if ( strcmp(command_name, "checktime") == 0 ) { /* char *sdate; if ( (sdate = malloc( 80 * sizeof(char) ) )== NULL)return NULL; sdate = current_time(sdate); return_value = json_option_string("status",sdate); printf("%s\n",return_value); free(sdate); */ //long pystep = process_read_step(1); //process_position(pystep); //process_expression(3,1,3,1); //process_pass_through_check(); //process_syncclock(); process_expression(3,1,3,0); process_read_home_switch(1); } if ( strcmp(command_name, "settime") == 0 ) { if ( argc < 4 ) { print_comusage (stderr, 1); } char *date = argv[2]; char *time = argv[3]; int *buf = (int*)malloc(6*sizeof(int)); parse(buf,date,time); int i,m_buf[6]; for(i=0;i<=5;i++) { m_buf[i]=*(buf+i); } feedback = set_time(&m_buf); return_value = json_option("status:",feedback); printf("%s\n",return_value); login("Set local time"); login(return_value); sleep(5); } if ( strcmp(command_name, "voltage") == 0 ) { double voltage; voltage = voltage_read(); return_value = json_float_option("status",voltage); printf("%s\n",return_value); } if ( strcmp(command_name, "temp") == 0 ) { double temp; temp = temp_read(); return_value = json_float_option("status",temp); printf("%s\n",return_value); } if(strcmp(command_name, "enable_power") == 0) { enable(0); initbus(1); return_value = json_option("status:",1); } if(strcmp(command_name, "disable_power") == 0) { enable(0); initbus(0); return_value = json_option("status:",1); } if ( strcmp(command_name, "backup") == 0 ) { feedback = system("cp /home/sampler/lr.sl3 /home/sampler/lr_default.sl3"); if(feedback == -1) { return_value = json_float_option("status",-1); } else return_value = json_float_option("status",1); printf("%s\n",return_value); } if ( strcmp(command_name, "restore") == 0 ) { feedback = system("cp /home/sampler/lr_default.sl3 /home/sampler/lr.sl3"); if(feedback == -1) { return_value = json_float_option("status",-1); } else return_value = json_float_option("status",1); printf("%s\n",return_value); } if ( strcmp(command_name, "debug") == 0 ) { long return_steps; char *debug_result; enable(0); initbus(1); sleep(1); ctx = modbusconnection(ctx); modbus = 1; uint16_t *debug_position_registers = (uint16_t*)malloc(2*sizeof(uint16_t)); debug_result = (char*)malloc(50*sizeof(char)); return_steps = checksteps(ctx,debug_position_registers); sprintf(debug_result,"%x,%x,%x\n",debug_position_registers[0],debug_position_registers[1],return_steps); json_option_string("status",debug_result); printf("%s\n",debug_result); initbus(0); } if ( strcmp(command_name, "power_check") == 0 ) { int power_status = check_power(); printf("Power is %d\n",power_status); } if ( strcmp(command_name, "sdl") == 0 ) { modbus_t * sdl; sdl = sdl_connection(sdl); if(sdl != NULL) { double vol = sdltest(sdl); return_value = json_float_option("status",vol); printf("%s\n",return_value); setsdl(30000,vol); login("Read SDL"); login(return_value); } else setsdl(30000,-100000); modbus_close(sdl); modbus_free(sdl); } if ( strcmp(command_name, "sdl_reset") == 0 ) { resetsdl(); } if ( strcmp(command_name, "sdl_get") == 0 ) { int num_records; SLEN * sdl_records; sdl_records = (SLEN*)malloc(100*sizeof(SLEN)); sdl_records = getsdl(&num_records, sdl_records); return_value = json_sdl_option(num_records,sdl_records); printf("%s\n",return_value); free(sdl_records); } if ( strcmp(command_name, "sdl_uploadtime") == 0 ) { modbus_t * sdl; sdl = sdl_connection(sdl); if(sdl == NULL) { setsdl(30000,-100000); } else sdl_setuploadtime(sdl,12,5,21,12,50,0); } if ( strcmp(command_name, "sdl_settime") == 0 ) { modbus_t * sdl; sdl = sdl_connection(sdl); if(sdl == NULL) { setsdl(30000,-100000); } else sdl_rtc_time(sdl,12,5,25,7,58,0); } if ( strcmp(command_name, "sdl_readsize") == 0 ) { modbus_t * sdl; sdl = sdl_connection(sdl); if(sdl == NULL) { setsdl(30000,-100000); } else sdl_readbuffsize(sdl); } if ( strcmp(command_name, "sdl_readsensor") == 0 ) { modbus_t * sdl; sdl = sdl_connection(sdl); if(sdl == NULL) { setsdl(30000,-100000); } else sdl_read_sensor(sdl,1,1); } if ( strcmp(command_name, "sdl_upload") == 0 ) { //sdl_read_log_data(16); int number; modbus_t * sdl; sdl = sdl_connection(sdl); if(sdl == NULL) { setsdl(30000,-100000); } else { profile_save_data(sdl); } modbus_close(sdl); } if ( strcmp(command_name, "sdl_sample") == 0 ) { int number; modbus_t * sdl; sdl = sdl_connection(sdl); if(sdl == NULL) { setsdl(30000,-100000); } else { sdl_read_sensor(sdl,1,1); sleep(60); sample_save_data(sdl); //sdl_start_profile(sdl,2); } modbus_close(sdl); } if ( strcmp(command_name, "shutdown") == 0 ) { feedback = system("/sbin/shutdown now"); } if ( strcmp(command_name, "maxstep") == 0 ) { enable(0); initbus(1); sleep(1); ctx = modbusconnection(ctx); modbus = 1; feedback = set_max_step(ctx,rd_position_registers); return_value = json_option("status",feedback); initbus(0); } if(strcmp(command_name, "slave") == 0) { slave(); } if(strcmp(command_name, "motor_status") == 0) { if (check_power()== 1) { sleep(1); ctx = modbusconnection(ctx); modbus = 1; feedback = checkmotorstatus(ctx,tab_rp_registers); if(feedback == -1) { printf("0\n"); return 0; } else { printf("%d\n",feedback); return feedback; } } else { printf("0\n"); return 0; } } close: /* Free the memory */ free(config); free(tab_rp_registers); free(rd_position_registers); //modbus_mapping_free(mb_mapping); /* Close the connection */ if (modbus == 1) { modbus_close(ctx); } if (motor_stop == 1) { printf("stop setting\n"); setconfig(9,last_position); } return return_value; }
int main(int argc, char *argv[]) { mi_bkpt *bk; /* This is like a file-handle for fopen. Here we have all the state of gdb "connection". */ mi_h *h; /* You can use any gdb you want: */ /*mi_set_gdb_exe("/usr/src/gdb-6.1.1/gdb/gdb");*/ /* You can use a terminal different than xterm: */ /*mi_set_xterm_exe("/usr/bin/Eterm");*/ /* Connect to gdb child. */ h=mi_connect_local(); if (!h) { printf("Connect failed\n"); return 1; } printf("Connected to gdb!\n"); /* Set all callbacks. */ mi_set_console_cb(h,cb_console,NULL); mi_set_target_cb(h,cb_target,NULL); mi_set_log_cb(h,cb_log,NULL); mi_set_async_cb(h,cb_async,NULL); mi_set_to_gdb_cb(h,cb_to,NULL); mi_set_from_gdb_cb(h,cb_from,NULL); /* Tell gdb to load symbols from the local copy. */ if (!gmi_file_symbol_file(h,"./test_target")) { printf("Error loading symbols\n"); mi_disconnect(h); return 1; } /* Connect to remote machine using TCP/IP. */ if (!gmi_target_select(h,"extended-remote",REMOTE_MACHINE)) { printf("Error connecting to gdb server\n"); mi_disconnect(h); return 1; } /* Set a breakpoint. */ bk=gmi_break_insert(h,"test_target.cc",12); if (!bk) { printf("Error setting breakpoint\n"); mi_disconnect(h); return 1; } printf("Breakpoint %d @ function: %s\n",bk->number,bk->func); /* You can do things like: gmi_break_delete(h,bk->number); gmi_break_set_times(h,bk->number,2); gmi_break_set_condition(h,bk->number,"1"); gmi_break_state(h,bk->number,0);*/ /* If we no longer need this data we can release it. */ mi_free_bkpt(bk); /* Run the program. */ /* Note that remote targets starts running and we must use continue! */ if (!gmi_exec_continue(h)) { printf("Error in continue!\n"); mi_disconnect(h); return 1; } /* Here we should be stopped at the breakpoint. */ if (!wait_for_stop(h)) { mi_disconnect(h); return 1; } /* Continue execution. */ if (!gmi_exec_continue(h)) { printf("Error in continue!\n"); mi_disconnect(h); return 1; } /* Here we should be terminated. */ if (!wait_for_stop(h)) { mi_disconnect(h); return 1; } /* Exit from gdb. */ gmi_gdb_exit(h); /* Close the connection. */ mi_disconnect(h); return 0; }