struct pjs *pjs_init(void *ctx, int (*map)(const struct js_event *))
{
static const char dev_name[] = "/dev/input/js0";
struct pjs *pjs;
pjs = talloc_zero(ctx, struct pjs);
if (!pjs)
return NULL;
pjs->map = map;
pjs->fd = open(dev_name, O_RDONLY | O_NONBLOCK);
if (pjs->fd < 0) {
pb_log("%s: open %s failed: %s\n", __func__, dev_name,
strerror(errno));
goto out_err;
}
talloc_set_destructor(pjs, pjs_destructor);
pb_debug("%s: using %s\n", __func__, dev_name);
return pjs;
out_err:
close(pjs->fd);
pjs->fd = 0;
talloc_free(pjs);
return NULL;
}
static int ipmi_recv(struct ipmi *ipmi, uint8_t *netfn, uint8_t *cmd,
long *seq, uint8_t *buf, uint16_t *len)
{
struct ipmi_recv recv;
struct ipmi_addr addr;
int rc;
recv.addr = (unsigned char *)&addr;
recv.addr_len = sizeof(addr);
recv.msg.data = buf;
recv.msg.data_len = *len;
rc = ioctl(ipmi->fd, IPMICTL_RECEIVE_MSG_TRUNC, &recv);
if (rc < 0 && errno != EMSGSIZE) {
pb_log("IPMI: recv (%d bytes) failed: %m\n", *len);
return -1;
} else if (rc < 0 && errno == EMSGSIZE) {
pb_debug("IPMI: truncated message (netfn %d, cmd %d, "
"size %d), continuing anyway\n",
recv.msg.netfn, recv.msg.cmd, *len);
}
*netfn = recv.msg.netfn;
*cmd = recv.msg.cmd;
*seq = recv.msgid;
*len = recv.msg.data_len;
return 0;
}
int platform_init(void *ctx)
{
extern struct platform *__start_platforms, *__stop_platforms;
struct platform **p;
platform_ctx = talloc_new(ctx);
for (p = &__start_platforms; p < &__stop_platforms; p++) {
pb_debug("%s: Try platform %s\n", __func__, (*p)->name);
if (!(*p)->probe(*p, platform_ctx))
continue;
platform = *p;
break;
}
config = talloc(platform_ctx, struct config);
config_set_defaults(config);
if (platform) {
pb_log("Detected platform type: %s\n", platform->name);
if (platform->load_config)
platform->load_config(platform, config);
} else {
pb_log("No platform type detected, some platform-specific "
"functionality will be disabled\n");
}
dump_config(config);
return 0;
}
void cdrom_init(const char *devpath)
{
int fd, rc;
fd = cdrom_open(devpath, __func__);
if (fd < 0)
return;
/* We disable autoclose so that any attempted mount() operation doesn't
* close the tray, and disable CDO_LOCK to prevent the lock status
* changing on open()/close()
*/
rc = ioctl(fd, CDROM_CLEAR_OPTIONS, CDO_LOCK | CDO_AUTO_CLOSE);
if (rc < 0)
pb_debug("%s: CLEAR CDO_LOCK|CDO_AUTO_CLOSE failed: %s\n",
__func__, strerror(errno));
close(fd);
}
static void __attribute__((format(__printf__, 4, 5))) update_status(
boot_status_fn fn, void *arg, int type, char *fmt, ...)
{
struct boot_status status;
va_list ap;
va_start(ap, fmt);
status.message = talloc_vasprintf(NULL, fmt, ap);
va_end(ap);
status.type = type;
status.progress = -1;
status.detail = NULL;
pb_debug("boot status: [%d] %s\n", type, status.message);
fn(arg, &status);
talloc_free(status.message);
}
static int cui_boot(struct pmenu_item *item)
{
int result;
struct cui *cui = cui_from_item(item);
struct cui_opt_data *cod = cod_from_item(item);
assert(cui->current == &cui->main->scr);
pb_debug("%s: %s\n", __func__, cod->name);
nc_scr_status_printf(cui->current, _("Booting %s..."), cod->name);
result = discover_client_boot(cui->client, NULL, cod->opt, cod->bd);
if (result) {
nc_scr_status_printf(cui->current,
_("Failed: boot %s"), cod->bd->image);
}
return 0;
}
void cui_resize(struct cui *cui)
{
pb_debug("%s: resizing\n", __func__);
cui->resize = 1;
}
int ipmi_transaction(struct ipmi *ipmi, uint8_t netfn, uint8_t cmd,
uint8_t *req_buf, uint16_t req_len,
uint8_t *resp_buf, uint16_t *resp_len,
int timeout_ms)
{
struct timeval start, now, delta;
struct pollfd pollfds[1];
struct flock lock;
int expired_ms, rc;
memset(&lock, 0, sizeof(lock));
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
rc = fcntl(ipmi->fd, F_SETLKW, &lock);
if (rc == -1) {
pb_log("IPMI: error locking IPMI device: %m\n");
return rc;
}
rc = ipmi_send(ipmi, netfn, cmd, req_buf, req_len);
if (rc)
goto out;
pollfds[0].fd = ipmi->fd;
pollfds[0].events = POLLIN;
gettimeofday(&start, NULL);
expired_ms = 0;
for (;;) {
uint8_t resp_netfn, resp_cmd;
long seq;
rc = poll(pollfds, 1, timeout_ms - expired_ms);
if (rc < 0) {
pb_log("IPMI: poll() error %m");
break;
}
if (rc == 0) {
pb_log("IPMI: timeout waiting for response "
"(netfn %d, cmd %d)\n", netfn, cmd);
rc = -1;
break;
}
if (!(pollfds[0].revents & POLLIN)) {
pb_log("IPMI: unexpected fd status from poll?\n");
rc = -1;
break;
}
rc = ipmi_recv(ipmi, &resp_netfn, &resp_cmd, &seq,
resp_buf, resp_len);
if (rc)
break;
if (seq != ipmi->seq - 1) {
pb_log("IPMI: out-of-sequence reply: "
"exp %ld, got %ld\n",
ipmi->seq, seq);
if (timeout_ms) {
gettimeofday(&now, NULL);
timersub(&now, &start, &delta);
expired_ms = (delta.tv_sec * 1000) +
(delta.tv_usec / 1000);
if (expired_ms >= timeout_ms) {
rc = -1;
break;
}
}
} else {
pb_debug("IPMI: netfn(%x->%x), cmd(%x->%x)\n",
netfn, resp_netfn, cmd, resp_cmd);
rc = 0;
goto out;
}
}
out:
lock.l_type = F_UNLCK;
if (fcntl(ipmi->fd, F_SETLKW, &lock) == -1)
pb_log("IPMI: error unlocking IPMI device: %m\n");
return rc ? -1 : 0;
}
