static int ceata_write_multiple_register(uint32_t addr, void* dest, uint32_t size) { uint32_t i; if (size > 0x10) RET_ERR(0); mmc_discard_irq(); SDCI_DMASIZE = size; SDCI_DMACOUNT = 0; SDCI_DCTRL = SDCI_DCTRL_TXFIFORST | SDCI_DCTRL_RXFIFORST; PASS_RC(mmc_send_command(SDCI_CMD_CMD_NUM(MMC_CMD_CEATA_RW_MULTIPLE_REG) | SDCI_CMD_CMD_TYPE_ADTC | SDCI_CMD_CMD_RD_WR | SDCI_CMD_RES_BUSY | SDCI_CMD_RES_TYPE_R1 | SDCI_CMD_RES_SIZE_48 | SDCI_CMD_NCR_NID_NCR, MMC_CMD_CEATA_RW_MULTIPLE_REG_DIRECTION_WRITE | MMC_CMD_CEATA_RW_MULTIPLE_REG_ADDRESS(addr & 0xfc) | MMC_CMD_CEATA_RW_MULTIPLE_REG_COUNT(size & 0xfc), NULL, CEATA_COMMAND_TIMEOUT), 3, 1); SDCI_DCTRL = SDCI_DCTRL_TRCONT_TX; for (i = 0; i < size / 4; i++) SDCI_DATA = ((uint32_t*)dest)[i]; long startusec = USEC_TIMER; if (semaphore_wait(&mmc_wakeup, CEATA_COMMAND_TIMEOUT * HZ / 1000000) == OBJ_WAIT_TIMEDOUT) RET_ERR(2); while ((SDCI_STATE & SDCI_STATE_DAT_STATE_MASK) != SDCI_STATE_DAT_STATE_IDLE) { if (TIMEOUT_EXPIRED(startusec, CEATA_COMMAND_TIMEOUT)) RET_ERR(3); yield(); } PASS_RC(mmc_dsta_check_data_success(), 3, 4); return 0; }
alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename, alpm_siglevel_t level) { alpm_db_t *db; _alpm_log(handle, ALPM_LOG_DEBUG, "registering sync database '%s'\n", treename); #ifndef HAVE_LIBGPGME if(level != 0 && level != ALPM_SIG_USE_DEFAULT) { RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL); } #endif db = _alpm_db_new(treename, 0); if(db == NULL) { RET_ERR(handle, ALPM_ERR_DB_CREATE, NULL); } db->ops = &sync_db_ops; db->handle = handle; db->siglevel = level; sync_db_validate(db); handle->dbs_sync = alpm_list_add(handle->dbs_sync, db); return db; }
static FILE *create_tempfile(struct dload_payload *payload, const char *localpath) { int fd; FILE *fp; char *randpath; size_t len; /* create a random filename, which is opened with O_EXCL */ len = strlen(localpath) + 14 + 1; MALLOC(randpath, len, RET_ERR(payload->handle, ALPM_ERR_MEMORY, NULL)); snprintf(randpath, len, "%salpmtmp.XXXXXX", localpath); if((fd = mkstemp(randpath)) == -1 || fchmod(fd, ~(_getumask()) & 0666) || !(fp = fdopen(fd, payload->tempfile_openmode))) { unlink(randpath); close(fd); _alpm_log(payload->handle, ALPM_LOG_ERROR, _("failed to create temporary file for download\n")); free(randpath); return NULL; } /* fp now points to our alpmtmp.XXXXXX */ free(payload->tempfile_name); payload->tempfile_name = randpath; free(payload->remote_name); STRDUP(payload->remote_name, strrchr(randpath, '/') + 1, RET_ERR(payload->handle, ALPM_ERR_MEMORY, NULL)); return fp; }
/** Add a target to the transaction. * @param trans the current transaction * @param target the name of the target to add * @return 0 on success, -1 on error (pm_errno is set accordingly) */ int _alpm_trans_addtarget(pmtrans_t *trans, char *target) { ALPM_LOG_FUNC; /* Sanity checks */ ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(target != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1)); switch(trans->type) { case PM_TRANS_TYPE_UPGRADE: if(_alpm_add_loadtarget(trans, handle->db_local, target) == -1) { /* pm_errno is set by _alpm_add_loadtarget() */ return(-1); } break; case PM_TRANS_TYPE_REMOVE: case PM_TRANS_TYPE_REMOVEUPGRADE: if(_alpm_remove_loadtarget(trans, handle->db_local, target) == -1) { /* pm_errno is set by _alpm_remove_loadtarget() */ return(-1); } break; case PM_TRANS_TYPE_SYNC: if(_alpm_sync_addtarget(trans, handle->db_local, handle->dbs_sync, target) == -1) { /* pm_errno is set by _alpm_sync_loadtarget() */ return(-1); } break; } return(0); }
/** Release a transaction. */ int SYMEXPORT alpm_trans_release(alpm_handle_t *handle) { alpm_trans_t *trans; /* Sanity checks */ CHECK_HANDLE(handle, return -1); trans = handle->trans; ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1)); ASSERT(trans->state != STATE_IDLE, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1)); int nolock_flag = trans->flags & ALPM_TRANS_FLAG_NOLOCK; _alpm_trans_free(trans); handle->trans = NULL; /* unlock db */ if(!nolock_flag) { if(_alpm_handle_unlock(handle)) { _alpm_log(handle, ALPM_LOG_WARNING, _("could not remove lock file %s\n"), alpm_option_get_lockfile(handle)); alpm_logaction(handle, "warning: could not remove lock file %s\n", alpm_option_get_lockfile(handle)); } } return 0; }
/** Initialize the transaction. */ int SYMEXPORT alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags, alpm_trans_cb_event event, alpm_trans_cb_conv conv, alpm_trans_cb_progress progress) { alpm_trans_t *trans; /* Sanity checks */ CHECK_HANDLE(handle, return -1); ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, -1)); /* lock db */ if(!(flags & ALPM_TRANS_FLAG_NOLOCK)) { if(_alpm_handle_lock(handle)) { RET_ERR(handle, ALPM_ERR_HANDLE_LOCK, -1); } } CALLOC(trans, 1, sizeof(alpm_trans_t), RET_ERR(handle, ALPM_ERR_MEMORY, -1)); trans->flags = flags; trans->cb_event = event; trans->cb_conv = conv; trans->cb_progress = progress; trans->state = STATE_INITIALIZED; handle->trans = trans; return 0; }
/** Release a transaction. * @return 0 on success, -1 on error (pm_errno is set accordingly) */ int SYMEXPORT alpm_trans_release() { pmtrans_t *trans; ALPM_LOG_FUNC; /* Sanity checks */ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1)); trans = handle->trans; ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(trans->state != STATE_IDLE, RET_ERR(PM_ERR_TRANS_NULL, -1)); _alpm_trans_free(trans); handle->trans = NULL; /* unlock db */ if(handle->lckfd != -1) { while(close(handle->lckfd) == -1 && errno == EINTR); handle->lckfd = -1; } if(_alpm_lckrm()) { _alpm_log(PM_LOG_WARNING, _("could not remove lock file %s\n"), alpm_option_get_lockfile()); alpm_logaction("warning: could not remove lock file %s\n", alpm_option_get_lockfile()); } return(0); }
/** * @brief Add a package removal action to the transaction. * * @param handle the context handle * @param pkg the package to uninstall * * @return 0 on success, -1 on error */ int SYMEXPORT alpm_remove_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg) { const char *pkgname; alpm_trans_t *trans; alpm_pkg_t *copy; /* Sanity checks */ CHECK_HANDLE(handle, return -1); ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1)); ASSERT(handle == pkg->handle, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1)); trans = handle->trans; ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1)); ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1)); pkgname = pkg->name; if(alpm_pkg_find(trans->remove, pkgname)) { RET_ERR(handle, ALPM_ERR_TRANS_DUP_TARGET, -1); } _alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s to the transaction remove list\n", pkgname); if(_alpm_pkg_dup(pkg, ©) == -1) { return -1; } trans->remove = alpm_list_add(trans->remove, copy); return 0; }
int examine_inside_scaling_none(void) { int i; double inside; inside_failure = 0.0; for (i = 0; i < num_roots; i++) { inside = expl_graph[roots[i]->id]->inside; if (i == failure_root_index) { inside_failure = inside; if (!(1.0 - inside_failure > 0.0)) { emit_error("Probability of failure being unity"); RET_ERR(err_invalid_numeric_value); } } else { if (!(inside > 0.0)) { emit_error("Probability of an observed goal being non-positive (log_scale: off)"); RET_ERR(err_invalid_numeric_value); } } } return BP_TRUE; }
/** Unregister a package database. */ int SYMEXPORT alpm_db_unregister(alpm_db_t *db) { int found = 0; alpm_handle_t *handle; /* Sanity checks */ ASSERT(db != NULL, return -1); /* Do not unregister a database if a transaction is on-going */ handle = db->handle; handle->pm_errno = 0; ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, -1)); if(db == handle->db_local) { handle->db_local = NULL; found = 1; } else { /* Warning : this function shouldn't be used to unregister all sync * databases by walking through the list returned by * alpm_get_syncdbs, because the db is removed from that list here. */ void *data; handle->dbs_sync = alpm_list_remove(handle->dbs_sync, db, _alpm_db_cmp, &data); if(data) { found = 1; } } if(!found) { RET_ERR(handle, ALPM_ERR_DB_NOT_FOUND, -1); } db->ops->unregister(db); return 0; }
/* * Export probabilities of switches from Prolog to C. Switches is * a list of switches, each of which takes the form: * * sw(Id,InstanceIds,Probs,SmoothCs,Fixed,FixedH), * * where * Id: identifier of the switch * InstanceIds: list of ids of the instances of the switch * Probs: current probabilities assigned to the instance switches * SmoothCs: current pseudo counts assigned to the instance switches * Fixed: probabilities fixed? * FixedH: pseudo counts fixed? * * The structures for switch instances have been allocated. This * function only fills out the initial probabilities. */ int pc_export_sw_info_1(void) { int sw_id,instance_id,fixed,fixed_h; double prob,smooth; TERM p_switches, p_switch; TERM p_instance_list,p_prob_list,p_smooth_list; TERM p_prob,p_smooth; p_switches = bpx_get_call_arg(1,1); while (bpx_is_list(p_switches)) { /* p_switch: sw(Id,InstList,ProbList,SmoothCList,FixedP,FixedH) */ p_switch = bpx_get_car(p_switches); sw_id = bpx_get_integer(bpx_get_arg(1,p_switch)); p_instance_list = bpx_get_arg(2,p_switch); p_prob_list = bpx_get_arg(3,p_switch); p_smooth_list = bpx_get_arg(4,p_switch); fixed = bpx_get_integer(bpx_get_arg(5,p_switch)); fixed_h = bpx_get_integer(bpx_get_arg(6,p_switch)); while (bpx_is_list(p_instance_list)) { instance_id = bpx_get_integer(bpx_get_car(p_instance_list)); p_prob = bpx_get_car(p_prob_list); p_smooth = bpx_get_car(p_smooth_list); if (bpx_is_integer(p_prob)) { prob = (double)bpx_get_integer(p_prob); } else if (bpx_is_float(p_prob)) { prob = bpx_get_float(p_prob); } else { RET_ERR(illegal_arguments); } if (bpx_is_integer(p_smooth)) { smooth = (double)bpx_get_integer(p_smooth); } else if (bpx_is_float(p_smooth)) { smooth = bpx_get_float(p_smooth); } else { RET_ERR(illegal_arguments); } switch_instances[instance_id]->inside = prob; switch_instances[instance_id]->fixed = fixed; switch_instances[instance_id]->fixed_h = fixed_h; switch_instances[instance_id]->smooth_prolog = smooth; p_instance_list = bpx_get_cdr(p_instance_list); p_prob_list = bpx_get_cdr(p_prob_list); p_smooth_list = bpx_get_cdr(p_smooth_list); } p_switches = bpx_get_cdr(p_switches); } return BP_TRUE; }
/*! * \brief Inizializza il Buffer Pool. * * Alloca la memoria per il Buffer di Playout e inizializza la Free List per la gestione interna della memoria. * Inizializza la variabile di accesso in Mutua Esclusione alla Free List. * * \param bp Il puntatore al Buffer Pool corrente. * \return 1 in caso di errore, 0 altrimenti. * \see bpkill * \see bufferpool.h * */ int bpinit(buffer_pool * bp) { pthread_mutexattr_t mutex_attr; int i; if (((bp->bufferpool) = (bp_slot *) malloc(BP_SLOT_NUM * sizeof(bp_slot))) == NULL) { return 1; } memset(bp->bufferpool, 0, BP_SLOT_NUM * sizeof(bp_slot)); bp->freelist = calloc(BP_SLOT_NUM, sizeof(int)); for (i = 0; i < BP_SLOT_NUM; bp->freelist[i] = i + 1, i++); bp->freelist[BP_SLOT_NUM - 1] = -1; bp->flhead = 0; bp->flcount = 0; bp->size = BP_SLOT_NUM; if ((i = pthread_mutexattr_init(&mutex_attr)) > 0) RET_ERR(i); if ((i = pthread_mutex_init(&(bp->fl_mutex), &mutex_attr)) > 0) RET_ERR(i); // cond initialization if ((i = pthread_cond_init(&(bp->cond_full), NULL)) > 0) RET_ERR(i); return 0; }
int examine_inside_scaling_log_exp(void) { int i; double inside; /* [23 Aug 2007, by yuizumi] * By the code below, inside_failure can take only a non-zero value * when `failure' is observed. We can therefore safely use zero as * an indicator of failure being not observed. Zero is chosen just * for convenience in implementation of the parallel version. */ inside_failure = 0.0; for (i = 0; i < num_roots; i++) { inside = expl_graph[roots[i]->id]->inside; if (i == failure_root_index) { inside_failure = inside; /* log-scale */ if (!(inside_failure < 0.0)) { emit_error("Probability of failure being unity"); RET_ERR(err_invalid_numeric_value); } } else { if (!isfinite(inside)) { emit_error("Probability of an observed goal being non-positive (log_scale: on)"); RET_ERR(err_invalid_numeric_value); } } } return BP_TRUE; }
static char *get_sync_dir(alpm_handle_t *handle) { size_t len = strlen(handle->dbpath) + 6; char *syncpath; struct stat buf; MALLOC(syncpath, len, RET_ERR(handle, ALPM_ERR_MEMORY, NULL)); sprintf(syncpath, "%s%s", handle->dbpath, "sync/"); if(stat(syncpath, &buf) != 0) { _alpm_log(handle, ALPM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n", syncpath); if(_alpm_makepath(syncpath) != 0) { free(syncpath); RET_ERR(handle, ALPM_ERR_SYSTEM, NULL); } } else if(!S_ISDIR(buf.st_mode)) { _alpm_log(handle, ALPM_LOG_WARNING, _("removing invalid file: %s\n"), syncpath); if(unlink(syncpath) != 0 || _alpm_makepath(syncpath) != 0) { free(syncpath); RET_ERR(handle, ALPM_ERR_SYSTEM, NULL); } } return syncpath; }
/** Register a sync database of packages. */ alpm_db_t SYMEXPORT *alpm_register_syncdb(alpm_handle_t *handle, const char *treename, alpm_siglevel_t level) { alpm_list_t *i; /* Sanity checks */ CHECK_HANDLE(handle, return NULL); ASSERT(treename != NULL && strlen(treename) != 0, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL)); ASSERT(!strchr(treename, '/'), RET_ERR(handle, ALPM_ERR_WRONG_ARGS, NULL)); /* Do not register a database if a transaction is on-going */ ASSERT(handle->trans == NULL, RET_ERR(handle, ALPM_ERR_TRANS_NOT_NULL, NULL)); /* ensure database name is unique */ if(strcmp(treename, "local") == 0) { RET_ERR(handle, ALPM_ERR_DB_NOT_NULL, NULL); } for(i = handle->dbs_sync; i; i = i->next) { alpm_db_t *d = i->data; if(strcmp(treename, d->treename) == 0) { RET_ERR(handle, ALPM_ERR_DB_NOT_NULL, NULL); } } return _alpm_db_register_sync(handle, treename, level); }
static int ata_wait_for_end_of_transfer(long timeout) { PASS_RC(ata_wait_for_not_bsy(timeout), 2, 0); uint8_t dad = ata_read_cbr(&ATA_PIO_DAD); if (dad & BIT(0)) RET_ERR(1); if ((dad & (BIT(3) | BITRANGE(5, 7))) == BIT(6)) return 0; RET_ERR(2); }
/** Prepare a transaction. */ int SYMEXPORT alpm_trans_prepare(alpm_handle_t *handle, alpm_list_t **data) { alpm_trans_t *trans; /* Sanity checks */ CHECK_HANDLE(handle, return -1); ASSERT(data != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1)); trans = handle->trans; ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1)); ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1)); /* If there's nothing to do, return without complaining */ if(trans->add == NULL && trans->remove == NULL) { return 0; } alpm_list_t *invalid = check_arch(handle, trans->add); if(invalid) { if(data) { *data = invalid; } RET_ERR(handle, ALPM_ERR_PKG_INVALID_ARCH, -1); } if(trans->add == NULL) { if(_alpm_remove_prepare(handle, data) == -1) { /* pm_errno is set by _alpm_remove_prepare() */ return -1; } } else { if(_alpm_sync_prepare(handle, data) == -1) { /* pm_errno is set by _alpm_sync_prepare() */ return -1; } } if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) { _alpm_log(handle, ALPM_LOG_DEBUG, "sorting by dependencies\n"); if(trans->add) { alpm_list_t *add_orig = trans->add; trans->add = _alpm_sortbydeps(handle, add_orig, trans->remove, 0); alpm_list_free(add_orig); } if(trans->remove) { alpm_list_t *rem_orig = trans->remove; trans->remove = _alpm_sortbydeps(handle, rem_orig, NULL, 1); alpm_list_free(rem_orig); } } trans->state = STATE_PREPARED; return 0; }
pmconflict_t *_alpm_conflict_dup(const pmconflict_t *conflict) { pmconflict_t *newconflict; CALLOC(newconflict, 1, sizeof(pmconflict_t), RET_ERR(PM_ERR_MEMORY, NULL)); STRDUP(newconflict->package1, conflict->package1, RET_ERR(PM_ERR_MEMORY, NULL)); STRDUP(newconflict->package2, conflict->package2, RET_ERR(PM_ERR_MEMORY, NULL)); return(newconflict); }
/** Add a package to the transaction. */ int SYMEXPORT alpm_add_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg) { const char *pkgname, *pkgver; alpm_trans_t *trans; alpm_pkg_t *local; /* Sanity checks */ CHECK_HANDLE(handle, return -1); ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1)); ASSERT(handle == pkg->handle, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1)); trans = handle->trans; ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1)); ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1)); pkgname = pkg->name; pkgver = pkg->version; _alpm_log(handle, ALPM_LOG_DEBUG, "adding package '%s'\n", pkgname); if(alpm_pkg_find(trans->add, pkgname)) { RET_ERR(handle, ALPM_ERR_TRANS_DUP_TARGET, -1); } local = _alpm_db_get_pkgfromcache(handle->db_local, pkgname); if(local) { const char *localpkgname = local->name; const char *localpkgver = local->version; int cmp = _alpm_pkg_compare_versions(pkg, local); if(cmp == 0) { if(trans->flags & ALPM_TRANS_FLAG_NEEDED) { /* with the NEEDED flag, packages up to date are not reinstalled */ _alpm_log(handle, ALPM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"), localpkgname, localpkgver); return 0; } else if(!(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY)) { _alpm_log(handle, ALPM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"), localpkgname, localpkgver); } } else if(cmp < 0) { /* local version is newer */ _alpm_log(handle, ALPM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"), localpkgname, localpkgver, pkgver); } } /* add the package to the transaction */ pkg->reason = ALPM_PKG_REASON_EXPLICIT; _alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction add list\n", pkgname, pkgver); trans->add = alpm_list_add(trans->add, pkg); return 0; }
static int local_db_validate(pmdb_t *db) { struct dirent *ent = NULL; const char *dbpath; DIR *dbdir; int ret = -1; if(db->status & DB_STATUS_VALID) { return 0; } dbpath = _alpm_db_path(db); if(dbpath == NULL) { RET_ERR(db->handle, PM_ERR_DB_OPEN, -1); } dbdir = opendir(dbpath); if(dbdir == NULL) { if(errno == ENOENT) { /* database dir doesn't exist yet */ db->status |= DB_STATUS_VALID; return 0; } else { RET_ERR(db->handle, PM_ERR_DB_OPEN, -1); } } while((ent = readdir(dbdir)) != NULL) { const char *name = ent->d_name; char path[PATH_MAX]; if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) { continue; } if(!is_dir(dbpath, ent)) { continue; } snprintf(path, PATH_MAX, "%s%s/depends", dbpath, name); if(access(path, F_OK) == 0) { /* we found a depends file- bail */ db->handle->pm_errno = PM_ERR_DB_VERSION; goto done; } } /* we found no depends file after full scan */ db->status |= DB_STATUS_VALID; ret = 0; done: if(dbdir) { closedir(dbdir); } return ret; }
static struct dload_payload *build_payload(alpm_handle_t *handle, const char *filename, size_t size, alpm_list_t *servers) { struct dload_payload *payload; CALLOC(payload, 1, sizeof(*payload), RET_ERR(handle, ALPM_ERR_MEMORY, NULL)); STRDUP(payload->remote_name, filename, RET_ERR(handle, ALPM_ERR_MEMORY, NULL)); payload->max_size = size; payload->servers = servers; return payload; }
static int ata_wait_for_start_of_transfer(long timeout) { long startusec = USEC_TIMER; PASS_RC(ata_wait_for_not_bsy(timeout), 2, 0); while (true) { uint8_t dad = ata_read_cbr(&ATA_PIO_DAD); if (dad & BIT(0)) RET_ERR(1); if ((dad & (BIT(7) | BIT(3))) == BIT(3)) return 0; if (TIMEOUT_EXPIRED(startusec, timeout)) RET_ERR(2); } }
/** Commit a transaction. * @param data the address of an alpm_list where detailed description * of an error can be dumped (ie. list of conflicting files) * @return 0 on success, -1 on error (pm_errno is set accordingly) */ int SYMEXPORT alpm_trans_commit(alpm_list_t **data) { ALPM_LOG_FUNC; /* Sanity checks */ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1)); ASSERT(handle->trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(handle->trans->state == STATE_PREPARED, RET_ERR(PM_ERR_TRANS_NOT_PREPARED, -1)); return(_alpm_trans_commit(handle->trans, data)); }
/* We check if all smoothing constants are positive (MAP), * or all smoothing constants are zero. If some are positive, * but the others are zero, die immediately. We also check * if there exist parameters fixed at zero in MAP estimation. */ int check_smooth(int *smooth) { /* q = +4 : found non-zero smoothing constants +2 : found zero-valued smoothing constants +1 : found parameters fixed to zero */ int i, q = 0; SW_INS_PTR sw_ins_ptr; for (i = 0; i < occ_switch_tab_size; i++) { sw_ins_ptr = occ_switches[i]; while (sw_ins_ptr != NULL) { if (sw_ins_ptr->smooth_prolog < 0) { emit_error("negative delta values in MAP estimation"); RET_ERR(err_invalid_numeric_value); } q |= (sw_ins_ptr->smooth_prolog < TINY_PROB) ? 2 : 4; q |= (sw_ins_ptr->fixed && sw_ins_ptr->inside < TINY_PROB) ? 1 : 0; sw_ins_ptr = sw_ins_ptr->next; } } switch (q) { case 0: /* p.counts = (none), w/o 0-valued params */ case 1: /* p.counts = (none), with 0-valued params */ emit_internal_error("unexpected case in check_smooth()"); RET_ERR(ierr_unmatched_branches); break; case 2: /* p.counts = 0 only, w/o 0-valued params */ case 3: /* p.counts = 0 only, with 0-valued params */ *smooth = 0; break; case 4: /* p.counts = + only, w/o 0-valued params */ *smooth = 1; break; case 5: /* p.counts = + only, with 0-valued params */ emit_error("parameters fixed to zero in MAP estimation"); RET_ERR(err_invalid_numeric_value); break; case 6: /* p.counts = (both), w/o 0-valued params */ case 7: /* p.counts = (both), with 0-valued params */ emit_error("mixture of zero and non-zero pseudo counts"); RET_ERR(err_invalid_numeric_value); } transfer_hyperparams_prolog(); return BP_TRUE; }
/** Prepare a transaction. * @param data the address of an alpm_list where detailed description * of an error can be dumped (ie. list of conflicting files) * @return 0 on success, -1 on error (pm_errno is set accordingly) */ int SYMEXPORT alpm_trans_prepare(alpm_list_t **data) { ALPM_LOG_FUNC; /* Sanity checks */ ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1)); ASSERT(data != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1)); ASSERT(handle->trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(handle->trans->state == STATE_INITIALIZED, RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1)); return(_alpm_trans_prepare(handle->trans, data)); }
pmconflict_t *_alpm_conflict_new(const char *package1, const char *package2) { pmconflict_t *conflict; ALPM_LOG_FUNC; MALLOC(conflict, sizeof(pmconflict_t), RET_ERR(PM_ERR_MEMORY, NULL)); STRDUP(conflict->package1, package1, RET_ERR(PM_ERR_MEMORY, NULL)); STRDUP(conflict->package2, package2, RET_ERR(PM_ERR_MEMORY, NULL)); return(conflict); }
/** Open an archive for reading and perform the necessary boilerplate. * This takes care of creating the libarchive 'archive' struct, setting up * compression and format options, opening a file descriptor, setting up the * buffer size, and performing a stat on the path once opened. * On error, no file descriptor is opened, and the archive pointer returned * will be set to NULL. * @param handle the context handle * @param path the path of the archive to open * @param buf space for a stat buffer for the given path * @param archive pointer to place the created archive object * @param error error code to set on failure to open archive * @return -1 on failure, >=0 file descriptor on success */ int _alpm_open_archive(alpm_handle_t *handle, const char *path, struct stat *buf, struct archive **archive, alpm_errno_t error) { int fd; size_t bufsize = ALPM_BUFFER_SIZE; errno = 0; if((*archive = archive_read_new()) == NULL) { RET_ERR(handle, ALPM_ERR_LIBARCHIVE, -1); } archive_read_support_compression_all(*archive); archive_read_support_format_all(*archive); _alpm_log(handle, ALPM_LOG_DEBUG, "opening archive %s\n", path); OPEN(fd, path, O_RDONLY); if(fd < 0) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno)); goto error; } if(fstat(fd, buf) != 0) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not stat file %s: %s\n"), path, strerror(errno)); goto error; } #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE if(buf->st_blksize > ALPM_BUFFER_SIZE) { bufsize = buf->st_blksize; } #endif if(archive_read_open_fd(*archive, fd, bufsize) != ARCHIVE_OK) { _alpm_log(handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), path, archive_error_string(*archive)); goto error; } return fd; error: archive_read_finish(*archive); *archive = NULL; if(fd >= 0) { CLOSE(fd); } RET_ERR(handle, error, -1); }
/** Search for packages to upgrade and add them to the transaction. * @return 0 on success, -1 on error (pm_errno is set accordingly) */ int SYMEXPORT alpm_trans_sysupgrade() { pmtrans_t *trans; ALPM_LOG_FUNC; ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1)); trans = handle->trans; ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1)); ASSERT(trans->type == PM_TRANS_TYPE_SYNC, RET_ERR(PM_ERR_TRANS_TYPE, -1)); return(_alpm_trans_sysupgrade(trans)); }
static bool mmc_send_command(uint32_t cmd, uint32_t arg, uint32_t* result, int timeout) { long starttime = USEC_TIMER; while ((SDCI_STATE & SDCI_STATE_CMD_STATE_MASK) != SDCI_STATE_CMD_STATE_CMD_IDLE) { if (TIMEOUT_EXPIRED(starttime, timeout)) RET_ERR(0); yield(); } SDCI_STAC = SDCI_STAC_CLR_CMDEND | SDCI_STAC_CLR_BIT_3 | SDCI_STAC_CLR_RESEND | SDCI_STAC_CLR_DATEND | SDCI_STAC_CLR_DAT_CRCEND | SDCI_STAC_CLR_CRC_STAEND | SDCI_STAC_CLR_RESTOUTE | SDCI_STAC_CLR_RESENDE | SDCI_STAC_CLR_RESINDE | SDCI_STAC_CLR_RESCRCE | SDCI_STAC_CLR_WR_DATCRCE | SDCI_STAC_CLR_RD_DATCRCE | SDCI_STAC_CLR_RD_DATENDE0 | SDCI_STAC_CLR_RD_DATENDE1 | SDCI_STAC_CLR_RD_DATENDE2 | SDCI_STAC_CLR_RD_DATENDE3 | SDCI_STAC_CLR_RD_DATENDE4 | SDCI_STAC_CLR_RD_DATENDE5 | SDCI_STAC_CLR_RD_DATENDE6 | SDCI_STAC_CLR_RD_DATENDE7; SDCI_ARGU = arg; SDCI_CMD = cmd; if (!(SDCI_DSTA & SDCI_DSTA_CMDRDY)) RET_ERR(1); SDCI_CMD = cmd | SDCI_CMD_CMDSTR; long sleepbase = USEC_TIMER; while (TIMEOUT_EXPIRED(sleepbase, 1000)) yield(); while (!(SDCI_DSTA & SDCI_DSTA_CMDEND)) { if (TIMEOUT_EXPIRED(starttime, timeout)) RET_ERR(2); yield(); } if ((cmd & SDCI_CMD_RES_TYPE_MASK) != SDCI_CMD_RES_TYPE_NONE) { while (!(SDCI_DSTA & SDCI_DSTA_RESEND)) { if (TIMEOUT_EXPIRED(starttime, timeout)) RET_ERR(3); yield(); } if (cmd & SDCI_CMD_RES_BUSY) while (SDCI_DSTA & SDCI_DSTA_DAT_BUSY) { if (TIMEOUT_EXPIRED(starttime, CEATA_DAT_NONBUSY_TIMEOUT)) RET_ERR(4); yield(); } } bool nocrc = (cmd & SDCI_CMD_RES_SIZE_MASK) == SDCI_CMD_RES_SIZE_136; PASS_RC(mmc_dsta_check_command_success(nocrc), 3, 5); if (result) *result = SDCI_RESP0; return 0; }
int _pacman_handle_get_option(pmhandle_t *ph, unsigned char val, long *data) { /* Sanity checks */ ASSERT(ph != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1)); switch(val) { case PM_OPT_ROOT: *data = (long)ph->root; break; case PM_OPT_DBPATH: *data = (long)ph->dbpath; break; case PM_OPT_CACHEDIR: *data = (long)ph->cachedir; break; case PM_OPT_HOOKSDIR: *data = (long)ph->hooksdir; break; case PM_OPT_LOCALDB: *data = (long)ph->db_local; break; case PM_OPT_SYNCDB: *data = (long)ph->dbs_sync; break; case PM_OPT_LOGFILE: *data = (long)ph->logfile; break; case PM_OPT_NOUPGRADE: *data = (long)ph->noupgrade; break; case PM_OPT_NOEXTRACT: *data = (long)ph->noextract; break; case PM_OPT_IGNOREPKG: *data = (long)ph->ignorepkg; break; case PM_OPT_HOLDPKG: *data = (long)ph->holdpkg; break; case PM_OPT_NEEDLES: *data = (long)ph->needles; break; case PM_OPT_USESYSLOG: *data = ph->usesyslog; break; case PM_OPT_LOGCB: *data = (long)pm_logcb; break; case PM_OPT_DLCB: *data = (long)pm_dlcb; break; case PM_OPT_UPGRADEDELAY: *data = (long)ph->upgradedelay; break; case PM_OPT_OLDDELAY: *data = (long)ph->olddelay; break; case PM_OPT_LOGMASK: *data = pm_logmask; break; case PM_OPT_DLFNM: *data = (long)pm_dlfnm; break; case PM_OPT_DLOFFSET: *data = (long)pm_dloffset; break; case PM_OPT_DLT0: *data = (long)pm_dlt0; break; case PM_OPT_DLT: *data = (long)pm_dlt; break; case PM_OPT_DLRATE: *data = (long)pm_dlrate; break; case PM_OPT_DLXFERED1: *data = (long)pm_dlxfered1; break; case PM_OPT_DLETA_H: *data = (long)pm_dleta_h; break; case PM_OPT_DLETA_M: *data = (long)pm_dleta_m; break; case PM_OPT_DLETA_S: *data = (long)pm_dleta_s; break; case PM_OPT_DLREMAIN: *data = (long)ph->dlremain; break; case PM_OPT_DLHOWMANY: *data = (long)ph->dlhowmany; break; case PM_OPT_PROXYHOST: *data = (long)ph->proxyhost; break; case PM_OPT_PROXYPORT: *data = ph->proxyport; break; case PM_OPT_XFERCOMMAND: *data = (long)ph->xfercommand; break; case PM_OPT_NOPASSIVEFTP: *data = ph->nopassiveftp; break; case PM_OPT_CHOMP: *data = ph->chomp; break; case PM_OPT_MAXTRIES: *data = ph->maxtries; break; default: RET_ERR(PM_ERR_WRONG_ARGS, -1); break; } return(0); }