static int lw_psr_state_init_wait_get(struct teamd_context *ctx,
struct team_state_gsc *gsc,
void *priv)
{
struct lw_common_port_priv *common_ppriv = priv;
struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv);
gsc->data.int_val = timespec_to_ms(&psr_ppriv->init_wait);
return 0;
}
static int lw_ethtool_state_delay_down_get(struct teamd_context *ctx,
struct team_state_gsc *gsc,
void *priv)
{
struct lw_common_port_priv *common_ppriv = priv;
struct timespec *ts;
ts = &lw_ethtool_ppriv_get(common_ppriv)->delay_down;
gsc->data.int_val = timespec_to_ms(ts);
return 0;
}
int
xppoll(struct pollfd *fds, nfds_t nfds,
const struct timespec *timeout_ts, const sigset_t *sigmask)
{
int ret;
sigset_t saved_sigmask;
sigprocmask(SIG_SETMASK, sigmask, &saved_sigmask);
ret = poll(fds, nfds, timespec_to_ms(timeout_ts));
sigprocmask(SIG_SETMASK, &saved_sigmask, NULL);
return ret;
}
static int lw_psr_load_options(struct teamd_context *ctx,
struct teamd_port *tdport,
struct lw_psr_port_priv *psr_ppriv)
{
struct teamd_config_path_cookie *cpcookie = psr_ppriv->common.cpcookie;
int err;
int tmp;
err = teamd_config_int_get(ctx, &tmp, "@.interval", cpcookie);
if (err) {
teamd_log_err("Failed to get \"interval\" link-watch option.");
return -EINVAL;
}
teamd_log_dbg("interval \"%d\".", tmp);
ms_to_timespec(&psr_ppriv->interval, tmp);
err = teamd_config_int_get(ctx, &tmp, "@.init_wait", cpcookie);
if (!err)
ms_to_timespec(&psr_ppriv->init_wait, tmp);
/* if init_wait is set to 0, use default_init_wait */
if (err || !tmp)
psr_ppriv->init_wait = lw_psr_default_init_wait;
teamd_log_dbg("init_wait \"%d\".", timespec_to_ms(&psr_ppriv->init_wait));
err = teamd_config_int_get(ctx, &tmp, "@.missed_max", cpcookie);
if (err) {
teamd_log_err("Failed to get \"missed_max\" link-watch option.");
return -EINVAL;
}
if (tmp < 0) {
teamd_log_err("\"missed_max\" must not be negative number.");
return -EINVAL;
}
teamd_log_dbg("missed_max \"%d\".", tmp);
psr_ppriv->missed_max = tmp;
return 0;
}
static u32_t
cond_wait(XaxMachinery *xm, ZCond *zcond, ZMutex *zmutex, u32_t timeout_ms, bool verbose)
{
int result;
ZCondWaitRecord zcwr;
zcondwaitrecord_init_auto(&zcwr, xm->zdt, zcond, zmutex);
ZAS *zasses[2];
zasses[0] = &zcwr.zas;
int zascount = 1;
LegacyZTimer *ztimer;
bool using_ztimer = false;
struct timespec start_time;
if (timeout_ms > 0) {
(xm->zclock->methods->read)(xm->zclock, &start_time);
struct timespec timeout_offset;
ms_to_timespec(&timeout_offset, timeout_ms);
struct timespec timeout_absolute;
timespec_add(&timeout_absolute, &start_time, &timeout_offset);
ztimer = (xm->zclock->methods->new_timer)(xm->zclock, &timeout_absolute);
zasses[1] = (xm->zclock->methods->get_zas)(ztimer);
zascount += 1;
using_ztimer = true;
}
if (verbose)
{
fprintf(stderr, "xax_arch cond_wait zcond %08x START\n", (uint32_t) zcond);
}
int idx = zas_wait_any(xm->zdt, zasses, zascount);
if (verbose && idx==0)
{
fprintf(stderr, "xax_arch cond_wait zcond %08x SUCCEED\n", (uint32_t) zcond);
}
if (idx==1)
{
result = SYS_ARCH_TIMEOUT;
}
else if (timeout_ms > 0)
{
/* Calculate for how long we waited for the cond. */
struct timespec end_time;
(xm->zclock->methods->read)(xm->zclock, &end_time);
struct timespec delay;
timespec_subtract(&delay, &end_time, &start_time);
result = timespec_to_ms(&delay);
}
else
{
result = SYS_ARCH_TIMEOUT;
}
if (using_ztimer)
{
(xm->zclock->methods->free_timer)(ztimer);
}
zcondwaitrecord_free(xm->zdt, &zcwr);
return result;
}
