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; }