- Iterator it(ProcInfo::all.find(pid));

- return (it == ProcInfo::all.end() ? NULL : it->second);

- GList *columns, *col;

- GtkTreeView *proctree;

- proctree = GTK_TREE_VIEW(procdata->tree);

- columns = gtk_tree_view_get_columns (proctree);

- for(col = columns; col; col = col->next)

- gtk_tree_view_column_set_reorderable(static_cast<GtkTreeViewColumn*>(col->data), TRUE);

- g_list_free(columns);

- ProcData * const procdata = static_cast<ProcData*>(user_data);

- procman_save_tree_state(procdata->settings,

- GTK_WIDGET(treeview),

- "proctree");

- GList *columns, *it;

- GtkTreeViewColumn *col = NULL;

- columns = gtk_tree_view_get_columns(treeview);

- for(it = columns; it; it = it->next)

- {

- if(gtk_tree_view_column_get_sort_column_id(static_cast<GtkTreeViewColumn*>(it->data)) == id)

- {

- col = static_cast<GtkTreeViewColumn*>(it->data);

- break;

- }

- }

- g_list_free(columns);

- return col;

- GtkTreeViewColumn* last = NULL;

- GSList *it;

- for(it = order; it; it = it->next)

- {

- int id;

- GtkTreeViewColumn *cur;

- id = GPOINTER_TO_INT(it->data);

- g_assert(id >= 0 && id < NUM_COLUMNS);

- cur = my_gtk_tree_view_get_column_with_sort_column_id(treeview, id);

- if(cur && cur != last)

- {

- gtk_tree_view_move_column_after(treeview, cur, last);

- last = cur;

- }

- }

- GList *columns, *col;

- GSList *order = NULL;

- columns = gtk_tree_view_get_columns(treeview);

- for(col = columns; col; col = col->next)

- {

- int id;

- id = gtk_tree_view_column_get_sort_column_id(static_cast<GtkTreeViewColumn*>(col->data));

- order = g_slist_prepend(order, GINT_TO_POINTER(id));

- }

- g_list_free(columns);

- order = g_slist_reverse(order);

- return order;

- gint column,

- const gchar *key,

- GtkTreeIter *iter,

- gpointer search_data)

- char* name;

- char* user;

- gboolean found;

- gtk_tree_model_get(model, iter,

- COL_NAME, &name,

- COL_USER, &user,

- -1);

- found = !((name && strstr(name, key))

- || (user && strstr(user, key)));

- g_free(name);

- g_free(user);

- return found;

- GtkWidget *proctree;

- GtkWidget *scrolled;

- GtkTreeStore *model;

- GtkTreeSelection *selection;

- GtkTreeViewColumn *column;

- GtkCellRenderer *cell_renderer;

-

- const gchar *titles[] = {

- N_("Process Name"),

- N_("User"),

- N_("Status"),

- N_("Virtual Memory"),

- N_("Resident Memory"),

- N_("Writable Memory"),

- N_("Shared Memory"),

- N_("X Server Memory"),

- /* xgettext:no-c-format */ N_("% CPU"),

- N_("CPU Time"),

- N_("Started"),

- N_("Nice"),

- N_("ID"),

- N_("Security Context"),

- N_("Command Line"),

- N_("Memory"),

- /* xgettext: wchan, see ps(1) or top(1) */

- N_("Waiting Channel"),

- NULL,

- "POINTER"

- };

-

- gint i;

-

- scrolled = gtk_scrolled_window_new (NULL, NULL);

- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),

- GTK_POLICY_AUTOMATIC,

- GTK_POLICY_AUTOMATIC);

-

