static void rtas_event_scan(struct work_struct *w)
{
unsigned int cpu;
do_event_scan();
get_online_cpus();
cpu = next_cpu(smp_processor_id(), cpu_online_map);
if (cpu == NR_CPUS) {
cpu = first_cpu(cpu_online_map);
if (first_pass) {
first_pass = 0;
event_scan_delay = 30*HZ/rtas_event_scan_rate;
if (surveillance_timeout != -1) {
pr_debug("rtasd: enabling surveillance\n");
enable_surveillance(surveillance_timeout);
pr_debug("rtasd: surveillance enabled\n");
}
}
}
schedule_delayed_work_on(cpu, &event_scan_work,
__round_jiffies_relative(event_scan_delay, cpu));
put_online_cpus();
}
static void rtas_event_scan(struct work_struct *w)
{
unsigned int cpu;
do_event_scan();
get_online_cpus();
/* raw_ OK because just using CPU as starting point. */
cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask);
if (cpu >= nr_cpu_ids) {
cpu = cpumask_first(cpu_online_mask);
if (first_pass) {
first_pass = 0;
event_scan_delay = 30*HZ/rtas_event_scan_rate;
if (surveillance_timeout != -1) {
pr_debug("rtasd: enabling surveillance\n");
enable_surveillance(surveillance_timeout);
pr_debug("rtasd: surveillance enabled\n");
}
}
}
schedule_delayed_work_on(cpu, &event_scan_work,
__round_jiffies_relative(event_scan_delay, cpu));
put_online_cpus();
}
static int rtasd(void *unused)
{
unsigned int err_type;
int event_scan = rtas_token("event-scan");
int rc;
daemonize("rtasd");
if (event_scan == RTAS_UNKNOWN_SERVICE || get_eventscan_parms() == -1)
goto error;
rtas_log_buf = vmalloc(rtas_error_log_buffer_max*LOG_NUMBER);
if (!rtas_log_buf) {
printk(KERN_ERR "rtasd: no memory\n");
goto error;
}
printk(KERN_DEBUG "RTAS daemon started\n");
DEBUG("will sleep for %d milliseconds\n", (30000/rtas_event_scan_rate));
/* See if we have any error stored in NVRAM */
memset(logdata, 0, rtas_error_log_max);
rc = nvram_read_error_log(logdata, rtas_error_log_max, &err_type);
/* We can use rtas_log_buf now */
no_logging = 0;
if (!rc) {
if (err_type != ERR_FLAG_ALREADY_LOGGED) {
pSeries_log_error(logdata, err_type | ERR_FLAG_BOOT, 0);
}
}
/* First pass. */
do_event_scan_all_cpus(1000);
if (surveillance_timeout != -1) {
DEBUG("enabling surveillance\n");
enable_surveillance(surveillance_timeout);
DEBUG("surveillance enabled\n");
}
/* Delay should be at least one second since some
* machines have problems if we call event-scan too
* quickly. */
for (;;)
do_event_scan_all_cpus(30000/rtas_event_scan_rate);
error:
/* Should delete proc entries */
return -EINVAL;
}
static int rtasd(void *unused)
{
unsigned int err_type;
int rc;
daemonize("rtasd");
printk(KERN_DEBUG "RTAS daemon started\n");
pr_debug("rtasd: will sleep for %d milliseconds\n",
(30000 / rtas_event_scan_rate));
/* See if we have any error stored in NVRAM */
memset(logdata, 0, rtas_error_log_max);
rc = nvram_read_error_log(logdata, rtas_error_log_max,
&err_type, &error_log_cnt);
/* We can use rtas_log_buf now */
logging_enabled = 1;
if (!rc) {
if (err_type != ERR_FLAG_ALREADY_LOGGED) {
pSeries_log_error(logdata, err_type | ERR_FLAG_BOOT, 0);
}
}
/* First pass. */
do_event_scan_all_cpus(1000);
if (surveillance_timeout != -1) {
pr_debug("rtasd: enabling surveillance\n");
enable_surveillance(surveillance_timeout);
pr_debug("rtasd: surveillance enabled\n");
}
/* Delay should be at least one second since some
* machines have problems if we call event-scan too
* quickly. */
for (;;)
do_event_scan_all_cpus(30000/rtas_event_scan_rate);
return -EINVAL;
}
static int rtasd(void *unused)
{
int cpu = 0;
int error;
int first_pass = 1;
int event_scan = rtas_token("event-scan");
if (event_scan == RTAS_UNKNOWN_SERVICE || get_eventscan_parms() == -1)
goto error;
rtas_log_buf = vmalloc(rtas_error_log_max*LOG_NUMBER);
if (!rtas_log_buf) {
printk(KERN_ERR "rtasd: no memory\n");
goto error;
}
DEBUG("will sleep for %d jiffies\n", (HZ*60/rtas_event_scan_rate) / 2);
daemonize();
sigfillset(¤t->blocked);
sprintf(current->comm, "rtasd");
/* Rusty unreal time task */
current->policy = SCHED_FIFO;
current->nice = sys_sched_get_priority_max(SCHED_FIFO) + 1;
cpu = 0;
current->cpus_allowed = 1UL << cpu_logical_map(cpu);
schedule();
while(1) {
do {
memset(logdata, 0, rtas_error_log_max);
error = rtas_call(event_scan, 4, 1, NULL,
EVENT_SCAN_ALL_EVENTS, 0,
__pa(logdata), rtas_error_log_max);
if (error == -1) {
printk(KERN_ERR "event-scan failed\n");
break;
}
if (error == 0)
log_rtas(logdata);
} while(error == 0);
DEBUG("watchdog scheduled on cpu %d\n", smp_processor_id());
cpu++;
if (cpu >= smp_num_cpus) {
if (first_pass && surveillance_requested) {
DEBUG("enabling surveillance\n");
if (enable_surveillance())
goto error_vfree;
DEBUG("surveillance enabled\n");
}
first_pass = 0;
cpu = 0;
}
current->cpus_allowed = 1UL << cpu_logical_map(cpu);
/* Check all cpus for pending events before sleeping*/
if (first_pass) {
schedule();
} else {
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout((HZ*60/rtas_event_scan_rate) / 2);
}
}
error_vfree:
vfree(rtas_log_buf);
error:
/* Should delete proc entries */
return -EINVAL;
}
static int rtasd(void *unused)
{
unsigned int err_type;
int cpu = 0;
int event_scan = rtas_token("event-scan");
cpumask_t all = CPU_MASK_ALL;
int rc;
daemonize("rtasd");
if (event_scan == RTAS_UNKNOWN_SERVICE || get_eventscan_parms() == -1)
goto error;
rtas_log_buf = vmalloc(rtas_error_log_buffer_max*LOG_NUMBER);
if (!rtas_log_buf) {
printk(KERN_ERR "rtasd: no memory\n");
goto error;
}
/* We can use rtas_log_buf now */
no_more_logging = 0;
printk(KERN_ERR "RTAS daemon started\n");
DEBUG("will sleep for %d jiffies\n", (HZ*60/rtas_event_scan_rate) / 2);
/* See if we have any error stored in NVRAM */
memset(logdata, 0, rtas_error_log_max);
rc = nvram_read_error_log(logdata, rtas_error_log_max, &err_type);
if (!rc) {
if (err_type != ERR_FLAG_ALREADY_LOGGED) {
pSeries_log_error(logdata, err_type | ERR_FLAG_BOOT, 0);
}
}
/* First pass. */
lock_cpu_hotplug();
for_each_online_cpu(cpu) {
DEBUG("scheduling on %d\n", cpu);
set_cpus_allowed(current, cpumask_of_cpu(cpu));
DEBUG("watchdog scheduled on cpu %d\n", smp_processor_id());
do_event_scan(event_scan);
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ);
}
unlock_cpu_hotplug();
if (surveillance_timeout != -1) {
DEBUG("enabling surveillance\n");
enable_surveillance(surveillance_timeout);
DEBUG("surveillance enabled\n");
}
lock_cpu_hotplug();
cpu = first_cpu_const(mk_cpumask_const(cpu_online_map));
for (;;) {
set_cpus_allowed(current, cpumask_of_cpu(cpu));
do_event_scan(event_scan);
set_cpus_allowed(current, all);
/* Drop hotplug lock, and sleep for a bit (at least
* one second since some machines have problems if we
* call event-scan too quickly). */
unlock_cpu_hotplug();
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout((HZ*60/rtas_event_scan_rate) / 2);
lock_cpu_hotplug();
cpu = next_cpu_const(cpu, mk_cpumask_const(cpu_online_map));
if (cpu == NR_CPUS)
cpu = first_cpu_const(mk_cpumask_const(cpu_online_map));
}
error:
/* Should delete proc entries */
return -EINVAL;
}
static int rtasd(void *unused)
{
int cpu = 0;
int error;
int first_pass = 1;
int event_scan = rtas_token("event-scan");
if (event_scan == RTAS_UNKNOWN_SERVICE || get_eventscan_parms() == -1)
goto error;
rtas_log_buf = vmalloc(rtas_error_log_max*LOG_NUMBER);
if (!rtas_log_buf) {
printk(KERN_ERR "rtasd: no memory\n");
goto error;
}
DEBUG("will sleep for %d jiffies\n", (HZ*60/rtas_event_scan_rate) / 2);
daemonize("rtasd");
#if 0
/* Rusty unreal time task */
current->policy = SCHED_FIFO;
current->nice = sys_sched_get_priority_max(SCHED_FIFO) + 1;
#endif
repeat:
for (cpu = 0; cpu < NR_CPUS; cpu++) {
if (!cpu_online(cpu))
continue;
DEBUG("scheduling on %d\n", cpu);
set_cpus_allowed(current, cpumask_of_cpu(cpu));
DEBUG("watchdog scheduled on cpu %d\n", smp_processor_id());
do {
memset(logdata, 0, rtas_error_log_max);
error = rtas_call(event_scan, 4, 1, NULL,
EVENT_SCAN_ALL_EVENTS, 0,
__pa(logdata), rtas_error_log_max);
if (error == -1) {
printk(KERN_ERR "event-scan failed\n");
break;
}
if (error == 0)
log_rtas(logdata);
} while(error == 0);
/*
* Check all cpus for pending events quickly, sleeping for
* at least one second since some machines have problems
* if we call event-scan too quickly
*/
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(first_pass ? HZ : (HZ*60/rtas_event_scan_rate) / 2);
}
if (first_pass && surveillance_requested) {
DEBUG("enabling surveillance\n");
if (enable_surveillance())
goto error_vfree;
DEBUG("surveillance enabled\n");
}
first_pass = 0;
goto repeat;
error_vfree:
vfree(rtas_log_buf);
error:
/* Should delete proc entries */
return -EINVAL;
}