bool debug_ask(Machine *pmach){
	char input[NMAX];
	while(1){
		printf("DEBUG? ");
		gets(input);
		if(strcmp(input,"h")==0){
			printf("h\thelp\n");
			printf("c\tcontinue(exit interactive debug mode)\n");
			printf("s\tstep by step(next instruction)\n");
			printf("RET\tstep by step(next instruction)\n");
			printf("r\tprint registers\n");
			printf("d\tprint data memory\n");
			printf("t\tprint text(program) memory\n");
			printf("p\tprint text(program) memory\n");
			printf("m\tprint registers and data memory\n");	
		}
		if(strcmp(input,"c")==0)
			return false;
		if(strcmp(input,"r")==0)
			print_cpu(pmach);
		if(strcmp(input,"RET")==0 || strcmp(input,"s")==0 || strcmp(input,"\0")==0)
			return true;
		if(strcmp(input,"d")==0)
			print_data(pmach);
		if(strcmp(input,"t")==0)
			print_program(pmach);
		if(strcmp(input,"p")==0)
			print_program(pmach);
		if(strcmp(input,"m")==0){
			print_cpu(pmach);
			print_data(pmach);
		}
	}
		return true;
}

void cpu_print_filter(pid_t pid) {
	EUID_ASSERT();
	
	// if the pid is that of a firejail  process, use the pid of the first child process
	EUID_ROOT();	// grsecurity
	char *comm = pid_proc_comm(pid);
	EUID_USER();	// grsecurity
	if (comm) {
		if (strcmp(comm, "firejail") == 0) {
			pid_t child;
			if (find_child(pid, &child) == 0) {
				pid = child;
			}
		}
		free(comm);
	}

	// check privileges for non-root users
	uid_t uid = getuid();
	if (uid != 0) {
		uid_t sandbox_uid = pid_get_uid(pid);
		if (uid != sandbox_uid) {
			fprintf(stderr, "Error: permission denied.\n");
			exit(1);
		}
	}

	print_cpu(pid);
	exit(0);
}