- model = gtk_tree_store_new (NUM_COLUMNS,

- G_TYPE_STRING, /* Process Name */

- G_TYPE_STRING, /* User */

- G_TYPE_UINT, /* Status */

- G_TYPE_ULONG, /* VM Size */

- G_TYPE_ULONG, /* Resident Memory */

- G_TYPE_ULONG, /* Writable Memory */

- G_TYPE_ULONG, /* Shared Memory */

- G_TYPE_ULONG, /* X Server Memory */

- G_TYPE_UINT, /* % CPU */

- G_TYPE_UINT64, /* CPU time */

- G_TYPE_ULONG, /* Started */

- G_TYPE_INT, /* Nice */

- G_TYPE_UINT, /* ID */

- G_TYPE_STRING, /* Security Context */

- G_TYPE_STRING, /* Arguments */

- G_TYPE_ULONG, /* Memory */

- G_TYPE_STRING, /* wchan */

- GDK_TYPE_PIXBUF, /* Icon */

- G_TYPE_POINTER, /* ProcInfo */

- G_TYPE_STRING /* Sexy tooltip */

- );

-

- proctree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));

- gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (proctree), COL_TOOLTIP);

- g_object_set(G_OBJECT(proctree),

- "show-expanders", procdata->config.show_tree,

- NULL);

- gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (proctree),

- search_equal_func,

- NULL,

- NULL);

- gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (proctree), TRUE);

- g_object_unref (G_OBJECT (model));

-

- selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree));

- gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);

-

- column = gtk_tree_view_column_new ();

-

- cell_renderer = gtk_cell_renderer_pixbuf_new ();

- gtk_tree_view_column_pack_start (column, cell_renderer, FALSE);

- gtk_tree_view_column_set_attributes (column, cell_renderer,

- "pixbuf", COL_PIXBUF,

- NULL);

-

- cell_renderer = gtk_cell_renderer_text_new ();

- gtk_tree_view_column_pack_start (column, cell_renderer, FALSE);

- gtk_tree_view_column_set_attributes (column, cell_renderer,

- "text", COL_NAME,

- NULL);

- gtk_tree_view_column_set_title (column, _(titles[0]));

- gtk_tree_view_column_set_sort_column_id (column, COL_NAME);

- gtk_tree_view_column_set_resizable (column, TRUE);

- gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);

- gtk_tree_view_column_set_min_width (column, 1);

- gtk_tree_view_append_column (GTK_TREE_VIEW (proctree), column);

- gtk_tree_view_set_expander_column (GTK_TREE_VIEW (proctree), column);

-

-

- for (i = COL_USER; i <= COL_WCHAN; i++) {

-

- GtkCellRenderer *cell;

- GtkTreeViewColumn *col;

-

- cell = gtk_cell_renderer_text_new();

- col = gtk_tree_view_column_new();

- gtk_tree_view_column_pack_start(col, cell, TRUE);

- gtk_tree_view_column_set_title(col, _(titles[i]));

- gtk_tree_view_column_set_resizable(col, TRUE);

- gtk_tree_view_column_set_sort_column_id(col, i);

- gtk_tree_view_column_set_reorderable(col, TRUE);

- gtk_tree_view_append_column(GTK_TREE_VIEW(proctree), col);

-

- // type

- switch (i) {

- case COL_MEMXSERVER:

- gtk_tree_view_column_set_cell_data_func(col, cell,

- &procman::size_cell_data_func,

- GUINT_TO_POINTER(i),

- NULL);

- break;

-

- case COL_VMSIZE:

- case COL_MEMRES:

- case COL_MEMSHARED:

- case COL_MEM:

- case COL_MEMWRITABLE:

- gtk_tree_view_column_set_cell_data_func(col, cell,

- &procman::size_na_cell_data_func,

- GUINT_TO_POINTER(i),

- NULL);

- break;

-

- case COL_CPU_TIME:

- gtk_tree_view_column_set_cell_data_func(col, cell,

- &procman::duration_cell_data_func,

- GUINT_TO_POINTER(i),

- NULL);

- break;

-

- case COL_START_TIME:

- gtk_tree_view_column_set_cell_data_func(col, cell,

- &procman::time_cell_data_func,

- GUINT_TO_POINTER(i),

- NULL);

- break;

-

- case COL_STATUS:

- gtk_tree_view_column_set_cell_data_func(col, cell,

- &procman::status_cell_data_func,

- GUINT_TO_POINTER(i),

- NULL);

- break;

-

- default:

- gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL);

- break;

- }

