/*
* Handle SIGWINCH. Order of calling various resize
* functions is really important.
*/
static void resize(void)
{
get_rows_cols(&screen_rows, &screen_cols);
resizeterm(screen_rows, screen_cols);
wresize(main_win, screen_rows-3, screen_cols);
win_init();
mvwin(help_win.wd, screen_rows - 1, 0);
// wnoutrefresh(help_win.wd);
// wnoutrefresh(info_win.wd);
/* set the cursor position if necessary */
if(current->cursor > current->rows)
current->cursor = current->rows;
werase(main_win);
current->redraw();
wnoutrefresh(main_win);
print_help();
pad_resize();
print_info();
update_load();
menu_resize();
box_resize();
info_resize();
doupdate();
size_changed = 0;
}
void update_pt(int frame){
// unset old page
int oldpage = vmem->pt.framepage[frame];
DEBUG(fprintf(stderr, "Update Table: Oldpage: %d OldFrame: %d\n", oldpage, frame));
update_unload(oldpage);
// update loaded state
update_load(frame);
}
/** Statistics callback to display userload.
* @param[in] sptr Client requesting statistics.
* @param[in] sd Stats descriptor for request (ignored).
* @param[in] param Extra parameter from user (ignored).
*/
void
calc_load(struct Client *sptr, const struct StatDesc *sd, char *param)
{
/* *INDENT-OFF* */
static const char *header =
/* ----.- ----.- ---- ---- ---- ------------ */
"Minute Hour Day Yest. YYest. Userload for:";
/* *INDENT-ON* */
static const char *what[3] = {
"local clients",
"total clients",
"total connections"
};
int i, j, times[5][3]; /* [min,hour,day,Yest,YYest]
[local,client,conn] */
int last_m_index = m_index, last_h_index = h_index;
update_load(); /* We want stats accurate as of *now* */
if (--last_m_index < 0)
last_m_index = 59;
times[0][0] = (cspm[last_m_index].local_count + 3) / 6;
times[0][1] = (cspm[last_m_index].client_count + 3) / 6;
times[0][2] = (cspm[last_m_index].conn_count + 3) / 6;
times[1][0] = (csph_sum.local_count + 180) / 360;
times[1][1] = (csph_sum.client_count + 180) / 360;
times[1][2] = (csph_sum.conn_count + 180) / 360;
for (i = 2; i < 5; ++i)
{
times[i][0] = 43200;
times[i][1] = 43200;
times[i][2] = 43200;
for (j = 0; j < 24; ++j)
{
if (--last_h_index < 0)
last_h_index = 71;
times[i][0] += csph[last_h_index].local_count;
times[i][1] += csph[last_h_index].client_count;
times[i][2] += csph[last_h_index].conn_count;
}
times[i][0] /= 86400;
times[i][1] /= 86400;
times[i][2] /= 86400;
}
sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :%s", sptr, header);
for (i = 0; i < 3; ++i)
sendcmdto_one(&me, CMD_NOTICE, sptr,
"%C :%4d.%1d %4d.%1d %4d %4d %4d %s", sptr,
times[0][i] / 10, times[0][i] % 10,
times[1][i] / 10, times[1][i] % 10,
times[2][i], times[3][i], times[4][i], what[i]);
}
/*
* Process these function after each TIMEOUT (default 3 seconds).
* Order is important because some windows are on the top
* of others.
*/
static void periodic(void)
{
check_wtmp();
update_load();
current->periodic();
wnoutrefresh(main_win);
wnoutrefresh(info_win.wd);
sub_periodic();
menu_refresh();
box_refresh();
info_refresh();
doupdate();
}
int
osc_configure_handler(const char *path, const char *types, lo_arg **argv,
int argc, lo_message msg, void *user_data)
{
char *key, *value;
if (argc < 2) {
GDB_MESSAGE(GDB_OSC, " error: too few arguments to osc_configure_handler\n");
return 1;
}
key = &argv[0]->s;
value = &argv[1]->s;
if (!strcmp(key, "load")) {
update_load(value);
} else if (!strcmp(key, "polyphony")) {
update_polyphony(value);
} else if (!strcmp(key, "monophonic")) {
update_monophonic(value);
} else if (!strcmp(key, "glide")) {
update_glide(value);
} else if (!strcmp(key, "program_cancel")) {
update_program_cancel(value);
} else if (!strcmp(key, DSSI_PROJECT_DIRECTORY_KEY)) {
update_project_directory(value);
} else {
return osc_debug_handler(path, types, argv, argc, msg, user_data);
}
return 0;
}
bool top_globalstats_update(void *ptr, const void *sample) {
const libtop_tsamp_t *tsamp = sample;
struct globalstat_controller *c = ptr;
int i;
if (!top_prefs_get_logging_mode()) {
for(i = 0; i < GLOBALSTAT_TOTAL; ++i) {
// MWW: If we've disabled framework logging one of these windows isn't valid and needs skipping
if (!top_prefs_get_frameworks() && (i == GLOBALSTAT_SHAREDLIBS)) continue;
werase(c->stats[i].window);
}
}
update_processes(c->stats + GLOBALSTAT_PROCESSES, tsamp);
update_load(c->stats + GLOBALSTAT_LOAD, tsamp);
update_cpu(c->stats + GLOBALSTAT_CPU, tsamp);
if(top_prefs_get_frameworks())
update_sharedlibs(c->stats + GLOBALSTAT_SHAREDLIBS, tsamp);
update_memregions(c->stats + GLOBALSTAT_MEMREGIONS, tsamp);
update_physmem(c->stats + GLOBALSTAT_PHYSMEM, tsamp);
update_vm(c->stats + GLOBALSTAT_VM, tsamp);
update_time(c->stats + GLOBALSTAT_TIME, tsamp);
if(top_prefs_get_swap()) {
update_swap(c->stats + GLOBALSTAT_SWAP, tsamp);
update_purgeable(c->stats + GLOBALSTAT_PURGEABLE, tsamp);
}
if(update_networks(c->stats + GLOBALSTAT_NETWORKS, tsamp))
top_log("An error occurred while updating the network global stats.\n");
if(update_disks(c->stats + GLOBALSTAT_DISKS, tsamp))
top_log("An erorr occurred while updating the disk global stats.\n");
return false;
}
/** Handle a SERVER message from an unregistered connection.
*
* \a parv has the following elements:
* \li \a parv[1] is the server name
* \li \a parv[2] is the hop count to the server
* \li \a parv[3] is the start timestamp for the server
* \li \a parv[4] is the link timestamp
* \li \a parv[5] is the protocol version (P10 or J10)
* \li \a parv[6] is the numnick mask for the server
* \li \a parv[7] is a string of flags like +hs to mark hubs and services
* \li \a parv[\a parc - 1] is the server description
*
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int mr_server(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
char* host;
struct ConfItem* aconf;
struct Jupe* ajupe;
unsigned int hop;
int ret;
unsigned short prot;
time_t start_timestamp;
time_t timestamp;
time_t recv_time;
time_t ghost;
if (IsUserPort(cptr))
return exit_client_msg(cptr, cptr, &me,
"Cannot connect a server to a user port");
if (parc < 8)
{
need_more_params(sptr, "SERVER");
return exit_client(cptr, cptr, &me, "Need more parameters");
}
host = clean_servername(parv[1]);
if (!host)
{
sendto_opmask(0, SNO_OLDSNO, "Bogus server name (%s) from %s",
host, cli_name(cptr));
return exit_client_msg(cptr, cptr, &me, "Bogus server name (%s)", host);
}
if ((ajupe = jupe_find(host)) && JupeIsActive(ajupe))
return exit_client_msg(cptr, sptr, &me, "Juped: %s", JupeReason(ajupe));
/* check connection rules */
if (0 != conf_eval_crule(host, CRULE_ALL)) {
ServerStats->is_ref++;
sendto_opmask(0, SNO_OLDSNO, "Refused connection from %s.", cli_name(cptr));
return exit_client(cptr, cptr, &me, "Disallowed by connection rule");
}
log_write(LS_NETWORK, L_NOTICE, LOG_NOSNOTICE, "SERVER: %s %s[%s]", host,
cli_sockhost(cptr), cli_sock_ip(cptr));
/*
* Detect protocol
*/
hop = atoi(parv[2]);
start_timestamp = atoi(parv[3]);
timestamp = atoi(parv[4]);
prot = parse_protocol(parv[5]);
if (!prot)
return exit_client_msg(cptr, sptr, &me, "Bogus protocol (%s)", parv[5]);
else if (prot < atoi(MINOR_PROTOCOL))
return exit_new_server(cptr, sptr, host, timestamp,
"Incompatible protocol: %s", parv[5]);
Debug((DEBUG_INFO, "Got SERVER %s with timestamp [%s] age %Tu (%Tu)",
host, parv[4], start_timestamp, cli_serv(&me)->timestamp));
if (timestamp < OLDEST_TS || start_timestamp < OLDEST_TS)
return exit_client_msg(cptr, sptr, &me,
"Bogus timestamps (%s %s)", parv[3], parv[4]);
/* If the server had a different name before, change it. */
if (!EmptyString(cli_name(cptr)) &&
(IsUnknown(cptr) || IsHandshake(cptr)) &&
0 != ircd_strcmp(cli_name(cptr), host))
hChangeClient(cptr, host);
ircd_strncpy(cli_name(cptr), host, HOSTLEN);
ircd_strncpy(cli_info(cptr), parv[parc-1][0] ? parv[parc-1] : cli_name(&me), REALLEN);
cli_hopcount(cptr) = hop;
if (conf_check_server(cptr)) {
++ServerStats->is_ref;
sendto_opmask(0, SNO_OLDSNO, "Received unauthorized connection from %s",
cli_name(cptr));
log_write(LS_NETWORK, L_NOTICE, LOG_NOSNOTICE, "Received unauthorized "
"connection from %C [%s]", cptr,
ircd_ntoa(&cli_ip(cptr)));
return exit_client(cptr, cptr, &me, "No Connect block");
}
host = cli_name(cptr);
update_load();
if (!(aconf = find_conf_byname(cli_confs(cptr), host, CONF_SERVER))) {
++ServerStats->is_ref;
sendto_opmask(0, SNO_OLDSNO, "Access denied. No conf line for server %s",
cli_name(cptr));
return exit_client_msg(cptr, cptr, &me,
"Access denied. No conf line for server %s", cli_name(cptr));
}
#if defined(USE_SSL)
if (!verify_sslclifp(cptr, aconf)) {
++ServerStats->is_ref;
sendto_opmask(0, SNO_OLDSNO, "Access denied (SSL fingerprint mismatch) %s",
cli_name(cptr));
return exit_client_msg(cptr, cptr, &me,
"No Access (SSL fingerprint mismatch) %s", cli_name(cptr));
}
#endif
if (*aconf->passwd && !!strcmp(aconf->passwd, cli_passwd(cptr))) {
++ServerStats->is_ref;
sendto_opmask(0, SNO_OLDSNO, "Access denied (passwd mismatch) %s",
cli_name(cptr));
return exit_client_msg(cptr, cptr, &me,
"No Access (passwd mismatch) %s", cli_name(cptr));
}
memset(cli_passwd(cptr), 0, sizeof(cli_passwd(cptr)));
ret = check_loop_and_lh(cptr, sptr, &ghost, host, (parc > 7 ? parv[6] : NULL), timestamp, hop, 1);
if (ret != 1)
return ret;
make_server(cptr);
cli_serv(cptr)->timestamp = timestamp;
cli_serv(cptr)->prot = prot;
cli_serv(cptr)->ghost = ghost;
memset(cli_privs(cptr), 255, sizeof(struct Privs));
ClrPriv(cptr, PRIV_SET);
SetServerYXX(cptr, cptr, parv[6]);
update_uworld_flags(cptr);
if (*parv[7] == '+')
set_server_flags(cptr, parv[7] + 1);
recv_time = TStime();
check_start_timestamp(cptr, timestamp, start_timestamp, recv_time);
ret = server_estab(cptr, aconf);
if (feature_bool(FEAT_RELIABLE_CLOCK) &&
abs(cli_serv(cptr)->timestamp - recv_time) > 30) {
sendto_opmask(0, SNO_OLDSNO, "Connected to a net with a "
"timestamp-clock difference of %Td seconds! "
"Used SETTIME to correct this.",
timestamp - recv_time);
sendcmdto_prio_one(&me, CMD_SETTIME, cptr, "%Tu :%s", TStime(),
cli_name(&me));
}
return ret;
}
int cardpeek_update_perform(void)
{
const char* cardpeek_update_file = path_config_get_string(PATH_CONFIG_FILE_CARDPEEK_UPDATE);
a_string_t *contents;
update_t *update;
int remove;
update_item_t *item;
time_t now = time(NULL);
int updated = 0;
char *url = NULL;
char *local_file;
char *local_dnld;
unsigned char digest[SHA256_DIGEST_LENGTH];
a_string_t *url_request;
unsigned first_update;
first_update = (unsigned)luax_variable_get_integer("cardpeek.updates.first_update");
/* STEP 1: get cardpeek.update file */
url=luax_variable_get_strdup("cardpeek.updates.url");
if (url==NULL)
url = g_strdup(DEFAULT_UPDATE_URL);
log_printf(LOG_INFO,"Fetching '%s'",url);
url_request = a_strnew(NULL);
a_sprintf(url_request,"%s?u=%x&v=%s",url,first_update,VERSION);
if (http_download(a_strval(url_request),cardpeek_update_file)==0)
{
g_free(url);
return 0;
}
g_free(url);
a_strfree(url_request);
/* STEP 2: parse file */
if ((contents=file_get_contents(cardpeek_update_file))==NULL)
{
log_printf(LOG_ERROR,"failed to read update file information.");
unlink(cardpeek_update_file);
return 0;
}
update = update_new();
if ((update_load(update,a_strval(contents),a_strlen(contents)))==0)
{
unlink(cardpeek_update_file);
a_strfree(contents);
update_free(update);
return 0;
}
a_strfree(contents);
/* log_printf(LOG_DEBUG,"Updates correctly loaded from '%s'",cardpeek_update_file); */
if ((remove = update_filter_version(update,VERSION))>0)
log_printf(LOG_WARNING,"%d updates will not be installed because they require a newer version of Cardpeek.");
remove = update_filter_files(update);
if (update->item_count)
log_printf(LOG_INFO,"A total of %d files will be updated, %d files are kept unchanged.",update->item_count,remove);
else
log_printf(LOG_INFO,"No files will be updated, %d files are kept unchanged.",remove);
item = update->items;
while (item)
{
local_dnld = new_path(PATH_CONFIG_FOLDER_CARDPEEK,item->file,".download");
local_file = new_path(PATH_CONFIG_FOLDER_CARDPEEK,item->file,NULL);
if (http_download(item->url,local_dnld)!=0)
{
if (sha256sum(local_dnld,digest))
{
if (memcmp(digest,bytestring_get_data(&item->digest),SHA256_DIGEST_LENGTH)==0)
{
unlink(local_file);
if (rename(local_dnld,local_file)==0)
{
log_printf(LOG_INFO,"Successfuly updated %s", local_file);
updated++;
}
else
{
log_printf(LOG_ERROR,"Failed to copy %s to %s: %s",
local_dnld,
local_file,
strerror(errno));
}
}
else
{
log_printf(LOG_WARNING,"File %s was not updated: authentication failed.",local_file);
}
}
unlink(local_dnld);
}
g_free(local_dnld);
g_free(local_file);
item = item->next;
}
if (updated == update->item_count)
{
luax_variable_set_integer("cardpeek.updates.next_update",(int)(now+7*(24*3600)));
luax_config_table_save();
}
unlink(cardpeek_update_file);
update_free(update);
/* STEP 3: finish */
return 1;
}
static void cpufreq_interactive_timer(unsigned long data)
{
u64 now;
unsigned int delta_time;
u64 cputime_speedadj;
int cpu_load;
struct cpufreq_interactive_cpuinfo *pcpu =
&per_cpu(cpuinfo, data);
unsigned int new_freq;
unsigned int loadadjfreq;
unsigned int index;
unsigned long flags;
bool boosted;
unsigned long mod_min_sample_time;
int i, max_load;
unsigned int max_freq;
unsigned int boosted_freq;
struct cpufreq_interactive_cpuinfo *picpu;
if (!down_read_trylock(&pcpu->enable_sem))
return;
if (!pcpu->governor_enabled)
goto exit;
spin_lock_irqsave(&pcpu->load_lock, flags);
pcpu->last_evaluated_jiffy = get_jiffies_64();
now = update_load(data);
if (use_sched_hint) {
/*
* Unlock early to avoid deadlock.
*
* cpufreq_interactive_timer_resched_now() is called
* in thread migration notification which already holds
* rq lock. Then it locks load_lock to avoid racing with
* cpufreq_interactive_timer_resched/start().
* sched_get_busy() will also acquire rq lock. Thus we
* can't hold load_lock when calling sched_get_busy().
*
* load_lock used in this function protects time
* and load information. These stats are not used when
* scheduler hint is available. Thus unlocking load_lock
* early is perfectly OK.
*/
spin_unlock_irqrestore(&pcpu->load_lock, flags);
cputime_speedadj = (u64)sched_get_busy(data) *
pcpu->policy->cpuinfo.max_freq;
do_div(cputime_speedadj, timer_rate);
} else {
delta_time = (unsigned int)
(now - pcpu->cputime_speedadj_timestamp);
cputime_speedadj = pcpu->cputime_speedadj;
spin_unlock_irqrestore(&pcpu->load_lock, flags);
if (WARN_ON_ONCE(!delta_time))
goto rearm;
do_div(cputime_speedadj, delta_time);
}
spin_lock_irqsave(&pcpu->target_freq_lock, flags);
loadadjfreq = (unsigned int)cputime_speedadj * 100;
cpu_load = loadadjfreq / pcpu->target_freq;
pcpu->prev_load = cpu_load;
boosted = boost_val || now < boostpulse_endtime;
boosted_freq = max(hispeed_freq, pcpu->policy->min);
if (cpu_load >= go_hispeed_load || boosted) {
if (pcpu->target_freq < boosted_freq) {
new_freq = boosted_freq;
} else {
new_freq = choose_freq(pcpu, loadadjfreq);
if (new_freq > freq_calc_thresh)
new_freq = pcpu->policy->max * cpu_load / 100;
if (new_freq < boosted_freq)
new_freq = boosted_freq;
}
} else {
new_freq = choose_freq(pcpu, loadadjfreq);
if (new_freq > freq_calc_thresh)
new_freq = pcpu->policy->max * cpu_load / 100;
if (sync_freq && new_freq < sync_freq) {
max_load = 0;
max_freq = 0;
for_each_online_cpu(i) {
picpu = &per_cpu(cpuinfo, i);
if (i == data || picpu->prev_load <
up_threshold_any_cpu_load)
continue;
max_load = max(max_load, picpu->prev_load);
max_freq = max(max_freq, picpu->target_freq);
}
if (max_freq > up_threshold_any_cpu_freq ||
max_load >= up_threshold_any_cpu_load)
new_freq = sync_freq;
}
}
int update_tftp(ulong addr, char *interface, char *devstring)
{
char *filename, *env_addr, *fit_image_name;
ulong update_addr, update_fladdr, update_size;
int images_noffset, ndepth, noffset;
bool update_tftp_dfu;
int ret = 0;
void *fit;
if (interface == NULL && devstring == NULL) {
update_tftp_dfu = false;
} else if (interface && devstring) {
update_tftp_dfu = true;
} else {
error("Interface: %s and devstring: %s not supported!\n",
interface, devstring);
return -EINVAL;
}
/* use already present image */
if (addr)
goto got_update_file;
printf("Auto-update from TFTP: ");
/* get the file name of the update file */
filename = getenv(UPDATE_FILE_ENV);
if (filename == NULL) {
printf("failed, env. variable '%s' not found\n",
UPDATE_FILE_ENV);
return 1;
}
printf("trying update file '%s'\n", filename);
/* get load address of downloaded update file */
if ((env_addr = getenv("loadaddr")) != NULL)
addr = simple_strtoul(env_addr, NULL, 16);
else
addr = CONFIG_UPDATE_LOAD_ADDR;
if (update_load(filename, CONFIG_UPDATE_TFTP_MSEC_MAX,
CONFIG_UPDATE_TFTP_CNT_MAX, addr)) {
printf("Can't load update file, aborting auto-update\n");
return 1;
}
got_update_file:
fit = (void *)addr;
if (!fit_check_format((void *)fit)) {
printf("Bad FIT format of the update file, aborting "
"auto-update\n");
return 1;
}
/* process updates */
images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
ndepth = 0;
noffset = fdt_next_node(fit, images_noffset, &ndepth);
while (noffset >= 0 && ndepth > 0) {
if (ndepth != 1)
goto next_node;
fit_image_name = (char *)fit_get_name(fit, noffset, NULL);
printf("Processing update '%s' :", fit_image_name);
if (!fit_image_verify(fit, noffset)) {
printf("Error: invalid update hash, aborting\n");
ret = 1;
goto next_node;
}
printf("\n");
if (update_fit_getparams(fit, noffset, &update_addr,
&update_fladdr, &update_size)) {
printf("Error: can't get update parameteres, "
"aborting\n");
ret = 1;
goto next_node;
}
if (!update_tftp_dfu) {
if (update_flash(update_addr, update_fladdr,
update_size)) {
printf("Error: can't flash update, aborting\n");
ret = 1;
goto next_node;
}
} else if (fit_image_check_type(fit, noffset,
IH_TYPE_FIRMWARE)) {
ret = dfu_tftp_write(fit_image_name, update_addr,
update_size, interface, devstring);
if (ret)
return ret;
}
next_node:
noffset = fdt_next_node(fit, noffset, &ndepth);
}
return ret;
}
void calc_load(aClient *sptr, char *parv) /* we only get passed the original parv[0] */
{
struct load_entry *cur_load_entry;
struct load_entry *last = NULL;
u_long secs = 0, adj_secs, total[2], adj[2];/*[client,conn]*/
int i, times[5][2]; /* [min,hour,day,Yest,YYest][client,conn] */
char what[2][HOSTLEN + 1 + 10];
bzero(total, 2 * sizeof(u_long));
current_load_data.entries = 0;
update_load(); /* we want stats accurate as of *now* */
for (cur_load_entry = load_list_tail; (secs < 6000) &&
(cur_load_entry != NULL); cur_load_entry = cur_load_entry->prev) {
u_long time_incr = cur_load_entry->time_incr;
total[0] += time_incr * cur_load_entry->client_count;
total[1] += time_incr * cur_load_entry->conn_count;
last = cur_load_entry;
secs += cur_load_entry->time_incr;
current_load_data.entries++;
}
if ((secs > 6000) && (last != NULL)) {
adj_secs = secs - 6000;
adj[0] = adj_secs * last->client_count;
adj[1] = adj_secs * last->conn_count;
} else
adj_secs = adj[0] = adj[1] = 0;
for (i = 0; i < 2; i++) {
times[0][i] = ((total[i] - adj[i]) * 1000 / (secs - adj_secs) + 5) / 10;
}
secs = (secs + 5) / 10;
for (i = 0; i < 2; i++)
total[i] = (total[i] + 5) / 10;
for ( ; (secs < 36000) && (cur_load_entry != NULL); secs +=
(cur_load_entry->time_incr + 5) / 10, cur_load_entry =
cur_load_entry->prev, current_load_data.entries++) {
u_long time_incr = (cur_load_entry->time_incr + 5) / 10;
total[0] += time_incr * cur_load_entry->client_count;
total[1] += time_incr * cur_load_entry->conn_count;
last = cur_load_entry;
}
if ((secs > 36000) && (last != NULL)) {
adj_secs = secs - 36000;
adj[0] = adj_secs * last->client_count;
adj[1] = adj_secs * last->conn_count;
} else
adj_secs = adj[0] = adj[1] = 0;
for (i = 0; i < 2; i++) {
times[1][i] = ((total[i] - adj[i]) * 100 / (secs - adj_secs) + 5) / 10;
}
secs = (secs + 5) / 10;
for (i = 0; i < 2; i++)
total[i] = (total[i] + 5) / 10;
for ( ; (secs < 86400) && (cur_load_entry != NULL); secs +=
(cur_load_entry->time_incr + 50) / 100, cur_load_entry =
cur_load_entry->prev, current_load_data.entries++) {
u_long time_incr = (cur_load_entry->time_incr + 50) / 100;
total[0] += time_incr * cur_load_entry->client_count;
total[1] += time_incr * cur_load_entry->conn_count;
last = cur_load_entry;
}
if ((secs > 86400) && (last != NULL)) {
adj_secs = secs - 86400;
adj[0] = adj_secs * last->client_count;
adj[1] = adj_secs * last->conn_count;
} else
adj_secs = adj[0] = adj[1] = 0;
for (i = 0; i < 2; i++) {
times[2][i] = ((total[i] - adj[i]) * 10 / (secs - adj_secs) + 5) / 10;
}
bzero(total, 2 * sizeof(u_long));
for (secs = 1 ; (secs < 86400) && (cur_load_entry != NULL); secs +=
(cur_load_entry->time_incr + 50) / 100, cur_load_entry =
cur_load_entry->prev, current_load_data.entries++) {
u_long time_incr = (cur_load_entry->time_incr + 50) / 100;
total[0] += time_incr * cur_load_entry->client_count;
total[1] += time_incr * cur_load_entry->conn_count;
last = cur_load_entry;
}
if ((secs > 86400) && (last != NULL)) {
adj_secs = secs - 86400;
adj[0] = adj_secs * last->client_count;
adj[1] = adj_secs * last->conn_count;
} else
adj_secs = adj[0] = adj[1] = 0;
for (i = 0; i < 2; i++) {
times[3][i] = ((total[i] - adj[i]) * 10 / (secs - adj_secs) + 5) / 10;
}
bzero(total, 2 * sizeof(u_long));
for (secs = 1 ; (secs < 86400) && (cur_load_entry != NULL); secs +=
(cur_load_entry->time_incr + 50) / 100, cur_load_entry =
cur_load_entry->prev, current_load_data.entries++) {
u_long time_incr = (cur_load_entry->time_incr + 50) / 100;
total[0] += time_incr * cur_load_entry->client_count;
total[1] += time_incr * cur_load_entry->conn_count;
last = cur_load_entry;
}
if ((secs > 86400) && (last != NULL)) {
adj_secs = secs - 86400;
adj[0] = adj_secs * last->client_count;
adj[1] = adj_secs * last->conn_count;
} else
adj_secs = adj[0] = adj[1] = 0;
for (i = 0; i < 2; i++) {
times[4][i] = ((total[i] - adj[i]) * 10 / (secs - adj_secs) + 5) / 10;
}
if ((cur_load_entry != NULL) && (cur_load_entry->prev != NULL) &&
(secs > 86400)) { /* have nodes to free -- more than 3 days old */
struct load_entry *cur_free_entry = load_free_head;
load_free_head = load_list_head;
load_list_head = cur_load_entry;
if (cur_free_entry != NULL)
cur_free_entry->prev = cur_load_entry->prev;
else
load_free_tail = cur_load_entry->prev;
/* printf("freeing: %x (head: %x, tail: %x)\n", cur_load_entry->prev,
load_free_head, load_free_tail); */
cur_load_entry->prev = NULL;
}
strcpy(what[0], "total clients");
strcpy(what[1], "total connections");
sendto_one(sptr,
":%s NOTICE %s :Minute Hour Day Yest. YYest. Userload for:",
me.name, parv);
for (i = 0; i < 2; i++)
sendto_one(sptr,
":%s NOTICE %s :%3d.%02d %3d.%01d %3d %3d %3d %s",
me.name, parv, times[0][i] / 100, times[0][i] % 100, times[1][i] / 10,
times[1][i] % 10, times[2][i], times[3][i], times[4][i], what[i]);
}
static void cpufreq_interactive_timer(unsigned long data)
{
u64 now;
unsigned int delta_time;
u64 cputime_speedadj;
int cpu_load;
struct cpufreq_interactive_cpuinfo *pcpu =
&per_cpu(cpuinfo, data);
unsigned int new_freq;
unsigned int loadadjfreq;
unsigned int index;
unsigned long flags;
bool boosted;
unsigned long mod_min_sample_time;
int i, max_load;
unsigned int max_freq;
struct cpufreq_interactive_cpuinfo *picpu;
static unsigned int phase = 0;
static unsigned int counter = 0;
unsigned int nr_cpus;
if (!down_read_trylock(&pcpu->enable_sem))
return;
if (!pcpu->governor_enabled)
goto exit;
if (cpu_is_offline(data))
goto exit;
spin_lock_irqsave(&pcpu->load_lock, flags);
now = update_load(data);
delta_time = (unsigned int)(now - pcpu->cputime_speedadj_timestamp);
cputime_speedadj = pcpu->cputime_speedadj;
spin_unlock_irqrestore(&pcpu->load_lock, flags);
if (WARN_ON_ONCE(!delta_time))
goto rearm;
do_div(cputime_speedadj, delta_time);
loadadjfreq = (unsigned int)cputime_speedadj * 100;
cpu_load = loadadjfreq / pcpu->target_freq;
pcpu->prev_load = cpu_load;
boosted = now < (last_input_time + boostpulse_duration_val);
/*
if (counter < 5) {
counter++;
if (counter > 2) {
phase = 1;
}
}*/
if (cpu_load >= go_hispeed_load) {
if (pcpu->target_freq < hispeed_freq) {
//nr_cpus = num_online_cpus();
//pcpu->two_phase_freq = two_phase_freq_array[nr_cpus-1];
//if (pcpu->two_phase_freq < pcpu->policy->cur)
// phase = 1;
//if (pcpu->two_phase_freq != 0 && phase == 0) {
// new_freq = pcpu->two_phase_freq;
//} else
new_freq = hispeed_freq;
} else {
new_freq = choose_freq(pcpu, loadadjfreq);
if (new_freq < hispeed_freq)
new_freq = hispeed_freq;
}
} else {
new_freq = choose_freq(pcpu, loadadjfreq);
if (sync_freq && new_freq < sync_freq) {
max_load = 0;
max_freq = 0;
for_each_online_cpu(i) {
picpu = &per_cpu(cpuinfo, i);
if (i == data || picpu->prev_load <
up_threshold_any_cpu_load)
continue;
max_load = max(max_load, picpu->prev_load);
max_freq = max(max_freq, picpu->policy->cur);
}
if (max_freq > up_threshold_any_cpu_freq &&
max_load >= up_threshold_any_cpu_load)
new_freq = sync_freq;
}
}
/**
* Exits a client of *any* type (user, server, etc)
* from this server. Also, this generates all necessary prototol
* messages that this exit may cause.
*
* This function implicitly exits all other clients depending on
* this connection.
*
* For convenience, this function returns a suitable value for
* m_function return value:
*
* CPTR_KILLED if (cptr == bcptr)
* 0 if (cptr != bcptr)
*
* This function can be called in two ways:
* 1) From before or in parse(), exiting the 'cptr', in which case it was
* invoked as exit_client(cptr, cptr, &me,...), causing it to always
* return CPTR_KILLED.
* 2) Via parse from a m_function call, in which case it was invoked as
* exit_client(cptr, acptr, sptr, ...). Here 'sptr' is known; the client
* that generated the message in a way that we can assume he already
* did remove acptr from memory himself (or in other cases we don't mind
* because he will be delinked.) Or invoked as:
* exit_client(cptr, acptr/sptr, &me, ...) when WE decide this one should
* be removed.
* In general: No generated SQUIT or QUIT should be sent to source link
* sptr->from. And CPTR_KILLED should be returned if cptr got removed (too).
*
* --Run
* @param cptr Connection currently being handled by read_message.
* @param victim Client being killed.
* @param killer Client that made the decision to remove \a victim.
* @param comment Reason for the exit.
* @return CPTR_KILLED if cptr == bcptr, else 0.
*/
int exit_client(struct Client *cptr,
struct Client* victim,
struct Client* killer,
const char* comment)
{
struct Client* acptr = 0;
struct DLink *dlp;
time_t on_for;
char comment1[HOSTLEN + HOSTLEN + 2];
assert(killer);
if (MyConnect(victim))
{
SetFlag(victim, FLAG_CLOSING);
if (feature_bool(FEAT_CONNEXIT_NOTICES) && IsUser(victim))
sendto_opmask_butone(0, SNO_CONNEXIT,
"Client exiting: %s (%s@%s) [%s] [%s] <%s%s>",
cli_name(victim), cli_user(victim)->username,
cli_user(victim)->host, comment,
ircd_ntoa(&cli_ip(victim)),
NumNick(victim) /* two %s's */);
update_load();
on_for = CurrentTime - cli_firsttime(victim);
if (IsUser(victim) || IsUserPort(victim))
auth_send_exit(victim);
if (IsUser(victim))
log_write(LS_USER, L_TRACE, 0, "%Tu %i %s@%s %s %s %s%s %s :%s",
cli_firsttime(victim), on_for,
cli_user(victim)->username, cli_sockhost(victim),
ircd_ntoa(&cli_ip(victim)),
IsAccount(victim) ? cli_username(victim) : "0",
NumNick(victim), /* two %s's */
cli_name(victim), cli_info(victim));
if (victim != cli_from(killer) /* The source knows already */
&& IsClient(victim)) /* Not a Ping struct or Log file */
{
if (IsServer(victim) || IsHandshake(victim))
sendcmdto_one(killer, CMD_SQUIT, victim, "%s 0 :%s", cli_name(&me), comment);
else if (!IsConnecting(victim)) {
if (!IsDead(victim)) {
if (IsServer(victim))
sendcmdto_one(killer, CMD_ERROR, victim,
":Closing Link: %s by %s (%s)", cli_name(victim),
cli_name(killer), comment);
else
sendrawto_one(victim, MSG_ERROR " :Closing Link: %s by %s (%s)",
cli_name(victim),
cli_name(IsServer(killer) ? &his : killer),
comment);
}
}
if ((IsServer(victim) || IsHandshake(victim) || IsConnecting(victim)) &&
(killer == &me || (IsServer(killer) &&
(strncmp(comment, "Leaf-only link", 14) ||
strncmp(comment, "Non-Hub link", 12)))))
{
/*
* Note: check user == user needed to make sure we have the same
* client
*/
if (cli_serv(victim)->user && *(cli_serv(victim))->by &&
(acptr = findNUser(cli_serv(victim)->by))) {
if (cli_user(acptr) == cli_serv(victim)->user) {
sendcmdto_one(&me, CMD_NOTICE, acptr,
"%C :Link with %s canceled: %s", acptr,
cli_name(victim), comment);
}
else {
/*
* not right client, set by to empty string
*/
acptr = 0;
*(cli_serv(victim))->by = '\0';
}
}
if (killer == &me)
sendto_opmask_butone(acptr, SNO_OLDSNO, "Link with %s canceled: %s",
cli_name(victim), comment);
}
}
/*
* Close the Client connection first.
*/
close_connection(victim);
}
if (IsServer(victim))
{
if (feature_bool(FEAT_HIS_NETSPLIT))
strcpy(comment1, "*.net *.split");
else
{
strcpy(comment1, cli_name(cli_serv(victim)->up));
strcat(comment1, " ");
strcat(comment1, cli_name(victim));
}
if (IsUser(killer))
sendto_opmask_butone(killer, SNO_OLDSNO, "%s SQUIT by %s [%s]:",
(cli_user(killer)->server == victim ||
cli_user(killer)->server == cli_serv(victim)->up) ?
"Local" : "Remote",
get_client_name(killer, HIDE_IP),
cli_name(cli_user(killer)->server));
else if (killer != &me && cli_serv(victim)->up != killer)
sendto_opmask_butone(0, SNO_OLDSNO, "Received SQUIT %s from %s :",
cli_name(victim), IsServer(killer) ? cli_name(killer) :
get_client_name(killer, HIDE_IP));
sendto_opmask_butone(0, SNO_NETWORK, "Net break: %C %C (%s)",
cli_serv(victim)->up, victim, comment);
}
/*
* First generate the needed protocol for the other server links
* except the source:
*/
for (dlp = cli_serv(&me)->down; dlp; dlp = dlp->next) {
if (dlp->value.cptr != cli_from(killer) && dlp->value.cptr != victim)
{
if (IsServer(victim))
sendcmdto_one(killer, CMD_SQUIT, dlp->value.cptr, "%s %Tu :%s",
cli_name(victim), cli_serv(victim)->timestamp, comment);
else if (IsUser(victim) && !HasFlag(victim, FLAG_KILLED))
sendcmdto_one(victim, CMD_QUIT, dlp->value.cptr, ":%s", comment);
}
}
/* Then remove the client structures */
if (IsServer(victim))
exit_downlinks(victim, killer, comment1);
exit_one_client(victim, comment);
/*
* cptr can only have been killed if it was cptr itself that got killed here,
* because cptr can never have been a dependent of victim --Run
*/
return (cptr == victim) ? CPTR_KILLED : 0;
}
int update_tftp(ulong addr)
{
char *filename, *env_addr;
int images_noffset, ndepth, noffset;
ulong update_addr, update_fladdr, update_size;
void *fit;
int ret = 0;
/* use already present image */
if (addr)
goto got_update_file;
printf("Auto-update from TFTP: ");
/* get the file name of the update file */
filename = getenv(UPDATE_FILE_ENV);
if (filename == NULL) {
printf("failed, env. variable '%s' not found\n",
UPDATE_FILE_ENV);
return 1;
}
printf("trying update file '%s'\n", filename);
/* get load address of downloaded update file */
if ((env_addr = getenv("loadaddr")) != NULL)
addr = simple_strtoul(env_addr, NULL, 16);
else
addr = CONFIG_UPDATE_LOAD_ADDR;
if (update_load(filename, CONFIG_UPDATE_TFTP_MSEC_MAX,
CONFIG_UPDATE_TFTP_CNT_MAX, addr)) {
printf("Can't load update file, aborting auto-update\n");
return 1;
}
got_update_file:
fit = (void *)addr;
if (!fit_check_format((void *)fit)) {
printf("Bad FIT format of the update file, aborting "
"auto-update\n");
return 1;
}
/* process updates */
images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
ndepth = 0;
noffset = fdt_next_node(fit, images_noffset, &ndepth);
while (noffset >= 0 && ndepth > 0) {
if (ndepth != 1)
goto next_node;
printf("Processing update '%s' :",
fit_get_name(fit, noffset, NULL));
if (!fit_image_verify(fit, noffset)) {
printf("Error: invalid update hash, aborting\n");
ret = 1;
goto next_node;
}
printf("\n");
if (update_fit_getparams(fit, noffset, &update_addr,
&update_fladdr, &update_size)) {
printf("Error: can't get update parameteres, "
"aborting\n");
ret = 1;
goto next_node;
}
if (update_flash(update_addr, update_fladdr, update_size)) {
printf("Error: can't flash update, aborting\n");
ret = 1;
goto next_node;
}
next_node:
noffset = fdt_next_node(fit, noffset, &ndepth);
}
return ret;
}
/** Initialize the userload statistics. */
void initload(void)
{
memset(¤t_load, 0, sizeof(current_load));
update_load(); /* Initialize the load list */
}
int main (int argc, char **argv)
{
struct timeval tv;
#ifdef HAVE_LIBKVM
if (kvm_init()) can_use_kvm = 1;
#endif
#ifdef DEBUG
if (!(debug_file = fopen("debug", "w"))) {
printf("file debug open error\n");
exit(0);
}
#endif
get_boot_time();
get_rows_cols(&screen_rows, &screen_cols);
buf_size = screen_cols + screen_cols/2;
line_buf = malloc(buf_size);
if (!line_buf)
errx(1, "Cannot allocate memory for buffer.");
curses_init();
current = &users_list;
users_init();
procwin_init();
subwin_init();
menu_init();
signal(SIGINT, int_handler);
signal(SIGWINCH, winch_handler);
// signal(SIGSEGV, segv_handler);
print_help();
update_load();
current->redraw();
wnoutrefresh(main_win);
wnoutrefresh(info_win.wd);
wnoutrefresh(help_win.wd);
doupdate();
tv.tv_sec = TIMEOUT;
tv.tv_usec = 0;
for(;;) { /* main loop */
#ifndef RETURN_TV_IN_SELECT
struct timeval before;
struct timeval after;
#endif
fd_set rfds;
int retval;
FD_ZERO(&rfds);
FD_SET(STDIN_FILENO,&rfds);
#ifdef RETURN_TV_IN_SELECT
retval = select(1, &rfds, 0, 0, &tv);
if(retval > 0) {
int key = read_key();
key_action(key);
}
if (!tv.tv_sec && !tv.tv_usec){
ticks++;
periodic();
tv.tv_sec = TIMEOUT;
}
#else
gettimeofday(&before, 0);
retval = select(1, &rfds, 0, 0, &tv);
gettimeofday(&after, 0);
tv.tv_sec -= (after.tv_sec - before.tv_sec);
if(retval > 0) {
int key = read_key();
key_action(key);
}
if(tv.tv_sec <= 0) {
ticks++;
periodic();
tv.tv_sec = TIMEOUT;
}
#endif
if (size_changed) resize();
}
}
static void cpufreq_interactive_timer(unsigned long data)
{
u64 now;
unsigned int delta_time;
u64 cputime_speedadj;
int cpu_load;
struct cpufreq_interactive_cpuinfo *pcpu =
&per_cpu(cpuinfo, data);
unsigned int new_freq;
unsigned int loadadjfreq;
unsigned int index;
unsigned long flags;
bool boosted;
unsigned long mod_min_sample_time;
int i, max_load;
unsigned int max_freq;
struct cpufreq_interactive_cpuinfo *picpu;
if (!down_read_trylock(&pcpu->enable_sem))
return;
if (!pcpu->governor_enabled)
goto exit;
spin_lock_irqsave(&pcpu->load_lock, flags);
now = update_load(data);
delta_time = (unsigned int)(now - pcpu->cputime_speedadj_timestamp);
cputime_speedadj = pcpu->cputime_speedadj;
spin_unlock_irqrestore(&pcpu->load_lock, flags);
if (!delta_time)
goto rearm;
do_div(cputime_speedadj, delta_time);
loadadjfreq = (unsigned int)cputime_speedadj * 100;
cpu_load = loadadjfreq / pcpu->target_freq;
pcpu->prev_load = cpu_load;
boosted = now < (last_input_time + boostpulse_duration_val);
if (cpu_load >= go_hispeed_load)
{
if (pcpu->target_freq < hispeed_freq)
new_freq = hispeed_freq;
else
{
new_freq = choose_freq(pcpu, loadadjfreq);
if (new_freq < hispeed_freq)
new_freq = hispeed_freq;
}
}
else
{
new_freq = choose_freq(pcpu, loadadjfreq);
if (sync_freq && new_freq < sync_freq) {
max_load = 0;
max_freq = 0;
for_each_online_cpu(i) {
picpu = &per_cpu(cpuinfo, i);
if (i == data || picpu->prev_load <
up_threshold_any_cpu_load)
continue;
max_load = max(max_load, picpu->prev_load);
max_freq = max(max_freq, picpu->target_freq);
}
if (max_freq > up_threshold_any_cpu_freq &&
max_load >= up_threshold_any_cpu_load)
new_freq = sync_freq;
}
}
static void cpufreq_interactive_timer(unsigned long data)
{
u64 now;
unsigned int delta_time;
u64 cputime_speedadj;
int cpu_load;
struct cpufreq_interactive_cpuinfo *pcpu =
&per_cpu(cpuinfo, data);
unsigned int new_freq;
unsigned int loadadjfreq;
unsigned int index;
unsigned long flags;
bool boosted;
unsigned long mod_min_sample_time;
int i, max_load;
unsigned int max_freq;
unsigned int boosted_freq;
struct cpufreq_interactive_cpuinfo *picpu;
if (!down_read_trylock(&pcpu->enable_sem))
return;
if (!pcpu->governor_enabled)
goto exit;
spin_lock_irqsave(&pcpu->load_lock, flags);
now = update_load(data);
delta_time = (unsigned int)(now - pcpu->cputime_speedadj_timestamp);
cputime_speedadj = pcpu->cputime_speedadj;
pcpu->last_evaluated_jiffy = get_jiffies_64();
spin_unlock_irqrestore(&pcpu->load_lock, flags);
if (WARN_ON_ONCE(!delta_time))
goto rearm;
spin_lock_irqsave(&pcpu->target_freq_lock, flags);
do_div(cputime_speedadj, delta_time);
loadadjfreq = (unsigned int)cputime_speedadj * 100;
cpu_load = loadadjfreq / pcpu->target_freq;
pcpu->prev_load = cpu_load;
boosted = boost_val || now < boostpulse_endtime;
boosted_freq = max(hispeed_freq, pcpu->policy->min);
if (cpu_load >= go_hispeed_load || boosted) {
if (pcpu->target_freq < boosted_freq) {
new_freq = boosted_freq;
} else {
new_freq = choose_freq(pcpu, loadadjfreq);
if (new_freq > freq_calc_thresh)
new_freq = pcpu->policy->max * cpu_load / 100;
if (new_freq < boosted_freq)
new_freq = boosted_freq;
}
} else {
new_freq = choose_freq(pcpu, loadadjfreq);
if (new_freq > freq_calc_thresh)
new_freq = pcpu->policy->max * cpu_load / 100;
if (sync_freq && new_freq < sync_freq) {
max_load = 0;
max_freq = 0;
for_each_online_cpu(i) {
picpu = &per_cpu(cpuinfo, i);
if (i == data || picpu->prev_load <
up_threshold_any_cpu_load)
continue;
max_load = max(max_load, picpu->prev_load);
max_freq = max(max_freq, picpu->target_freq);
}
if (max_freq > up_threshold_any_cpu_freq ||
max_load >= up_threshold_any_cpu_load)
new_freq = sync_freq;
}
}
void initload()
{
bzero(¤t_load_data, sizeof(struct current_load_struct));
update_load(); /* Initialize the load list */
}