static int sched_debug_show(struct seq_file *m, void *v)
{
	u64 now = ktime_to_ns(ktime_get());
	int cpu;

	SEQ_printf(m, "Sched Debug Version: v0.09, %s %.*s\n",
		init_utsname()->release,
		(int)strcspn(init_utsname()->version, " "),
		init_utsname()->version);

	SEQ_printf(m, "now at %Lu.%06ld msecs\n", SPLIT_NS(now));

#define P(x) \
	SEQ_printf(m, "  .%-40s: %Ld\n", #x, (long long)(x))
#define PN(x) \
	SEQ_printf(m, "  .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
	P(jiffies);
	PN(sysctl_sched_latency);
	PN(sysctl_sched_min_granularity);
	PN(sysctl_sched_wakeup_granularity);
	PN(sysctl_sched_child_runs_first);
	P(sysctl_sched_features);
#undef PN
#undef P

	for_each_online_cpu(cpu)
		print_cpu(m, cpu);

	SEQ_printf(m, "\n");

	return 0;
}

int main(int argc, char** argv)
{
    printf(PIPEMENU_BEGIN);
    print_cpu(0, count_cpus());
    printf(PIPEMENU_END);
    return 0;
}

static int sched_debug_show(struct seq_file *m, void *v)
{
	u64 ktime, sched_clk, cpu_clk;
	unsigned long flags;
	int cpu;

	local_irq_save(flags);
	ktime = ktime_to_ns(ktime_get());
	sched_clk = sched_clock();
	cpu_clk = local_clock();
	local_irq_restore(flags);

	SEQ_printf(m, "Sched Debug Version: v0.10, %s %.*s\n",
		init_utsname()->release,
		(int)strcspn(init_utsname()->version, " "),
		init_utsname()->version);

#define P(x) \
	SEQ_printf(m, "%-40s: %Ld\n", #x, (long long)(x))
#define PN(x) \
	SEQ_printf(m, "%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
	PN(ktime);
	PN(sched_clk);
	PN(cpu_clk);
	P(jiffies);
#ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
	P(sched_clock_stable);
#endif
#undef PN
#undef P

	SEQ_printf(m, "\n");
	SEQ_printf(m, "sysctl_sched\n");

#define P(x) \
	SEQ_printf(m, "  .%-40s: %Ld\n", #x, (long long)(x))
#define PN(x) \
	SEQ_printf(m, "  .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
	PN(sysctl_sched_latency);
	PN(sysctl_sched_min_granularity);
	PN(sysctl_sched_wakeup_granularity);
	P(sysctl_sched_child_runs_first);
	P(sysctl_sched_features);
#undef PN
#undef P

	SEQ_printf(m, "  .%-40s: %d (%s)\n", "sysctl_sched_tunable_scaling",
		sysctl_sched_tunable_scaling,
		sched_tunable_scaling_names[sysctl_sched_tunable_scaling]);

	read_lock_irqsave(&tasklist_lock, flags);
	//for_each_online_cpu(cpu)
	for_each_possible_cpu(cpu)
		print_cpu(m, cpu);
	read_unlock_irqrestore(&tasklist_lock, flags);
	SEQ_printf(m, "\n");

	return 0;
}

void sysrq_sched_debug_show(void)
{
	int cpu;

	sched_debug_header(NULL);
	for_each_online_cpu(cpu)
		print_cpu(NULL, cpu);

}

int registers_cmd(struct _6510_cpu* cpu, char memory[][9], char* string){
  char regname[5] = "1234";
  char buffer_reg[8+1] = "00000000";
  int key, content=-1;
  int i;
  // mon> mem af 02 ; mam[af] <- 02
  sscanf(string, " %*s %s %2x ", &(regname[0]), &content);

  key = -1;
  for(i=0;names[i]!=NULL;i++){
	if(strcmp(regname,names[i])==0){
	  key=i;
	  break;
	}
  }
  if(content!=-1){
	int2register(content, buffer_reg);
	switch(key)
	  {
	  case ACC:
		cp_register(buffer_reg, cpu->rega);
		break;
	  case ABRL:
		cp_register(buffer_reg, cpu->abrl);
		break;
	  case ABRH:
		cp_register(buffer_reg, cpu->abrh);
		break;
	  case DBR:
		cp_register(buffer_reg, cpu->dbr);
		break;
	  case IDX:
		cp_register(buffer_reg, cpu->regx);
		break;
	  case IDY:
		cp_register(buffer_reg, cpu->regy);
		break;
	  case PCL:
		cp_register(buffer_reg, cpu->pcl);
		break;
	  case PCH:
		cp_register(buffer_reg, cpu->pch);
		break;
	  case IR:
		cp_register(buffer_reg, cpu->ir);
		break;
	  case SP:
		cp_register(buffer_reg, cpu->sp);
		break;
	  default:
		break;
	  }
  }
  print_cpu(cpu);
  return 1;
}

/*!
 * Cette fonction gère le dialogue pour l'option \c -d (debug). Dans ce mode,
 * elle est invoquée après l'exécution de chaque instruction.  Elle affiche le
 * menu de mise au point et on exécute le choix de l'utilisateur. Si cette
 * fonction retourne faux, on abandonne le mode de mise au point interactive
 * pour les instructions suivantes et jusqu'à la fin du programme.
 * 
 * \param mach la machine/programme en cours de simulation
 * \return vrai si l'on doit continuer en mode debug, faux sinon
 */
bool debug_ask(Machine *pmach){
	printf("DEBUG? ");
	char commande = '\n';
	bool premier = true;
	char rep;
	while( (rep=getchar()) != '\n' && rep != EOF){
		if(premier) commande = rep;
		premier = false;
	};
	switch(commande){
	  case 'h':
		printf("Available commands :\n\th\thelp\n\tc\tcontinue (exit interactive debug mode)\n\ts\tstep by step (next instruction)\n\tRET\tstep by step (next instruction)\n\tr\tprint registers\n\td\tprint data memory\n\tt\tprint text (program) memory\n\tp\tprint text (program) memory\n\tm\tprint registers and data memory\n");
          break;
	  case 'c':
		return false;
	  break;
          case 's':
		return true;
          break;
	  case 'r':
		print_cpu(pmach);
          break;
          case 'd':
		print_data(pmach);
          break;
          case 't':
		print_program(pmach);
          break;
	  case 'p':
		print_program(pmach);
          break;
	  case 'm':
		print_cpu(pmach);
		print_data(pmach);
          break;
	  case '\n':
		return true;
	  break;
	  default:
          break;
	}
	return debug_ask(pmach);
}

static int sched_debug_show(struct seq_file *m, void *v)
{
	int cpu = (unsigned long)(v - 2);

	if (cpu != -1)
		print_cpu(m, cpu);
	else
		sched_debug_header(m);

	return 0;
}

int main(void) {
    FILE *fp_mail;
    char *status = (char *)alloca(200);
    int b, d, m;
    b = BATTERY_INTERVAL;
    d = DATE_INTERVAL;
    m = MAIL_INTERVAL;

    struct timespec interval = {
        .tv_sec  = UPDATE_INTERVAL,
        .tv_nsec = 0 };
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    for ( ; ; nanosleep(&interval, NULL)) {
        if (++b > BATTERY_INTERVAL) {
            print_battery();
            b = 0; }
        if (++d > DATE_INTERVAL) {
            print_time();
            d = 0; }
        if (++m > MAIL_INTERVAL) {
            if (print_mail(fp_mail) == 0) {
                m = 0; }
            if (errno == EBADF) {
                fp_mail = mail_init(); } }
        if (sockfd != -1) {
            print_iw(sockfd); }
        strncpy(_root, print_free("/"), _FREE_LEN);
        strncpy(_home, print_free("/home"), _FREE_LEN);
        print_time();
        print_cpu();
        print_memory();
        snprintf(status, 200, "%s %s | %s | %s | %s | %s | %s | %s"
                            , _root, _home, _iw, _battery, _mail, _cpu
                            , _mem, _date);
        printf("%s\n", status);

        }//break; }

    pclose(fp_mail);
    cleanup(sockfd); }

double get_battery_stats(const char *path) {
    FILE *stats;
    double value = 0;

    if ((stats = fopen(path, "r"))== NULL) {
        return -1; }
    fscanf(stats, "%lf", &value);
    fclose(stats);

    return value; }

void *load_check(void *param)
{	
	//int n=(int)param;
	cpu_t cpu1, cpu2;
    	while(1) 
	{
    		cpu_t *p_cpu1 = cpu_check(&cpu1);
        	sleep(1);
        	cpu_t *p_cpu2 = cpu_check(&cpu2);
        	print_cpu(p_cpu1, p_cpu2);
    	}
	pthread_exit(0);
}

void Summary::print()
{
    print_versions();
    print_memory();
    print_cpu();
    print_threads();
    print_pools();

#   ifndef XMRIG_NO_API
    print_api();
#   endif

    print_commands();
}

static int timer_list_show(struct seq_file *m, void *v)
{
	struct timer_list_iter *iter = v;

	if (iter->cpu == -1 && !iter->second_pass)
		timer_list_header(m, iter->now);
	else if (!iter->second_pass)
		print_cpu(m, iter->cpu, iter->now);
#ifdef CONFIG_GENERIC_CLOCKEVENTS
	else if (iter->cpu == -1 && iter->second_pass)
		timer_list_show_tickdevices_header(m);
	else
		print_tickdevice(m, tick_get_device(iter->cpu), iter->cpu);
#endif
	return 0;
}

void cpu(pid_t pid) {
	if (getuid() == 0)
		firemon_drop_privs();
	
	pid_read(pid);
	
	// print processes
	int i;
	for (i = 0; i < max_pids; i++) {
		if (pids[i].level == 1) {
			pid_print_list(i, 0);
			int child = find_child(i);
			if (child != -1)
				print_cpu(child);
		}
	}
}

int		print_hub(t_taupe *taupe)
{
  wclear(taupe->top->win);
  print_sys(taupe->sys, taupe->top);
  print_task(taupe->task, taupe->top);
  print_cpu(taupe->cpu, taupe->top);
  print_mem(taupe->mem, taupe->top);
  if (taupe->signal->on)
    {
      print_opt(taupe->signal, "Send Signal");
      print_signal(taupe->signal, taupe->pid);
    }
  else if (taupe->sort->on)
    print_opt(taupe->sort, "Sort By");
  print_main(taupe);
  return (0);
}

void sysrq_timer_list_show(void)
{
	u64 now = ktime_to_ns(ktime_get());
	int cpu;

	timer_list_header(NULL, now);

	for_each_online_cpu(cpu)
		print_cpu(NULL, cpu, now);

#ifdef CONFIG_GENERIC_CLOCKEVENTS
	timer_list_show_tickdevices_header(NULL);
	for_each_online_cpu(cpu)
		print_tickdevice(NULL, tick_get_device(cpu), cpu);
#endif
	return;
}

void cpu(void) {
	if (getuid() == 0)
		firemon_drop_privs();
	
	pid_read(0);	// include all processes
	
	// print processes
	int i;
	for (i = 0; i < MAX_PIDS; i++) {
		if (pids[i].level == 1) {
			pid_print_list(i, 0);
			int child = find_child(i);
			if (child != -1)
				print_cpu(child);
		}
	}
}

static int timer_list_show(struct seq_file *m, void *v)
{
	u64 now = ktime_to_ns(ktime_get());
	int cpu;

	SEQ_printf(m, "Timer List Version: v0.6\n");
	SEQ_printf(m, "HRTIMER_MAX_CLOCK_BASES: %d\n", HRTIMER_MAX_CLOCK_BASES);
	SEQ_printf(m, "now at %Ld nsecs\n", (unsigned long long)now);

	for_each_online_cpu(cpu)
		print_cpu(m, cpu, now);

	SEQ_printf(m, "\n");
	timer_list_show_tickdevices(m);

	return 0;
}

PUBLIC void root_cpuinfo(void)
{
	struct cpu_info cpu_info[CONFIG_MAX_CPUS];
	struct machine machine;
	unsigned c;

	if (sys_getmachine(&machine)) {
		printf("PROCFS: cannot get machine\n");
		return;
	}
	if (sys_getcpuinfo(&cpu_info)) {
		printf("PROCFS: cannot get cpu info\n");
		return;
	}

	for (c = 0; c < machine.processors_count; c++)
		print_cpu(&cpu_info[c], c);
}

/*!
 * Options de la ligne de commande :
 *
 * <dl>
 *   <dt>-d</dt><dd>mode pas à pas (mise au point)</dd>
 *
 *   <dt>-f</dt><dd>le programme est dans un fichier binaire ; le nom de ce
 *   fichier doit être fourni également en paramètre de la ligne de
 *   commande ; sans cette option, on exécute un programme de test prédéfini.</dd>
 *
 * </dl>
 */
int main(int argc, char *argv[])
{
    bool debug = false;
    bool binfile = false;
    bool no_exec = false;
    char *programfile = NULL;

    if (argc > 1) 
    {
        for (int iarg = 1; iarg < argc; ++iarg)
        {
            if (argv[iarg][0] == '-')
                switch (argv[iarg][1])
                {
                case 'd':
                    debug = true;
                    break;
                case 'b': 
                    binfile = true;
                    break;
                 case 'l': 
                    no_exec = true;
                    break;
                  case 'h':
                    usage();
                    exit(EXIT_SUCCESS);
                default:
                    fprintf(stderr, "Unknown option: %s\n", argv[iarg]);
                    usage();
                    exit(EXIT_FAILURE);
                }
            else if (binfile)
                programfile = argv[iarg];
            else 
                fprintf(stderr, "Trailing options ignored...\n");
        }
    }

    Machine mach;

    if (!binfile) 
        load_program(&mach, textsize, text, datasize, data, dataend);
    else 
        read_program(&mach, programfile);   

    printf("\n*** Sauvegarde des programmes et données initiales en format binaire ***\n\n");
    dump_memory(&mach);

    printf("\n*** Machine state before execution ***\n");
    print_program(&mach);
    print_data(&mach);
    print_cpu(&mach);

    if (no_exec) 
        return 0;

    printf("\n*** Execution trace ***\n\n");
    simul(&mach, debug);

    printf("\n*** Machine state after execution ***\n");
    print_cpu(&mach);
    print_data(&mach);
    if(allocated){
		free(mach._text);
		free(mach._data);
	}

    return 0; 
}