-

- // xaling

- switch(i)

- {

- case COL_VMSIZE:

- case COL_MEMRES:

- case COL_MEMWRITABLE:

- case COL_MEMSHARED:

- case COL_MEMXSERVER:

- case COL_CPU:

- case COL_NICE:

- case COL_PID:

- case COL_CPU_TIME:

- case COL_MEM:

- g_object_set(G_OBJECT(cell), "xalign", 1.0f, NULL);

- break;

- }

-

- // sizing

- switch (i) {

- case COL_ARGS:

- gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);

- gtk_tree_view_column_set_min_width(col, 150);

- break;

- default:

- gtk_tree_view_column_set_min_width(column, 20);

- break;

- }

- }

-

- gtk_container_add (GTK_CONTAINER (scrolled), proctree);

-

- procdata->tree = proctree;

-

- set_proctree_reorderable(procdata);

-

- procman_get_tree_state (procdata->settings, proctree, "proctree");

-

- /* Override column settings by hiding this column if it's meaningless: */

- if (!can_show_security_context_column ()) {

- GtkTreeViewColumn *column;

- column = my_gtk_tree_view_get_column_with_sort_column_id (GTK_TREE_VIEW (proctree), COL_SECURITYCONTEXT);

- gtk_tree_view_column_set_visible (column, FALSE);

- }

-

- g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree))),

- "changed",

- G_CALLBACK (cb_row_selected), procdata);

- g_signal_connect (G_OBJECT (proctree), "popup_menu",

- G_CALLBACK (cb_tree_popup_menu), procdata);

- g_signal_connect (G_OBJECT (proctree), "button_press_event",

- G_CALLBACK (cb_tree_button_pressed), procdata);

-

- g_signal_connect (G_OBJECT(proctree), "columns-changed",

- G_CALLBACK(cb_columns_changed), procdata);

-

- return scrolled;

- g_free(this->name);

- g_free(this->tooltip);

- g_free(this->arguments);

- g_free(this->security_context);

- const gchar *cmd, const GStrv args)

- if (args) {

- // look for /usr/bin/very_long_name

- // and also /usr/bin/interpreter /usr/.../very_long_name

- // which may have use prctl to alter 'cmd' name

- for (int i = 0; i != 2 && args[i]; ++i) {

- char* basename;

- basename = g_path_get_basename(args[i]);

-

- if (g_str_has_prefix(basename, cmd)) {

- info->name = basename;

- return;

- }

-

- g_free(basename);

- }

- }

-

- info->name = g_strdup (cmd);

- if (G_LIKELY(this->uid == uid))

- return;

- this->uid = uid;

- typedef std::pair<ProcInfo::UserMap::iterator, bool> Pair;

- ProcInfo::UserMap::value_type hint(uid, "");

- Pair p(ProcInfo::users.insert(hint));

- // procman_debug("User lookup for uid %u: %s", uid, (p.second ? "MISS" : "HIT"));

- if (p.second) {

- struct passwd* pwd;

- pwd = getpwuid(uid);

- if (pwd && pwd->pw_name)

- p.first->second = pwd->pw_name;

- else {

- char username[16];

- g_sprintf(username, "%u", uid);

- p.first->second = username;

- }

- }

- this->user = p.first->second;

- glibtop_proc_map buf;

- glibtop_map_entry *maps;

- maps = glibtop_get_proc_map(&buf, info->pid);

- gulong memwritable = 0;

- const unsigned number = buf.number;

- for (unsigned i = 0; i < number; ++i) {

- memwritable += maps[i].private_dirty;

- if (maps[i].perm & GLIBTOP_MAP_PERM_WRITE)

- memwritable += maps[i].size;

- }

- info->memwritable = memwritable;

- g_free(maps);

- glibtop_proc_mem procmem;

- WnckResourceUsage xresources;

- wnck_pid_read_resource_usage (gdk_screen_get_display (gdk_screen_get_default ()),

- info->pid,

- &xresources);

