void print_ancestor_line(node *n){
node *lt,*rt;
if( ! is_terminal(n) ){
lt=get_terminal(n,LEFT);
rt=get_terminal(n,RIGHT);
dprint(RES_FILE,"%-20s %-20s ",lt->name,rt->name);
if( n->name == NULL )
dprint(RES_FILE , "%-20s ", "-");
else
dprint(RES_FILE , "%-20s ", n->name);
if(EDGE_LENS_ARE_INTEGERS == TRUE ){
dprint(RES_FILE,"%10.3f +/- %-10.3f",n->mpl,prob2normval(1-PROB_LIMIT) * sqrt(n->var));
}
else{
dprint(RES_FILE,"%10.3f +/- %-10s",n->mpl,STAT_MISSING);
}
dprint(RES_FILE , "%12d " , n->num_of_terminals);
//printf("chis: %f free:%d prob:%f\n", n->chi_sq, n->num_of_children-1, n->prob);
if(EDGE_LENS_ARE_INTEGERS == FALSE){
dprint(RES_FILE,"%14s",STAT_MISSING);
}
else if( n->accepted == FALSE )
dprint(RES_FILE,"%8s, %s%f",REJ_WORD, "prob=",(double)n->prob);
else
dprint(RES_FILE,"%8s",ACC_WORD);
dprint(RES_FILE,"\n");
}
}
/**
* Get the end of a chain of references. If the final one is not
* found, we return the reference just before that.
*/
static int get_terminal(git_reference **out, git_repository *repo, const char *ref_name, int nesting)
{
git_reference *ref;
int error = 0;
if (nesting > MAX_NESTING_LEVEL) {
giterr_set(GITERR_REFERENCE, "Reference chain too deep (%d)", nesting);
return GIT_ENOTFOUND;
}
/* set to NULL to let the caller know that they're at the end of the chain */
if ((error = git_reference_lookup(&ref, repo, ref_name)) < 0) {
*out = NULL;
return error;
}
if (git_reference_type(ref) == GIT_REF_OID) {
*out = ref;
error = 0;
} else {
error = get_terminal(out, repo, git_reference_symbolic_target(ref), nesting + 1);
if (error == GIT_ENOTFOUND && !*out)
*out = ref;
else
git_reference_free(ref);
}
return error;
}
void print_ancestor_age_line(node *n){
node *lt,*rt;
double min, max;
if( ! is_terminal(n) ){
lt=get_terminal(n,LEFT);
rt=get_terminal(n,RIGHT);
dprint(RES_FILE,"%-20s %-20s ", lt->name,rt->name);
if( n->name == NULL )
dprint(RES_FILE , "%-20s ", "-");
else
dprint(RES_FILE , "%-20s ", n->name);
dprint(RES_FILE,"%10.3f ",n->fix->calc_age);
dprint(RES_FILE,"%11d ",n->num_of_terminals);
dprint(RES_FILE,"%16.3f ",n->mpl);
dprint(RES_FILE,"%14f ",n->mpl / n->fix->calc_age);
min = n->fix->minage;
max = n->fix->maxage;
if( is_fixnode(n)==TRUE && is_forced_fixnode(n) == FALSE){
min = max = n->fix->fixage;
}
if( is_minnode(n)==FALSE && !(is_fixnode(n) == TRUE && is_forced_fixnode(n)==FALSE) )
dprint(RES_FILE,"%11s " ,"-");
else
dprint(RES_FILE,"%11.1f " ,min);
if( is_maxnode(n)==FALSE && !(is_fixnode(n) == TRUE && is_forced_fixnode(n) == FALSE) )
dprint(RES_FILE,"%11s " ,"-");
else
dprint(RES_FILE,"%11.1f ",max);
dprint(RES_FILE,"\n");
}
}
static struct frame *
frame_for_x_selection (Lisp_Object object)
{
Lisp_Object tail;
struct frame *f;
if (NILP (object))
{
f = XFRAME (selected_frame);
if (FRAME_MAC_P (f) && FRAME_LIVE_P (f))
return f;
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
{
f = XFRAME (XCAR (tail));
if (FRAME_MAC_P (f) && FRAME_LIVE_P (f))
return f;
}
}
else if (TERMINALP (object))
{
struct terminal *t = get_terminal (object, 1);
if (t->type == output_mac)
{
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
{
f = XFRAME (XCAR (tail));
if (FRAME_LIVE_P (f) && f->terminal == t)
return f;
}
}
}
else if (FRAMEP (object))
{
f = XFRAME (object);
if (FRAME_MAC_P (f) && FRAME_LIVE_P (f))
return f;
}
return NULL;
}
/*
* Starting with the reference given by `ref_name`, follows symbolic
* references until a direct reference is found and updated the OID
* on that direct reference to `oid`.
*/
int git_reference__update_terminal(
git_repository *repo,
const char *ref_name,
const git_oid *oid,
const git_signature *sig,
const char *log_message)
{
git_reference *ref = NULL, *ref2 = NULL;
git_signature *who = NULL;
const git_signature *to_use;
int error = 0;
if (!sig && (error = git_reference__log_signature(&who, repo)) < 0)
return error;
to_use = sig ? sig : who;
error = get_terminal(&ref, repo, ref_name, 0);
/* found a dangling symref */
if (error == GIT_ENOTFOUND && ref) {
assert(git_reference_type(ref) == GIT_REF_SYMBOLIC);
giterr_clear();
error = reference__create(&ref2, repo, ref->target.symbolic, oid, NULL, 0, to_use,
log_message, NULL, NULL);
} else if (error == GIT_ENOTFOUND) {
giterr_clear();
error = reference__create(&ref2, repo, ref_name, oid, NULL, 0, to_use,
log_message, NULL, NULL);
} else if (error == 0) {
assert(git_reference_type(ref) == GIT_REF_OID);
error = reference__create(&ref2, repo, ref->name, oid, NULL, 1, to_use,
log_message, &ref->target.oid, NULL);
}
git_reference_free(ref2);
git_reference_free(ref);
git_signature_free(who);
return error;
}
Process *get_process(pid_t pid) {
/* TODO: Add test for invalid pid. Right now, we get a lot of errors and some
* structure.*/
Process *retval = (Process *)calloc(1, sizeof(Process));
unsigned int *uids = NULL;
unsigned int *gids = NULL;
retval->pid = pid;
retval->ppid = get_ppid(pid);
retval->name = get_procname(pid);
retval->exe = get_exe(pid);
retval->cmdline = get_cmdline(pid);
retval->create_time = get_create_time(pid);
uids = get_ids(pid, "Uid:");
if (uids) {
retval->uid = uids[0];
retval->euid = uids[1];
retval->suid = uids[2];
retval->username =
get_username(retval->uid); /* Uses real uid and not euid */
} else {
retval->uid = retval->euid = retval->suid = 0;
retval->username = NULL;
}
gids = get_ids(pid, "Gid:");
if (uids) {
retval->gid = gids[0];
retval->egid = gids[1];
retval->sgid = gids[2];
} else {
retval->uid = retval->euid = retval->suid = 0;
}
retval->terminal = get_terminal(pid);
free(uids);
free(gids);
return retval;
}
Process *
get_process(unsigned pid)
{
Process *retval = calloc(1, sizeof(Process));
unsigned int *uids = NULL;
unsigned int *gids = NULL;
retval->pid = pid;
retval->ppid = get_ppid(pid);
retval->name = get_procname(pid);
retval->exe = get_exe(pid);
retval->cmdline = get_cmdline(pid);
retval->create_time = get_create_time(pid);
uids = get_ids(pid, "Uid:");
if (uids) {
retval->uid = uids[0];
retval->euid = uids[1];
retval->suid = uids[2];
retval->username = get_username(retval->uid); /* Uses real uid and not euid */
} else {
retval->uid = retval->euid = retval->suid = 0;
retval->username = NULL;
}
gids = get_ids(pid, "Gid:");
if (uids) {
retval->gid = gids[0];
retval->egid = gids[1];
retval->sgid = gids[2];
} else {
retval->uid = retval->euid = retval->suid = 0;
}
retval->terminal = get_terminal(pid);
if (uids) free(uids);
if (gids) free(gids);
return retval;
}
/** Get all data from the procentry64 structure
*
* This is a poorly named function. It gets as much data out of the
* procentry64 structure as possible and places it in the psi_process
* structure.
*/
static int
set_bulk(struct psi_process *proci, const struct procentry64 *procent)
{
int pagesize;
int r;
proci->name = psi_strdup(procent->pi_comm);
if (proci->name == NULL)
return -1;
proci->name_status = PSI_STATUS_OK;
proci->exe = proci->name;
proci->exe_status = PSI_STATUS_OK;
proci->euid = procent->pi_cred.crx_uid;
proci->euid_status = PSI_STATUS_OK;
proci->ruid = procent->pi_cred.crx_ruid;
proci->ruid_status = PSI_STATUS_OK;
proci->egid = procent->pi_cred.crx_gid;
proci->egid_status = PSI_STATUS_OK;
proci->rgid = procent->pi_cred.crx_rgid;
proci->rgid_status = PSI_STATUS_OK;
proci->ppid = procent->pi_ppid;
proci->ppid_status = PSI_STATUS_OK;
proci->pgrp = procent->pi_pgrp;
proci->pgrp_status = PSI_STATUS_OK;
proci->sid = procent->pi_sid;
proci->sid_status = PSI_STATUS_OK;
proci->priority = procent->pi_ppri;
proci->priority_status = PSI_STATUS_OK;
proci->nice = procent->pi_nice;
proci->nice_status = PSI_STATUS_OK;
proci->start_time.tv_sec = procent->pi_start;
proci->start_time.tv_nsec = 0;
proci->start_time_status = PSI_STATUS_OK;
proci->status = procent->pi_state;
proci->status_status = PSI_STATUS_OK;
proci->nthreads = procent->pi_thcount;
proci->nthreads_status = PSI_STATUS_OK;
r = get_terminal(procent->pi_ttyd, &proci->terminal);
if (r == -1)
return -1;
else if (r == -2)
proci->terminal_status = PSI_STATUS_PRIVS;
else
proci->terminal_status = PSI_STATUS_OK;
/* The ru_utime and ru_stime members are `struct timeval64' which claims
* to contain microseconds in `tv_usec'. However all evidence suggests
* that it really is nanoseconds: (i) the values stored in it are larger
* then 1e6 and (ii) the results do match with ps(1) when treated as
* nanoseconds, but not when treated as micoseconds. */
proci->utime.tv_sec = procent->pi_ru.ru_utime.tv_sec;
proci->utime.tv_nsec = procent->pi_ru.ru_utime.tv_usec;
proci->utime_status = PSI_STATUS_OK;
proci->stime.tv_sec = procent->pi_ru.ru_stime.tv_sec;
proci->stime.tv_nsec = procent->pi_ru.ru_stime.tv_usec;
proci->stime_status = PSI_STATUS_OK;
/* There is a procent.pi_cpu which claims to be a tick count for the first
* thread, but I trust this more. */
proci->cputime.tv_sec = proci->utime.tv_sec + proci->stime.tv_sec;
proci->cputime.tv_sec +=
(proci->utime.tv_nsec + proci->stime.tv_nsec)/1000000000;
proci->cputime.tv_nsec =
(proci->utime.tv_nsec + proci->stime.tv_nsec)%1000000000;
proci->cputime_status = PSI_STATUS_OK;
pagesize = getpagesize();
proci->rss = (procent->pi_drss + procent->pi_trss) * pagesize;
proci->rss_status = PSI_STATUS_OK;
/* This is the same size as returned by ps(1) for VSZ. I don't believe
* it's correct however, it only contains the data sections of the virtual
* memory and omits the text size. None of the other values seem to give
* something useful either tho and there is something to be said for
* showing what ps shows. You can see the real value (in pagesizes) by
* using "svmon -P <pid>" and look in the "Virtual" column. */
proci->vsz = procent->pi_dvm * pagesize;
proci->vsz_status = PSI_STATUS_OK;
return 0;
}