/* * open a file descriptor * uses fd from cache if possible */ int fd_open(const char *path, nfs_fh3 nfh, int kind, int allow_caching) { int idx, res, fd; backend_statstruct buf; unfs3_fh_t *fh = (void *) nfh.data.data_val; idx = idx_by_fh(fh, kind); if (idx != -1) { if (fd_cache[idx].fd == -1) { /* pending error, report to client and remove from cache */ fd_cache_del(idx, FALSE); return -1; } return fd_cache[idx].fd; } else { /* call open to obtain new fd */ if (kind == UNFS3_FD_READ) fd = backend_open(path, O_RDONLY); else fd = backend_open(path, O_WRONLY); if (fd == -1) return -1; /* check for local fs race */ res = backend_fstat(fd, &buf); if ((res == -1) || (fh->dev != buf.st_dev || fh->ino != buf.st_ino || fh->gen != backend_get_gen(buf, fd, path))) { /* * local fs changed meaning of path between * calling NFS operation doing fh_decomp and * arriving here * * set errno to ELOOP to make calling NFS * operation return NFS3ERR_STALE */ backend_close(fd); errno = ELOOP; return -1; } /* * success, add to cache for later use */ if (allow_caching) fd_cache_add(fd, fh, kind); return fd; } }
static void nav_reload_current(navigator_t *nav) { nav_page_t *np; if((np = nav->nav_page_current) == NULL) return; plugins_reload_dev_plugin(); TRACE(TRACE_INFO, "navigator", "Reloading %s", np->np_url); prop_unsubscribe(np->np_close_sub); prop_unsubscribe(np->np_direct_close_sub); prop_destroy(np->np_prop_root); nav_page_setup_prop(nav, np, NULL); if(prop_set_parent(np->np_prop_root, nav->nav_prop_pages)) { /* nav->nav_prop_pages is a zombie, this is an error */ abort(); } nav_select(nav, np, NULL); if(backend_open(np->np_prop_root, np->np_url)) nav_open_errorf(np->np_prop_root, _("No handler for URL")); }
static int es_backend_open(duk_context *ctx) { prop_t *p = es_stprop_get(ctx, 0); const char *url = duk_require_string(ctx, 1); int sync = duk_require_boolean(ctx, 2); if(backend_open(p, url, sync)) duk_error(ctx, DUK_ERR_ERROR, "No handler for URL"); return 0; }
static void nav_open0(navigator_t *nav, const char *url, const char *view, prop_t *origin) { nav_page_t *np = calloc(1, sizeof(nav_page_t)); np->np_nav = nav; np->np_url = url ? strdup(url) : NULL; np->np_direct_close = 0; TAILQ_INSERT_TAIL(&nav->nav_pages, np, np_global_link); np->np_prop_root = prop_create_root("page"); if(view != NULL) { np->np_view = strdup(view); prop_set_string(prop_create(np->np_prop_root, "requestedView"), view); } // XXX Change this into event-style subscription np->np_close_sub = prop_subscribe(0, PROP_TAG_ROOT, prop_create(np->np_prop_root, "close"), PROP_TAG_CALLBACK_INT, nav_page_close_set, np, PROP_TAG_COURIER, nav->nav_pc, NULL); if(url != NULL) prop_set_string(prop_create(np->np_prop_root, "url"), url); np->np_url_sub = prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE, PROP_TAG_ROOT, prop_create(np->np_prop_root, "url"), PROP_TAG_CALLBACK_STRING, nav_page_url_set, np, PROP_TAG_COURIER, nav->nav_pc, NULL); np->np_direct_close_sub = prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE, PROP_TAG_ROOT, prop_create(np->np_prop_root, "directClose"), PROP_TAG_CALLBACK_INT, nav_page_direct_close_set, np, PROP_TAG_COURIER, nav->nav_pc, NULL); TRACE(TRACE_INFO, "navigator", "Opening %s", url); if(backend_open(np->np_prop_root, url)) nav_open_errorf(np->np_prop_root, url, "No handler for URL"); nav_insert_page(nav, np, origin); }
static void nav_open0(navigator_t *nav, const char *url, const char *view, prop_t *origin) { nav_page_t *np = calloc(1, sizeof(nav_page_t)); TRACE(TRACE_INFO, "navigator", "Opening %s", url); np->np_nav = nav; np->np_url = strdup(url); np->np_direct_close = 0; TAILQ_INSERT_TAIL(&nav->nav_pages, np, np_global_link); nav_page_setup_prop(nav, np, view); nav_insert_page(nav, np, origin); if(backend_open(np->np_prop_root, url)) nav_open_errorf(np->np_prop_root, _("No handler for URL")); }
static int search_open(prop_t *page, const char *url0) { const char *url; prop_t *model, *meta, *source; char title[256]; if((url = strchr(url0, ':')) == NULL) abort(); url++; if(!backend_open(page, url)) return 0; model = prop_create(page, "model"); prop_set_string(prop_create(model, "type"), "directory"); meta = prop_create(model, "metadata"); rstr_t *fmt = _("Search result for: %s"); snprintf(title, sizeof(title), rstr_get(fmt), url); rstr_release(fmt); prop_set_string(prop_create(meta, "title"), title); source = prop_create(page, "source"); struct prop_nf *pnf; pnf = prop_nf_create(prop_create(model, "nodes"), prop_create(source, "nodes"), NULL, PROP_NF_AUTODESTROY); prop_nf_sort(pnf, "node.metadata.title", 0, 2, NULL, 1); prop_nf_pred_int_add(pnf, "node.entries", PROP_NF_CMP_EQ, 0, NULL, PROP_NF_MODE_EXCLUDE); prop_nf_release(pnf); backend_search(source, url); return 0; }
int bladerf_open_with_devinfo(struct bladerf **opened_device, struct bladerf_devinfo *devinfo) { struct bladerf *dev; int status; *opened_device = NULL; dev = (struct bladerf *)calloc(1, sizeof(struct bladerf)); if (dev == NULL) { return BLADERF_ERR_MEM; } dev->fpga_version.describe = calloc(1, BLADERF_VERSION_STR_MAX + 1); if (dev->fpga_version.describe == NULL) { free(dev); return BLADERF_ERR_MEM; } dev->fw_version.describe = calloc(1, BLADERF_VERSION_STR_MAX + 1); if (dev->fw_version.describe == NULL) { free((void*)dev->fpga_version.describe); free(dev); return BLADERF_ERR_MEM; } status = backend_open(dev, devinfo); if (status != 0) { free((void*)dev->fw_version.describe); free((void*)dev->fpga_version.describe); free(dev); return status; } status = dev->fn->get_device_speed(dev, &dev->usb_speed); if (status < 0) { log_debug("Failed to get device speed: %s\n", bladerf_strerror(status)); goto error; } if (dev->usb_speed != BLADERF_DEVICE_SPEED_HIGH && dev->usb_speed != BLADERF_DEVICE_SPEED_SUPER) { log_debug("Unsupported device speed: %d\n", dev->usb_speed); goto error; } /* VCTCXO trim and FPGA size are non-fatal indicators that we've * trashed the calibration region of flash. If these were made fatal, * we wouldn't be able to open the device to restore them. */ status = bladerf_get_and_cache_vctcxo_trim(dev); if (status < 0) { log_warning("Failed to get VCTCXO trim value: %s\n", bladerf_strerror(status)); } status = bladerf_get_and_cache_fpga_size(dev); if (status < 0) { log_warning("Failed to get FPGA size %s\n", bladerf_strerror(status)); } status = bladerf_is_fpga_configured(dev); if (status > 0) { status = bladerf_init_device(dev); } error: if (status < 0) { bladerf_close(dev); } else { *opened_device = dev; } return status; }
CREATE3res *nfsproc3_create_3_svc(CREATE3args * argp, struct svc_req * rqstp) { static CREATE3res result; char *path; char obj[NFS_MAXPATHLEN]; sattr3 new_attr; int fd = -1, res = -1; backend_statstruct buf; uint32 gen; int flags = O_RDWR | O_CREAT | O_TRUNC | O_NONBLOCK; PREP(path, argp->where.dir); result.status = join(cat_name(path, argp->where.name, obj), exports_rw()); cluster_create(obj, rqstp, &result.status); /* GUARDED and EXCLUSIVE maps to Unix exclusive create */ if (argp->how.mode != UNCHECKED) flags = flags | O_EXCL; if (argp->how.mode != EXCLUSIVE) { new_attr = argp->how.createhow3_u.obj_attributes; result.status = join(result.status, atomic_attr(new_attr)); } /* Try to open the file */ if (result.status == NFS3_OK) { if (argp->how.mode != EXCLUSIVE) { fd = backend_open_create(obj, flags, create_mode(new_attr)); } else { fd = backend_open_create(obj, flags, create_mode(new_attr)); } } if (fd != -1) { /* Successful open */ res = backend_fstat(fd, &buf); if (res != -1) { /* Successful stat */ if (argp->how.mode == EXCLUSIVE) { /* Save verifier in atime and mtime */ res = backend_store_create_verifier(obj, argp->how.createhow3_u. verf); } } if (res != -1) { /* So far, so good */ gen = backend_get_gen(buf, fd, obj); fh_cache_add(buf.st_dev, buf.st_ino, obj); backend_close(fd); result.CREATE3res_u.resok.obj = fh_extend_post(argp->where.dir, buf.st_dev, buf.st_ino, gen); result.CREATE3res_u.resok.obj_attributes = get_post_buf(buf, rqstp); } if (res == -1) { /* backend_fstat() or backend_store_create_verifier() failed */ backend_close(fd); result.status = NFS3ERR_IO; } } else if (result.status == NFS3_OK) { /* open() failed */ if (argp->how.mode == EXCLUSIVE && errno == EEXIST) { /* Check if verifier matches */ fd = backend_open(obj, O_NONBLOCK); if (fd != -1) { res = backend_fstat(fd, &buf); } if (res != -1) { if (backend_check_create_verifier (&buf, argp->how.createhow3_u.verf)) { /* The verifier matched. Return success */ gen = backend_get_gen(buf, fd, obj); fh_cache_add(buf.st_dev, buf.st_ino, obj); backend_close(fd); result.CREATE3res_u.resok.obj = fh_extend_post(argp->where.dir, buf.st_dev, buf.st_ino, gen); result.CREATE3res_u.resok.obj_attributes = get_post_buf(buf, rqstp); } else { /* The verifier doesn't match */ result.status = NFS3ERR_EXIST; } } } if (res == -1) { result.status = create_err(); } } /* overlaps with resfail */ result.CREATE3res_u.resok.dir_wcc.before = get_pre_cached(); result.CREATE3res_u.resok.dir_wcc.after = get_post_stat(path, rqstp); return &result; }
int bladerf_open_with_devinfo(struct bladerf **device, struct bladerf_devinfo *devinfo) { struct bladerf *opened_device; int status; *device = NULL; status = backend_open(device, devinfo); if (!status) { /* Catch bugs from backends returning status = 0, but a NULL device */ assert(*device); opened_device = *device; /* We got a device */ bladerf_set_error(&opened_device->error, ETYPE_LIBBLADERF, 0); status = opened_device->fn->get_device_speed(opened_device, &opened_device->usb_speed); if (status < 0 || (opened_device->usb_speed != BLADERF_DEVICE_SPEED_HIGH && opened_device->usb_speed != BLADERF_DEVICE_SPEED_SUPER)) { opened_device->fn->close((*device)); *device = NULL; } else { if (opened_device->legacy) { /* Currently two modes of legacy: * - ALT_SETTING * - CONFIG_IF * * If either of these are set, we should tell the user to update */ printf("********************************************************************************\n"); printf("* ENTERING LEGACY MODE, PLEASE UPGRADE TO THE LATEST FIRMWARE BY RUNNING:\n"); printf("* wget http://nuand.com/fx3/latest.img ; bladeRF-cli -f latest.img\n"); printf("********************************************************************************\n"); } if (!(opened_device->legacy & LEGACY_ALT_SETTING)) { status = bladerf_get_and_cache_vctcxo_trim(opened_device); if (status < 0) { log_warning( "Could not extract VCTCXO trim value\n" ) ; } status = bladerf_get_and_cache_fpga_size(opened_device); if (status < 0) { log_warning( "Could not extract FPGA size\n" ) ; } /* If any of these routines failed, the dev structure should * still have had it's fields dummied, so they're safe to * print here (i.e., not uninitialized) */ log_debug("%s: fw=v%s serial=%s trim=0x%.4x fpga_size=%d\n", __FUNCTION__, opened_device->fw_version.describe, opened_device->ident.serial, opened_device->dac_trim, opened_device->fpga_size); } /* All status in here is not fatal, so whatever */ status = 0 ; if (bladerf_is_fpga_configured(opened_device)) { bladerf_init_device(opened_device); } } } return status; }
int bladerf_open_with_devinfo(struct bladerf **opened_device, struct bladerf_devinfo *devinfo) { struct bladerf *dev; int status; *opened_device = NULL; dev = (struct bladerf *)calloc(1, sizeof(struct bladerf)); if (dev == NULL) { return BLADERF_ERR_MEM; } MUTEX_INIT(&dev->ctrl_lock); MUTEX_INIT(&dev->sync_lock[BLADERF_MODULE_RX]); MUTEX_INIT(&dev->sync_lock[BLADERF_MODULE_TX]); dev->fpga_version.describe = calloc(1, BLADERF_VERSION_STR_MAX + 1); if (dev->fpga_version.describe == NULL) { free(dev); return BLADERF_ERR_MEM; } dev->fw_version.describe = calloc(1, BLADERF_VERSION_STR_MAX + 1); if (dev->fw_version.describe == NULL) { free((void*)dev->fpga_version.describe); free(dev); return BLADERF_ERR_MEM; } status = backend_open(dev, devinfo); if (status != 0) { free((void*)dev->fw_version.describe); free((void*)dev->fpga_version.describe); free(dev); return status; } status = dev->fn->get_device_speed(dev, &dev->usb_speed); if (status < 0) { log_debug("Failed to get device speed: %s\n", bladerf_strerror(status)); goto error; } if (dev->usb_speed != BLADERF_DEVICE_SPEED_HIGH && dev->usb_speed != BLADERF_DEVICE_SPEED_SUPER) { log_debug("Unsupported device speed: %d\n", dev->usb_speed); goto error; } /* Verify that we have a sufficent firmware version before continuing. */ status = version_check_fw(dev); if (status != 0) { #ifdef LOGGING_ENABLED if (status == BLADERF_ERR_UPDATE_FW) { struct bladerf_version req; const unsigned int dev_maj = dev->fw_version.major; const unsigned int dev_min = dev->fw_version.minor; const unsigned int dev_pat = dev->fw_version.patch; unsigned int req_maj, req_min, req_pat; version_required_fw(dev, &req, false); req_maj = req.major; req_min = req.minor; req_pat = req.patch; log_warning("Firmware v%u.%u.%u was detected. libbladeRF v%s " "requires firmware v%u.%u.%u or later. An upgrade via " "the bootloader is required.\n\n", dev_maj, dev_min, dev_pat, LIBBLADERF_VERSION, req_maj, req_min, req_pat); } #endif goto error; } /* VCTCXO trim and FPGA size are non-fatal indicators that we've * trashed the calibration region of flash. If these were made fatal, * we wouldn't be able to open the device to restore them. */ status = get_and_cache_vctcxo_trim(dev); if (status < 0) { log_warning("Failed to get VCTCXO trim value: %s\n", bladerf_strerror(status)); } status = get_and_cache_fpga_size(dev); if (status < 0) { log_warning("Failed to get FPGA size %s\n", bladerf_strerror(status)); } status = FPGA_IS_CONFIGURED(dev); if (status > 0) { /* If the FPGA version check fails, just warn, but don't error out. * * If an error code caused this function to bail out, it would prevent a * user from being able to unload and reflash a bitstream being * "autoloaded" from SPI flash. */ fpga_check_version(dev); status = init_device(dev); if (status != 0) { goto error; } } dev->rx_filter = -1; dev->tx_filter = -1; /* Load any configuration files or FPGA images that a user has stored * for this device in their bladerf config directory */ status = config_load_all(dev); error: if (status < 0) { bladerf_close(dev); } else { *opened_device = dev; } return status; }