- glibtop_get_proc_mem(&procmem, info->pid);

- info->vmsize = procmem.vsize;

- info->memres = procmem.resident;

- info->memshared = procmem.share;

- info->memxserver = xresources.total_bytes_estimate;

- get_process_memory_writable(info);

- // fake the smart memory column if writable is not available

- info->mem = info->memxserver + (info->memwritable ? info->memwritable : info->memres);

- ProcData * const procdata = ProcData::get_instance();

- GtkTreeModel *model;

- model = gtk_tree_view_get_model(GTK_TREE_VIEW(procdata->tree));

-

- using procman::tree_store_update;

-

- tree_store_update(model, &info->node, COL_STATUS, info->status);

- tree_store_update(model, &info->node, COL_USER, info->user.c_str());

- tree_store_update(model, &info->node, COL_VMSIZE, info->vmsize);

- tree_store_update(model, &info->node, COL_MEMRES, info->memres);

- tree_store_update(model, &info->node, COL_MEMWRITABLE, info->memwritable);

- tree_store_update(model, &info->node, COL_MEMSHARED, info->memshared);

- tree_store_update(model, &info->node, COL_MEMXSERVER, info->memxserver);

- tree_store_update(model, &info->node, COL_CPU, info->pcpu);

- tree_store_update(model, &info->node, COL_CPU_TIME, info->cpu_time);

- tree_store_update(model, &info->node, COL_START_TIME, info->start_time);

- tree_store_update(model, &info->node, COL_NICE, info->nice);

- tree_store_update(model, &info->node, COL_MEM, info->mem);

- tree_store_update(model, &info->node, COL_WCHAN, info->wchan);

- GtkTreeModel *model;

- model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));

- if (procdata->config.show_tree) {

- ProcInfo *parent = 0;

- if (not forced)

- parent = ProcInfo::find(info->ppid);

- if (parent) {

- GtkTreePath *parent_node = gtk_tree_model_get_path(model, &parent->node);

- gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, &parent->node, 0);

- if (!gtk_tree_view_row_expanded(GTK_TREE_VIEW(procdata->tree), parent_node))

- gtk_tree_view_expand_row(GTK_TREE_VIEW(procdata->tree), parent_node, FALSE);

- gtk_tree_path_free(parent_node);

- } else

- gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, NULL, 0);

- }

- else

- gtk_tree_store_insert (GTK_TREE_STORE (model), &info->node, NULL, 0);

- gtk_tree_store_set (GTK_TREE_STORE (model), &info->node,

- COL_POINTER, info,

- COL_NAME, info->name,

- COL_ARGS, info->arguments,

- COL_TOOLTIP, info->tooltip,

- COL_PID, info->pid,

- COL_SECURITYCONTEXT, info->security_context,

- -1);

- procdata->pretty_table.set_icon(*info);

- procman_debug("inserted %d%s", info->pid, (forced ? " (forced)" : ""));

- ProcInfo *current, List &orphans, unsigned lvl = 0)

- GtkTreeIter child_node;

- if (std::find(orphans.begin(), orphans.end(), current) != orphans.end()) {

- procman_debug("[%u] %d already removed from tree", lvl, int(current->pid));

- return;

- }

- procman_debug("[%u] pid %d, %d children", lvl, int(current->pid),

- gtk_tree_model_iter_n_children(model, &current->node));

- // it is not possible to iterate&erase over a treeview so instead we

- // just pop one child after another and recursively remove it and

- // its children

- while (gtk_tree_model_iter_children(model, &child_node, &current->node)) {

- ProcInfo *child = 0;

- gtk_tree_model_get(model, &child_node, COL_POINTER, &child, -1);

- remove_info_from_tree(procdata, model, child, orphans, lvl + 1);

- }

- g_assert(not gtk_tree_model_iter_has_child(model, &current->node));

- if (procdata->selected_process == current)

- procdata->selected_process = NULL;

- orphans.push_back(current);

- gtk_tree_store_remove(GTK_TREE_STORE(model), &current->node);

