static int fs_is_clean(o2fsck_state *ost, char *filename) { struct ocfs2_super_block *sb = OCFS2_RAW_SB(ost->ost_fs->fs_super); time_t now = time(NULL); time_t next = sb->s_lastcheck + sb->s_checkinterval; static char reason[4096] = {'\0', }; struct tm local; if (ost->ost_force) strcpy(reason, "was run with -f"); else if ((OCFS2_RAW_SB(ost->ost_fs->fs_super)->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_RESIZE_INPROG)) strcpy(reason, "incomplete volume resize detected"); else if ((OCFS2_RAW_SB(ost->ost_fs->fs_super)->s_feature_incompat & OCFS2_FEATURE_INCOMPAT_TUNEFS_INPROG)) strcpy(reason, "incomplete tunefs operation detected"); else if (sb->s_state & OCFS2_ERROR_FS) strcpy(reason, "contains a file system with errors"); else if (sb->s_max_mnt_count > 0 && sb->s_mnt_count > sb->s_max_mnt_count) { sprintf(reason, "has been mounted %u times without being " "checked", sb->s_mnt_count); } else if (sb->s_checkinterval > 0 && now >= next) { unsigned scaled_time; char *scaled_units; scale_time(now - sb->s_lastcheck, &scaled_time, &scaled_units); sprintf(reason, "has gone %u %s without being checked", scaled_time, scaled_units); } if (reason[0]) { printf("%s %s, check forced.\n", filename, reason); return 0; } reason[0] = '\0'; if (sb->s_max_mnt_count > 0) sprintf(reason, "after %u additional mounts", sb->s_max_mnt_count - sb->s_mnt_count); if (sb->s_checkinterval > 0) { localtime_r(&next, &local); if (reason[0]) ftso_strftime(reason + strlen(reason), sizeof(reason) - strlen(reason), " or by %c, whichever comes first", &local); else ftso_strftime(reason, sizeof(reason), "by %c", &local); } printf("%s is clean.", filename); if (reason[0]) printf(" It will be checked %s.\n", reason); return 1; }
static void bench_record(SkPicture* src, const char* name, SkBBHFactory* bbhFactory) { BenchTimer timer; timer.start(); const int width = src ? src->width() : FLAGS_nullSize; const int height = src ? src->height() : FLAGS_nullSize; for (int i = 0; i < FLAGS_loops; i++) { if (FLAGS_skr) { EXPERIMENTAL::SkRecording recording(width, height); if (NULL != src) { src->draw(recording.canvas()); } // Release and delete the SkPlayback so that recording optimizes its SkRecord. SkDELETE(recording.releasePlayback()); } else { SkPictureRecorder recorder; SkCanvas* canvas = recorder.beginRecording(width, height, bbhFactory, FLAGS_flags); if (NULL != src) { src->draw(canvas); } if (FLAGS_endRecording) { SkAutoTUnref<SkPicture> dst(recorder.endRecording()); } } } timer.end(); const double msPerLoop = timer.fCpu / (double)FLAGS_loops; printf("%f\t%s\n", scale_time(msPerLoop), name); }
int vpart_info::repair_time( const Character &ch ) const { return scale_time( repair_skills, repair_moves, ch ); }
int vpart_info::install_time( const Character &ch ) const { return scale_time( install_skills, install_moves, ch ); }
/* * Displays infos for a single task */ void show_task_info(proc_t *task, int pmem) { int i,j; unsigned int t; char *cmdptr; char tmp[2048], tmp2[2048] = "", tmp3[2048] = "", *p; for (i = 0; i < Numfields; i++) { tmp[0] = 0; switch (pflags[i]) { case P_PID: sprintf(tmp, "%5d ", task->pid); break; case P_PPID: sprintf(tmp, "%5d ", task->ppid); break; case P_EUID: sprintf(tmp, "%4d ", task->euid); break; case P_EUSER: sprintf(tmp, "%-8.8s ", task->euser); break; case P_PCPU: sprintf(tmp, "%4.1f ", (float)task->pcpu / 10); break; case P_LCPU: sprintf(tmp, "%2d ", task->lproc); break; case P_PMEM: sprintf(tmp, "%4.1f ", (float)pmem / 10); break; case P_TTY: { char outbuf[9]; dev_to_tty(outbuf, 8, task->tty, task->pid, ABBREV_DEV); sprintf(tmp, "%-8.8s ", outbuf); } break; case P_PRI: sprintf(tmp, "%3.3s ", scale_k(task->priority, 3, 0)); break; case P_NICE: sprintf(tmp, "%3.3s ", scale_k(task->nice, 3, 0)); break; case P_PAGEIN: sprintf(tmp, "%6.6s ", scale_k(task->maj_flt, 6, 0)); break; case P_TSIZ: sprintf(tmp, "%5.5s ", scale_k(((task->end_code - task->start_code) / 1024), 5, 1)); break; case P_DSIZ: sprintf(tmp, "%5.5s ", scale_k(((task->vsize - task->end_code) / 1024), 5, 1)); break; case P_SIZE: sprintf(tmp, "%5.5s ", scale_k((task->size << CL_pg_shift), 5, 1)); break; case P_TRS: sprintf(tmp, "%4.4s ", scale_k((task->trs << CL_pg_shift), 4, 1)); break; case P_SWAP: sprintf(tmp, "%4.4s ", scale_k(((task->size - task->resident) << CL_pg_shift), 4, 1)); break; case P_SHARE: sprintf(tmp, "%5.5s ", scale_k((task->share << CL_pg_shift), 5, 1)); break; case P_A: sprintf(tmp, "%3.3s ", "NYI"); break; case P_WP: sprintf(tmp, "%3.3s ", "NYI"); break; case P_DT: sprintf(tmp, "%3.3s ", scale_k(task->dt, 3, 0)); break; case P_RSS: /* resident not rss, it seems to be more correct. */ sprintf(tmp, "%4.4s ", scale_k((task->resident << CL_pg_shift), 4, 1)); break; case P_WCHAN: if (!CL_wchan_nout) sprintf(tmp, "%-9.9s ", wchan(task->wchan)); else sprintf(tmp, "%-9lx", task->wchan); break; case P_STAT: sprintf(tmp, "%-4.4s ", status(task)); break; case P_TIME: t = (task->utime + task->stime) / Hertz; if (Cumulative) t += (task->cutime + task->cstime) / Hertz; sprintf(tmp, "%6.6s ", scale_time(t,6)); break; case P_COMMAND: if (!show_cmd && task->cmdline && *(task->cmdline)) { j=0; while(((task->cmdline)[j] != NULL) && (strlen(tmp3)<1020)){ /* #if 0 */ /* This is useless? FIXME */ if (j > 0) strcat(tmp3, " "); /* #endif */ strncat(tmp3, (task->cmdline)[j], 1000); j++; } cmdptr = tmp3; } else { cmdptr = task->cmd; } if (strlen(cmdptr) > Maxcmd) cmdptr[Maxcmd - 1] = 0; sprintf(tmp, "%s", cmdptr); tmp3[0]=0; break; case P_FLAGS: sprintf(tmp, "%8lx ", task->flags); break; } strcat(tmp2, tmp); } if (strlen(tmp2) > Cols - 1) tmp2[Cols - 1] = 0; /* take care of cases like: perl -e 'foo bar foo bar foo # end of perl script' */ for (p=tmp2;*p;++p) if (!isgraph(*p)) *p=' '; printf("\n%s", tmp2); PUTP(top_clrtoeol); }
int main(int argc, char **argv) { int exit_status = 0; char header[HEADER_BUFFER_SIZE]; size_t header_length = snprintf( header, sizeof(header), "%-*s %-*s %-*s %-*s %-*s %-*s %*s %*s %*s " "%*s %*s %*s %*s %*s %*s\n", PID_Column_Width, PID_Column_Name, PPID_Column_Width, PPID_Column_Name, Name_Column_Width, Name_Column_Name, UID_Column_Width, UID_Column_Name, GID_Column_Width, GID_Column_Name, State_Column_Width, State_Column_Name, Nice_Column_Width, Nice_Column_Name, UTime_Column_Width, UTime_Column_Name, KTime_Column_Width, KTime_Column_Name, RSS_Column_Width, RSS_Column_Name, VM_Column_Width, VM_Column_Name, Reads_Column_Width, Reads_Column_Name, Writes_Column_Width, Writes_Column_Name, Read_Column_Width, Read_Column_Name, Written_Column_Width, Written_Column_Name ); pid_t *pid_list = NULL; char total_ram_scaled[FIELD_BUFFER_SIZE]; char used_ram_scaled[FIELD_BUFFER_SIZE]; char free_ram_scaled[FIELD_BUFFER_SIZE]; char total_swap_scaled[FIELD_BUFFER_SIZE]; char used_swap_scaled[FIELD_BUFFER_SIZE]; char free_swap_scaled[FIELD_BUFFER_SIZE]; char user_cpu_time_scaled[FIELD_BUFFER_SIZE]; char kernel_cpu_time_scaled[FIELD_BUFFER_SIZE]; char core_memory_usage_scaled[FIELD_BUFFER_SIZE]; char virtual_memory_usage_scaled[FIELD_BUFFER_SIZE]; char data_read_scaled[FIELD_BUFFER_SIZE]; char data_written_scaled[FIELD_BUFFER_SIZE]; bool show_kernel_threads = false; if (!initscr()) { fprintf( stderr, "Failed to create the program's UI.\n" ); exit_status = EXIT_FAILURE; goto cleanup; } if (has_colors()) { start_color(); use_default_colors(); init_pair(1, COLOR_BLACK, COLOR_WHITE); } noecho(); halfdelay(Input_Delay); WINDOW *header_pad = newpad(1, header_length); if (!header_pad) { fprintf( stderr, "Failed to create a UI pad for a header.\n" ); exit_status = EXIT_FAILURE; goto cleanup; } bool has_attribute = false; if (has_colors()) { wattron(header_pad, COLOR_PAIR(1)); has_attribute = !has_attribute; } waddstr(header_pad, header); if (has_attribute) { wattroff(header_pad, COLOR_PAIR(1)); } WINDOW *pad = NULL; int pad_height = -1; int pad_shift_y = 0; int pad_shift_x = 0; WINDOW *footer_pad = newpad(1, header_length); if (!footer_pad) { fprintf( stderr, "Failed to create a UI pad for a footer.\n" ); exit_status = EXIT_FAILURE; goto cleanup; } wprintw( footer_pad, "Press 't' to %s kernel threads. Press 'q' to exit.", show_kernel_threads ? "hide" : "show" ); for (;;) { pid_t current_pid = getpid(); struct sysinfo system; if (sysinfo(&system)) { fprintf( stderr, "Failed to perform the 'sysinfo' system call.\n" ); exit_status = EXIT_FAILURE; goto cleanup; } long pid_list_length = syscall(__NR_get_pids, 0, NULL); if (pid_list_length <= 0) { fprintf( stderr, "Failed to perform the 'get_pids' system call. " "Ensure that the 'task_info' subsystem was compiled " "into the kernel.\n" ); exit_status = EXIT_FAILURE; goto cleanup; } size_t pid_list_size = pid_list_length * sizeof(*pid_list); if (!(pid_list = realloc(pid_list, pid_list_size))) { fprintf(stderr, "Failed to reserve memory.\n"); exit_status = EXIT_FAILURE; goto cleanup; } memset(pid_list, 0, pid_list_size); if (syscall(__NR_get_pids, pid_list_length, pid_list) <= 0) { fprintf( stderr, "Failed to perform the 'get_pids' system call. " "Ensure that the 'task_info' subsystem was compiled " "into the kernel.\n" ); exit_status = EXIT_FAILURE; goto cleanup; } if (pad_height != pid_list_length + 1) { pad_height = pid_list_length + 1; if (pad) { delwin(pad); } pad = newpad(pad_height, header_length); if (!pad) { fprintf( stderr, "Failed to create a scrollable UI pad.\n" ); exit_status = EXIT_FAILURE; goto cleanup; } keypad(pad, true); } size_t header_height = Header_Height; unsigned long uptime_days = system.uptime / 86400; unsigned long uptime_hours = system.uptime / 3600 - uptime_days * 24; unsigned long uptime_minutes = system.uptime / 60 - uptime_days * 1440 - uptime_hours * 60; unsigned long uptime_seconds = system.uptime % 60; float load_average_scale = 1 << SI_LOAD_SHIFT; float load_average_for_1_minute = system.loads[0] / load_average_scale; float load_average_for_5_minutes = system.loads[1] / load_average_scale; float load_average_for_15_minutes = system.loads[1] / load_average_scale; uint64_t total_ram = system.totalram * system.mem_unit; uint64_t used_ram = (system.totalram - system.freeram) * system.mem_unit; uint64_t free_ram = system.freeram * system.mem_unit; uint64_t total_swap = system.totalswap * system.mem_unit; uint64_t used_swap = (system.totalswap - system.freeswap) * system.mem_unit; uint64_t free_swap = system.freeswap * system.mem_unit; scale_size( total_ram, total_ram_scaled, sizeof(total_ram_scaled) ); scale_size( used_ram, used_ram_scaled, sizeof(used_ram_scaled) ); scale_size( free_ram, free_ram_scaled, sizeof(free_ram_scaled) ); scale_size( total_swap, total_swap_scaled, sizeof(total_swap_scaled) ); scale_size( used_swap, used_swap_scaled, sizeof(used_swap_scaled) ); scale_size( free_swap, free_swap_scaled, sizeof(free_swap_scaled) ); wredrawln(stdscr, 0, header_height); mvprintw( 0, 0, "up for %lu %s %lu:%lu:%lu, tasks: %zu\n" "load average: %.2f, %.2f, %.2f\n" "\n" "total ram: %*s, used ram: %*s, free ram: %*s\n" "total swap: %*s, used swap: %*s, free swap: %*s\n", uptime_days, uptime_days == 1 ? "day" : "days", uptime_hours, uptime_minutes, uptime_seconds, pid_list_length, load_average_for_1_minute, load_average_for_5_minutes, load_average_for_15_minutes, Memory_Column_Width, total_ram_scaled, Memory_Column_Width, used_ram_scaled, Memory_Column_Width, free_ram_scaled, Memory_Column_Width, total_swap_scaled, Memory_Column_Width, used_swap_scaled, Memory_Column_Width, free_swap_scaled ); werase(pad); int real_pad_height = 0; for (size_t i = 0; i < pid_list_length; ++i) { struct task_info task; pid_t pid = pid_list[i]; if (syscall(__NR_get_task_info, pid, &task) == 0) { if (!show_kernel_threads && (task.pid == Kernel_Thread_Daemon_PID || task.ppid == Kernel_Thread_Daemon_PID)) { continue; } const char *task_state = task.state < Task_States_Count - 1 ? Task_States[task.state + 1] : Task_States[0]; scale_time( task.user_cpu_time, user_cpu_time_scaled, sizeof(user_cpu_time_scaled) ); scale_time( task.system_cpu_time, kernel_cpu_time_scaled, sizeof(kernel_cpu_time_scaled) ); scale_size( task.core_memory_bytes_used, core_memory_usage_scaled, sizeof(core_memory_usage_scaled) ); scale_size( task.virtual_memory_bytes_used, virtual_memory_usage_scaled, sizeof(virtual_memory_usage_scaled) ); scale_size( task.bytes_read, data_read_scaled, sizeof(data_read_scaled) ); scale_size( task.bytes_written, data_written_scaled, sizeof(data_written_scaled) ); has_attribute = false; if (has_colors()) { if (task.state == 0 && task.pid != current_pid) { wattron(pad, COLOR_PAIR(1)); has_attribute = !has_attribute; } } wprintw( pad, "%-*d %-*d %-*s %-*d %-*d %-*s %*d " "%*s %*s %*s %*s " "%*"PRIu64" %*"PRIu64" " "%*s %*s\n", PID_Column_Width, (int) pid, PPID_Column_Width, task.ppid, Name_Column_Width, task.name, UID_Column_Width, task.uid, GID_Column_Width, task.gid, State_Column_Width, task_state, Nice_Column_Width, task.nice_level, UTime_Column_Width, user_cpu_time_scaled, KTime_Column_Width, kernel_cpu_time_scaled, RSS_Column_Width, core_memory_usage_scaled, VM_Column_Width, virtual_memory_usage_scaled, Reads_Column_Width, task.read_syscalls_count, Writes_Column_Width, task.write_syscalls_count, Read_Column_Width, data_read_scaled, Written_Column_Width, data_written_scaled ); if (has_attribute) { wattroff(pad, COLOR_PAIR(1)); } ++real_pad_height; } } int window_height, window_width; getmaxyx(stdscr, window_height, window_width); wnoutrefresh(stdscr); prefresh( header_pad, 0, pad_shift_x, header_height, 0, header_height + 1, window_width - 1 ); prefresh( pad, pad_shift_y, pad_shift_x, header_height + 1, 0, window_height - 2, window_width - 1 ); prefresh( footer_pad, 0, 0, window_height - 1, 0, window_height, window_width - 1 ); doupdate(); int key = wgetch(pad); if (key != ERR) { switch (key) { case 'h': case KEY_LEFT: --pad_shift_x; break; case 'j': case KEY_DOWN: ++pad_shift_y; break; case 'k': case KEY_UP: --pad_shift_y; break; case 'l': case KEY_RIGHT: ++pad_shift_x; break; case 't': show_kernel_threads = !show_kernel_threads; werase(footer_pad); wprintw( footer_pad, "Press 't' to %s kernel threads. " "Press 'q' to exit.", show_kernel_threads ? "hide" : "show" ); break; case 'q': goto cleanup; } int pad_height_limit = real_pad_height - 2; if (pad_shift_y < 0) { pad_shift_y = 0; } else if (pad_shift_y > pad_height_limit) { pad_shift_y = pad_height_limit; } int pad_width_limit = header_length - 5; if (pad_shift_x < 0) { pad_shift_x = 0; } else if (pad_shift_x > pad_width_limit) { pad_shift_x = pad_width_limit; } } } cleanup: if (header_pad) { delwin(header_pad); } if (pad) { delwin(pad); } if (footer_pad) { delwin(footer_pad); } endwin(); return exit_status; }