/*
* Start a timer on a BSOCK. kill it after wait seconds.
*
* Returns: btimer_t *(pointer to btimer_t struct) on success
* NULL on failure
*/
btimer_t *start_bsock_timer(BSOCK *bsock, uint32_t wait)
{
btimer_t *wid;
if (wait <= 0) { /* wait should be > 0 */
return NULL;
}
wid = btimer_start_common(wait);
if (wid == NULL) {
return NULL;
}
wid->type = TYPE_BSOCK;
wid->tid = pthread_self();
wid->bsock = bsock;
wid->jcr = bsock->jcr();
wid->wd->callback = callback_thread_timer;
wid->wd->one_shot = true;
wid->wd->interval = wait;
register_watchdog(wid->wd);
Dmsg4(dbglvl, "Start bsock timer %p tid=%p for %d secs at %d\n", wid,
wid->tid, wait, time(NULL));
return wid;
}
/*
* Setup to call the timeout check routine every 30 seconds
* This routine will check any timers that have been enabled.
*/
bool init_jcr_subsystem(void)
{
watchdog_t *wd = new_watchdog();
wd->one_shot = false;
wd->interval = 30; /* FIXME: should be configurable somewhere, even
if only with a #define */
wd->callback = jcr_timeout_check;
register_watchdog(wd);
return true;
}
static struct device_t * wdg_s5pv210_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct wdg_s5pv210_pdata_t * pdat;
struct watchdog_t * wdg;
struct device_t * dev;
virtual_addr_t virt = phys_to_virt(dt_read_address(n));
char * clk = dt_read_string(n, "clock-name", NULL);
if(!search_clk(clk))
return NULL;
pdat = malloc(sizeof(struct wdg_s5pv210_pdata_t));
if(!pdat)
return NULL;
wdg = malloc(sizeof(struct watchdog_t));
if(!wdg)
{
free(pdat);
return NULL;
}
pdat->virt = virt;
pdat->clk = strdup(clk);
wdg->name = alloc_device_name(dt_read_name(n), -1);
wdg->set = wdg_s5pv210_set;
wdg->get = wdg_s5pv210_get;
wdg->priv = pdat;
clk_enable(pdat->clk);
write32(pdat->virt + WTCON, 0x0);
write32(pdat->virt + WTDAT, 0x0);
write32(pdat->virt + WTCNT, 0x0);
if(!register_watchdog(&dev, wdg))
{
clk_disable(pdat->clk);
free(pdat->clk);
free_device_name(wdg->name);
free(wdg->priv);
free(wdg);
return NULL;
}
dev->driver = drv;
return dev;
}
void init_job_server(int max_workers)
{
int status;
watchdog_t *wd;
if ((status = jobq_init(&job_queue, max_workers, job_thread)) != 0) {
berrno be;
Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), be.bstrerror(status));
}
wd = new_watchdog();
wd->callback = job_monitor_watchdog;
wd->destructor = job_monitor_destructor;
wd->one_shot = false;
wd->interval = 60;
wd->data = new_control_jcr("*JobMonitor*", JT_SYSTEM);
register_watchdog(wd);
}
/*
* Start a timer on a child process of pid, kill it after wait seconds.
*
* Returns: btimer_t *(pointer to btimer_t struct) on success
* NULL on failure
*/
btimer_t *start_child_timer(JCR *jcr, pid_t pid, uint32_t wait)
{
btimer_t *wid;
wid = btimer_start_common(wait);
if (wid == NULL) {
return NULL;
}
wid->type = TYPE_CHILD;
wid->pid = pid;
wid->killed = false;
wid->jcr = jcr;
wid->wd->callback = callback_child_timer;
wid->wd->one_shot = false;
wid->wd->interval = wait;
register_watchdog(wid->wd);
Dmsg3(dbglvl, "Start child timer %p, pid %d for %d secs.\n", wid, pid, wait);
return wid;
}
/*
* Start a timer on a thread. kill it after wait seconds.
*
* Returns: btimer_t *(pointer to btimer_t struct) on success
* NULL on failure
*/
btimer_t *start_thread_timer(JCR *jcr, pthread_t tid, uint32_t wait)
{
btimer_t *wid;
wid = btimer_start_common(wait);
if (wid == NULL) {
Dmsg1(dbglvl, "start_thread_timer return NULL from common. wait=%d.\n", wait);
return NULL;
}
wid->type = TYPE_PTHREAD;
wid->tid = tid;
wid->jcr = jcr;
wid->wd->callback = callback_thread_timer;
wid->wd->one_shot = true;
wid->wd->interval = wait;
register_watchdog(wid->wd);
Dmsg3(dbglvl, "Start thread timer %p tid %p for %d secs.\n", wid, tid, wait);
return wid;
}
static bool_t bcm2836_register_wdog(struct resource_t * res)
{
struct bcm2836_wdog_data_t * rdat = (struct bcm2836_wdog_data_t *)res->data;
struct bcm2836_wdog_pdata_t * pdat;
struct watchdog_t * wdog;
char name[64];
pdat = malloc(sizeof(struct bcm2836_wdog_pdata_t));
if(!pdat)
return FALSE;
wdog = malloc(sizeof(struct watchdog_t));
if(!wdog)
{
free(pdat);
return FALSE;
}
snprintf(name, sizeof(name), "%s.%d", res->name, res->id);
pdat->virt = phys_to_virt(rdat->phys);
pdat->start = 0;
wdog->name = strdup(name);
wdog->init = wdog_init;
wdog->exit = wdog_exit;
wdog->set = wdog_set,
wdog->get = wdog_get,
wdog->suspend = wdog_suspend,
wdog->resume = wdog_resume,
wdog->priv = pdat;
if(register_watchdog(wdog))
return TRUE;
free(wdog->priv);
free(wdog->name);
free(wdog);
return FALSE;
}
static struct device_t * wdog_bcm2836_probe(struct driver_t * drv, struct dtnode_t * n)
{
struct wdog_bcm2836_pdata_t * pdat;
struct watchdog_t * wdog;
struct device_t * dev;
virtual_addr_t virt = phys_to_virt(dt_read_address(n));
pdat = malloc(sizeof(struct wdog_bcm2836_pdata_t));
if(!pdat)
return NULL;
wdog = malloc(sizeof(struct watchdog_t));
if(!wdog)
{
free(pdat);
return NULL;
}
pdat->virt = virt;
pdat->start = 0;
wdog->name = alloc_device_name(dt_read_name(n), -1);
wdog->set = wdog_bcm2836_set;
wdog->get = wdog_bcm2836_get,
wdog->priv = pdat;
if(!register_watchdog(&dev, wdog))
{
free_device_name(wdog->name);
free(wdog->priv);
free(wdog);
return NULL;
}
dev->driver = drv;
return dev;
}