- procman::poison(current->node, 0x69);

- glibtop_proc_state procstate;

- glibtop_proc_uid procuid;

- glibtop_proc_time proctime;

- glibtop_proc_kernel prockernel;

- glibtop_get_proc_kernel(&prockernel, info->pid);

- g_strlcpy(info->wchan, prockernel.wchan, sizeof info->wchan);

- glibtop_get_proc_state (&procstate, info->pid);

- info->status = procstate.state;

- glibtop_get_proc_uid (&procuid, info->pid);

- glibtop_get_proc_time (&proctime, info->pid);

- get_process_memory_info(info);

- info->set_user(procstate.uid);

- info->pcpu = (proctime.rtime - info->cpu_time) * 100 / procdata->cpu_total_time;

- info->pcpu = MIN(info->pcpu, 100);

- if (not procdata->config.solaris_mode)

- info->pcpu *= procdata->config.num_cpus;

- ProcInfo::cpu_times[info->pid] = info->cpu_time = proctime.rtime;

- info->nice = procuid.nice;

- info->ppid = procuid.ppid;

- : tooltip(NULL),

- name(NULL),

- arguments(NULL),

- security_context(NULL),

- pid(pid),

- uid(-1)

- ProcInfo * const info = this;

- glibtop_proc_state procstate;

- glibtop_proc_time proctime;

- glibtop_proc_args procargs;

- gchar** arguments;

-

- glibtop_get_proc_state (&procstate, pid);

- glibtop_get_proc_time (&proctime, pid);

- arguments = glibtop_get_proc_argv (&procargs, pid, 0);

-

- /* FIXME : wrong. name and arguments may change with exec* */

- get_process_name (info, procstate.cmd, static_cast<const GStrv>(arguments));

-

- std::string tooltip = make_string(g_strjoinv(" ", arguments));

- if (tooltip.empty())

- tooltip = procstate.cmd;

-

- info->tooltip = g_markup_escape_text(tooltip.c_str(), -1);

-

- info->arguments = g_strescape(tooltip.c_str(), "\\\"");

- g_strfreev(arguments);

-

- guint64 cpu_time = proctime.rtime;

- std::map<pid_t, guint64>::iterator it(ProcInfo::cpu_times.find(pid));

- if (it != ProcInfo::cpu_times.end())

- {

- if (proctime.rtime >= it->second)

- cpu_time = it->second;

- }

- info->cpu_time = cpu_time;

- info->start_time = proctime.start_time;

-

- get_process_selinux_context (info);

- typedef std::list<ProcInfo*> ProcList;

- ProcList addition;

- GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));

- guint i;

- // Add or update processes in the process list

- for(i = 0; i < n; ++i) {

- ProcInfo *info = ProcInfo::find(pid_list[i]);

-

- if (!info) {

- info = new ProcInfo(pid_list[i]);

- ProcInfo::all[info->pid] = info;

- addition.push_back(info);

- }

- update_info (procdata, info);

- }

- // Remove dead processes from the process list and from the

- // tree. children are queued to be readded at the right place

- // in the tree.

- const std::set<pid_t> pids(pid_list, pid_list + n);

- ProcInfo::Iterator it(ProcInfo::begin());

- while (it != ProcInfo::end()) {

- ProcInfo * const info = it->second;

- ProcInfo::Iterator next(it);

- ++next;

- if (pids.find(info->pid) == pids.end()) {

- procman_debug("ripping %d", info->pid);

- remove_info_from_tree(procdata, model, info, addition);

- addition.remove(info);

- ProcInfo::all.erase(it);

- delete info;

- }

- it = next;

- }

- // INVARIANT

- // pid_list == ProcInfo::all + addition

