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