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