- if (procdata->config.show_tree) {

- // insert process in the tree. walk through the addition list

- // (new process + process that have a new parent). This loop

- // handles the dependencies because we cannot insert a process

- // until its parent is in the tree.

- std::set<pid_t> in_tree(pids);

- for (ProcList::iterator it(addition.begin()); it != addition.end(); ++it)

- in_tree.erase((*it)->pid);

- while (not addition.empty()) {

- procman_debug("looking for %d parents", int(addition.size()));

- ProcList::iterator it(addition.begin());

- while (it != addition.end()) {

- procman_debug("looking for %d's parent with ppid %d",

- int((*it)->pid), int((*it)->ppid));

- // inserts the process in the treeview if :

- // - it is init

- // - its parent is already in tree

- // - its parent is unreachable

- //

- // rounds == 2 means that addition contains processes with

- // unreachable parents

- //

- // FIXME: this is broken if the unreachable parent becomes active

- // i.e. it gets active or changes ower

- // so we just clear the tree on __each__ update

- // see proctable_update_list (ProcData * const procdata)

- if ((*it)->ppid == 0 or in_tree.find((*it)->ppid) != in_tree.end()) {

- insert_info_to_tree(*it, procdata);

- in_tree.insert((*it)->pid);

- it = addition.erase(it);

- continue;

- }

- ProcInfo *parent = ProcInfo::find((*it)->ppid);

- // if the parent is unreachable

- if (not parent) {

- // or std::find(addition.begin(), addition.end(), parent) == addition.end()) {

- insert_info_to_tree(*it, procdata, true);

- in_tree.insert((*it)->pid);

- it = addition.erase(it);

- continue;

- }

-

- ++it;

- }

- }

- }

- else {

- // don't care of the tree

- for (ProcList::iterator it(addition.begin()); it != addition.end(); ++it)

- insert_info_to_tree(*it, procdata);

- }

- for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it)

- update_info_mutable_cols(it->second);

- pid_t* pid_list;

- glibtop_proclist proclist;

- glibtop_cpu cpu;

- gint which, arg;

- procman::SelectionMemento selection;

-

- switch (procdata->config.whose_process) {

- case ALL_PROCESSES:

- which = GLIBTOP_KERN_PROC_ALL;

- arg = 0;

- break;

-

- case ACTIVE_PROCESSES:

- which = GLIBTOP_KERN_PROC_ALL | GLIBTOP_EXCLUDE_IDLE;

- arg = 0;

- if (procdata->config.show_tree)

- {

- selection.save(procdata->tree);

- proctable_clear_tree(procdata);

- }

- break;

-

- default:

- which = GLIBTOP_KERN_PROC_UID;

- arg = getuid ();

- if (procdata->config.show_tree)

- {

- selection.save(procdata->tree);

- proctable_clear_tree(procdata);

- }

- break;

- }

-

- pid_list = glibtop_get_proclist (&proclist, which, arg);

-

- /* FIXME: total cpu time elapsed should be calculated on an individual basis here

- ** should probably have a total_time_last gint in the ProcInfo structure */

- glibtop_get_cpu (&cpu);

- procdata->cpu_total_time = MAX(cpu.total - procdata->cpu_total_time_last, 1);

- procdata->cpu_total_time_last = cpu.total;

-

- refresh_list (procdata, pid_list, proclist.number);

-

- selection.restore(procdata->tree);

-

- g_free (pid_list);

-

- /* proclist.number == g_list_length(procdata->info) == g_hash_table_size(procdata->pids) */

- char* string;

- string = make_loadavg_string();

- gtk_label_set_text (GTK_LABEL(procdata->loadavg), string);

- g_free (string);

- proctable_update_list (procdata);

- GtkTreeModel *model;

- model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));

- gtk_tree_store_clear (GTK_TREE_STORE (model));

- proctable_free_table (procdata);

- update_sensitivity(procdata);

- for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it)

- delete it->second;

- ProcInfo::all.clear();

- glibtop_loadavg buf;

- glibtop_get_loadavg(&buf);

- return g_strdup_printf(

- _("Load averages for the last 1, 5, 15 minutes: "

- "%0.2f, %0.2f, %0.2f"),

- buf.loadavg[0],

- buf.loadavg[1],

- buf.loadavg[2]);

- COL_PIXBUF, (this->pixbuf ? this->pixbuf->gobj() : NULL),

- -1);