static bool erase_entry(struct exfat* ef, struct exfat_node* node)
{
cluster_t cluster = node->entry_cluster;
off64_t offset = node->entry_offset;
int name_entries = DIV_ROUND_UP(utf16_length(node->name), EXFAT_ENAME_MAX);
uint8_t entry_type;
entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID;
if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0)
{
exfat_error("failed to erase meta1 entry");
return false;
}
next_entry(ef, node->parent, &cluster, &offset);
entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;
if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0)
{
exfat_error("failed to erase meta2 entry");
return false;
}
while (name_entries--)
{
next_entry(ef, node->parent, &cluster, &offset);
entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID;
if (exfat_pwrite(ef->dev, &entry_type, 1,
co2o(ef, cluster, offset)) < 0)
{
exfat_error("failed to erase name entry");
return false;
}
}
return true;
}
int tux_readdir(struct file *file, void *state, filldir_t filldir)
{
loff_t pos = file->f_pos;
#ifdef __KERNEL__
struct inode *dir = file->f_dentry->d_inode;
#else
struct inode *dir = file->f_inode;
#endif
int revalidate = file->f_version != dir->i_version;
struct sb *sb = tux_sb(dir->i_sb);
unsigned blockbits = sb->blockbits;
block_t block, blocks = dir->i_size >> blockbits;
unsigned offset = pos & sb->blockmask;
assert(!(dir->i_size & sb->blockmask));
for (block = pos >> blockbits ; block < blocks; block++) {
struct buffer_head *buffer = blockread(mapping(dir), block);
if (!buffer)
return -EIO;
void *base = bufdata(buffer);
if (revalidate) {
if (offset) {
tux_dirent *entry = base + offset;
tux_dirent *p = base + (offset & sb->blockmask);
while (p < entry && p->rec_len)
p = next_entry(p);
offset = (void *)p - base;
file->f_pos = (block << blockbits) + offset;
}
file->f_version = dir->i_version;
revalidate = 0;
}
tux_dirent *limit = base + sb->blocksize - TUX_REC_LEN(1);
for (tux_dirent *entry = base + offset; entry <= limit; entry = next_entry(entry)) {
if (entry->rec_len == 0) {
blockput(buffer);
tux_zero_len_error(dir, block);
return -EIO;
}
if (!is_deleted(entry)) {
unsigned type = (entry->type < TUX_TYPES) ? filetype[entry->type] : DT_UNKNOWN;
int lame = filldir(
state, entry->name, entry->name_len,
(block << blockbits) | ((void *)entry - base),
be64_to_cpu(entry->inum), type);
if (lame) {
blockput(buffer);
return 0;
}
}
file->f_pos += tux_rec_len_from_disk(entry->rec_len);
}
blockput(buffer);
offset = 0;
}
return 0;
}
int avtab_read_item(void *fp, struct avtab_datum *avdatum, struct avtab_key *avkey)
{
__u32 *buf;
__u32 items, items2;
memset(avkey, 0, sizeof(struct avtab_key));
memset(avdatum, 0, sizeof(struct avtab_datum));
buf = next_entry(fp, sizeof(__u32));
if (!buf) {
printk(KERN_ERR "security: avtab: truncated entry\n");
goto bad;
}
items2 = le32_to_cpu(buf[0]);
buf = next_entry(fp, sizeof(__u32)*items2);
if (!buf) {
printk(KERN_ERR "security: avtab: truncated entry\n");
goto bad;
}
items = 0;
avkey->source_type = le32_to_cpu(buf[items++]);
avkey->target_type = le32_to_cpu(buf[items++]);
avkey->target_class = le32_to_cpu(buf[items++]);
avdatum->specified = le32_to_cpu(buf[items++]);
if (!(avdatum->specified & (AVTAB_AV | AVTAB_TYPE))) {
printk(KERN_ERR "security: avtab: null entry\n");
goto bad;
}
if ((avdatum->specified & AVTAB_AV) &&
(avdatum->specified & AVTAB_TYPE)) {
printk(KERN_ERR "security: avtab: entry has both access vectors and types\n");
goto bad;
}
if (avdatum->specified & AVTAB_AV) {
if (avdatum->specified & AVTAB_ALLOWED)
avtab_allowed(avdatum) = le32_to_cpu(buf[items++]);
if (avdatum->specified & AVTAB_AUDITDENY)
avtab_auditdeny(avdatum) = le32_to_cpu(buf[items++]);
if (avdatum->specified & AVTAB_AUDITALLOW)
avtab_auditallow(avdatum) = le32_to_cpu(buf[items++]);
} else {
if (avdatum->specified & AVTAB_TRANSITION)
avtab_transition(avdatum) = le32_to_cpu(buf[items++]);
if (avdatum->specified & AVTAB_CHANGE)
avtab_change(avdatum) = le32_to_cpu(buf[items++]);
if (avdatum->specified & AVTAB_MEMBER)
avtab_member(avdatum) = le32_to_cpu(buf[items++]);
}
if (items != items2) {
printk(KERN_ERR "security: avtab: entry only had %d items, expected %d\n",
items2, items);
goto bad;
}
return 0;
bad:
return -1;
}
int regex_load_mmap(struct mmap_area *mmap_area, struct regex_data **regex,
int unused __attribute__((unused)), bool *regex_compiled)
{
int rc;
uint32_t entry_len;
size_t info_len;
rc = next_entry(&entry_len, mmap_area, sizeof(uint32_t));
if (rc < 0 || !entry_len)
return -1;
*regex = regex_data_create();
if (!(*regex))
return -1;
(*regex)->owned = 0;
(*regex)->regex = (pcre *)mmap_area->next_addr;
rc = next_entry(NULL, mmap_area, entry_len);
if (rc < 0)
goto err;
/*
* Check that regex lengths match. pcre_fullinfo()
* also validates its magic number.
*/
rc = pcre_fullinfo((*regex)->regex, NULL, PCRE_INFO_SIZE, &info_len);
if (rc < 0 || info_len != entry_len)
goto err;
rc = next_entry(&entry_len, mmap_area, sizeof(uint32_t));
if (rc < 0 || !entry_len)
goto err;
if (entry_len) {
(*regex)->lsd.study_data = (void *)mmap_area->next_addr;
(*regex)->lsd.flags |= PCRE_EXTRA_STUDY_DATA;
rc = next_entry(NULL, mmap_area, entry_len);
if (rc < 0)
goto err;
/* Check that study data lengths match. */
rc = pcre_fullinfo((*regex)->regex, &(*regex)->lsd,
PCRE_INFO_STUDYSIZE, &info_len);
if (rc < 0 || info_len != entry_len)
goto err;
}
*regex_compiled = true;
return 0;
err:
regex_data_free(*regex);
*regex = NULL;
return -1;
}
int sens_read(struct policydb *p, struct hashtab *h, void *fp)
{
char *key = NULL;
struct level_datum *levdatum;
int rc;
u32 *buf, len;
levdatum = kmalloc(sizeof(*levdatum), GFP_ATOMIC);
if (!levdatum) {
rc = -ENOMEM;
goto out;
}
memset(levdatum, 0, sizeof(*levdatum));
buf = next_entry(fp, sizeof(u32)*2);
if (!buf) {
rc = -EINVAL;
goto bad;
}
len = le32_to_cpu(buf[0]);
levdatum->isalias = le32_to_cpu(buf[1]);
buf = next_entry(fp, len);
if (!buf) {
rc = -EINVAL;
goto bad;
}
key = kmalloc(len + 1,GFP_ATOMIC);
if (!key) {
rc = -ENOMEM;
goto bad;
}
memcpy(key, buf, len);
key[len] = 0;
levdatum->level = mls_read_level(fp);
if (!levdatum->level) {
rc = -EINVAL;
goto bad;
}
rc = hashtab_insert(h, key, levdatum);
if (rc)
goto bad;
out:
return rc;
bad:
sens_destroy(key, levdatum, NULL);
goto out;
}
/*
* Read a MLS range structure from a policydb binary
* representation file.
*/
static int mls_read_range_helper(struct mls_range *r, void *fp)
{
u32 *buf;
int items, rc = -EINVAL;
buf = next_entry(fp, sizeof(u32));
if (!buf)
goto out;
items = le32_to_cpu(buf[0]);
buf = next_entry(fp, sizeof(u32) * items);
if (!buf) {
printk(KERN_ERR "security: mls: truncated range\n");
goto out;
}
r->level[0].sens = le32_to_cpu(buf[0]);
if (items > 1) {
r->level[1].sens = le32_to_cpu(buf[1]);
} else {
r->level[1].sens = r->level[0].sens;
}
rc = ebitmap_read(&r->level[0].cat, fp);
if (rc) {
printk(KERN_ERR "security: mls: error reading low "
"categories\n");
goto out;
}
if (items > 1) {
rc = ebitmap_read(&r->level[1].cat, fp);
if (rc) {
printk(KERN_ERR "security: mls: error reading high "
"categories\n");
goto bad_high;
}
} else {
rc = ebitmap_cpy(&r->level[1].cat, &r->level[0].cat);
if (rc) {
printk(KERN_ERR "security: mls: out of memory\n");
goto bad_high;
}
}
rc = 0;
out:
return rc;
bad_high:
ebitmap_destroy(&r->level[0].cat);
goto out;
}
/* Get the section offsets from a package file, offsets will be malloc'd to
* the appropriate size and the caller must free() them */
static int module_package_read_offsets(sepol_module_package_t *mod,
struct policy_file *file,
size_t **offsets,
uint32_t *sections)
{
uint32_t *buf, nsec;
unsigned i;
buf = next_entry(file, sizeof(uint32_t) * 3);
if (!buf) {
ERR(file->handle, "module package header truncated");
return -1;
}
if (le32_to_cpu(buf[0]) != SEPOL_MODULE_PACKAGE_MAGIC) {
ERR(file->handle, "wrong magic number for module package: expected %u, got %u", SEPOL_MODULE_PACKAGE_MAGIC, le32_to_cpu(buf[0]));
return -1;
}
mod->version = le32_to_cpu(buf[1]);
nsec = *sections = le32_to_cpu(buf[2]);
if (nsec > MAXSECTIONS) {
ERR(file->handle, "too many sections (%u) in module package", nsec);
return -1;
}
*offsets = (size_t *)malloc((nsec + 1) * sizeof(size_t));
if (!*offsets) {
ERR(file->handle, "out of memory");
return -1;
}
buf = next_entry(file, sizeof(uint32_t) * nsec);
if (!buf) {
ERR(file->handle, "module package offset array truncated");
return -1;
}
for (i = 0; i < nsec; i++) {
(*offsets)[i] = le32_to_cpu(buf[i]);
if (i && (*offsets)[i] < (*offsets)[i - 1]) {
ERR(file->handle, "offsets are not increasing (at %u, "
"offset %zu -> %zu", i, (*offsets)[i-1], (*offsets)[i]);
return -1;
}
}
(*offsets)[nsec] = policy_file_length(file);
return 0;
}
int regex_load_mmap(struct mmap_area *mmap_area, struct regex_data **regex,
int do_load_precompregex, bool *regex_compiled)
{
int rc;
uint32_t entry_len;
*regex_compiled = false;
rc = next_entry(&entry_len, mmap_area, sizeof(uint32_t));
if (rc < 0)
return -1;
if (entry_len && do_load_precompregex) {
/*
* this should yield exactly one because we store one pattern at
* a time
*/
rc = pcre2_serialize_get_number_of_codes(mmap_area->next_addr);
if (rc != 1)
return -1;
*regex = regex_data_create();
if (!*regex)
return -1;
rc = pcre2_serialize_decode(&(*regex)->regex, 1,
(PCRE2_SPTR)mmap_area->next_addr,
NULL);
if (rc != 1)
goto err;
(*regex)->match_data =
pcre2_match_data_create_from_pattern((*regex)->regex, NULL);
if (!(*regex)->match_data)
goto err;
*regex_compiled = true;
}
/* and skip the decoded bit */
rc = next_entry(NULL, mmap_area, entry_len);
if (rc < 0)
goto err;
return 0;
err:
regex_data_free(*regex);
*regex = NULL;
return -1;
}
tux_dirent *tux_find_entry(struct inode *dir, const char *name, unsigned len,
struct buffer_head **result, loff_t size)
{
struct sb *sb = tux_sb(dir->i_sb);
unsigned reclen = TUX_REC_LEN(len);
block_t block, blocks = size >> sb->blockbits;
int err = -ENOENT;
for (block = 0; block < blocks; block++) {
struct buffer_head *buffer = blockread(mapping(dir), block);
if (!buffer) {
err = -EIO; // need ERR_PTR for blockread!!!
goto error;
}
tux_dirent *entry = bufdata(buffer);
tux_dirent *limit = (void *)entry + sb->blocksize - reclen;
while (entry <= limit) {
if (entry->rec_len == 0) {
blockput(buffer);
tux_zero_len_error(dir, block);
err = -EIO;
goto error;
}
if (tux_match(entry, name, len)) {
*result = buffer;
return entry;
}
entry = next_entry(entry);
}
blockput(buffer);
}
error:
*result = NULL; /* for debug */
return ERR_PTR(err);
}
/*
* Read a MLS level structure from a policydb binary
* representation file.
*/
struct mls_level *mls_read_level(void *fp)
{
struct mls_level *l;
u32 *buf;
l = kmalloc(sizeof(*l), GFP_ATOMIC);
if (!l) {
printk(KERN_ERR "security: mls: out of memory\n");
return NULL;
}
memset(l, 0, sizeof(*l));
buf = next_entry(fp, sizeof(u32));
if (!buf) {
printk(KERN_ERR "security: mls: truncated level\n");
goto bad;
}
l->sens = cpu_to_le32(buf[0]);
if (ebitmap_read(&l->cat, fp)) {
printk(KERN_ERR "security: mls: error reading level "
"categories\n");
goto bad;
}
return l;
bad:
kfree(l);
return NULL;
}
/* general BPLUS block level functions */
static int find_block(ENTRY *pe, int *poff)
{
register int pos, nextpos;
int ret;
pos = -1;
nextpos = 0;
ret = 1;
/*printf("block_ptr->bend = %d.\n", block_ptr->bend);*/
while ( nextpos < block_ptr->bend)
{
/*ret = strcmp((char *)(pe->key),*/
/*(char *)(ENT_ADR(block_ptr, nextpos)->key));*/
ret = key_cmp((char *)(pe->key),(char *)(ENT_ADR(block_ptr, nextpos)->key));
/*printf("debug: in find_block()2 key1=%s, key2=%s, nextpos = %d ret=%d\n", pe->key, ENT_ADR(block_ptr, nextpos)->key, nextpos, ret);*/
if (ret <= 0)
{
if (ret == 0)
{
pos = nextpos;
}
break;
}
pos = nextpos;
nextpos = next_entry(pos);
}
/*printf("debug: in find_block()4 nextpos = %d, block_ptr->bend=%d\t", nextpos, block_ptr->bend);*/
//getchar();
CO(pci->level) = pos;
*poff = pos;
/*printf("debug: out of find_block().\n\n");*/
return ret;
}
struct dl_dma_list*
dl_dma_map_user_buffer(void* page_array, unsigned long num_pages, int direction, void* pdev)
{
int i = 0;
struct dl_dma_list* sl = NULL;
struct dl_dma_entry *e = NULL;
struct page** pages = (struct page**)page_array;
if (!page_array)
return NULL;
sl = alloc_dl_dma_entry(num_pages);
if (!sl)
return NULL;
e = first_entry(sl);
direction = bmd_to_linux_direction(direction);
for (i = 0; i < num_pages; i++)
{
e->dma_addr = pci_map_page(pdev, pages[i], 0, PAGE_SIZE, direction);
e = next_entry(e);
}
sl->num_pages = num_pages;
sl->pdev = pdev;
return sl;
}
struct archive_entry *
archive_entry_partial_links(struct archive_entry_linkresolver *res,
unsigned int *links)
{
struct archive_entry *e;
struct links_entry *le;
/* Free a held entry. */
if (res->spare != NULL) {
archive_entry_free(res->spare->canonical);
archive_entry_free(res->spare->entry);
free(res->spare);
res->spare = NULL;
}
le = next_entry(res, NEXT_ENTRY_PARTIAL);
if (le != NULL) {
e = le->canonical;
if (links != NULL)
*links = le->links;
le->canonical = NULL;
} else {
e = NULL;
if (links != NULL)
*links = 0;
}
return (e);
}
int cat_read(struct policydb *p, struct hashtab *h, void *fp)
{
char *key = NULL;
struct cat_datum *catdatum;
int rc;
u32 *buf, len;
catdatum = kmalloc(sizeof(*catdatum), GFP_ATOMIC);
if (!catdatum) {
rc = -ENOMEM;
goto out;
}
memset(catdatum, 0, sizeof(*catdatum));
buf = next_entry(fp, sizeof(u32)*3);
if (!buf) {
rc = -EINVAL;
goto bad;
}
len = le32_to_cpu(buf[0]);
catdatum->value = le32_to_cpu(buf[1]);
catdatum->isalias = le32_to_cpu(buf[2]);
buf = next_entry(fp, len);
if (!buf) {
rc = -EINVAL;
goto bad;
}
key = kmalloc(len + 1,GFP_ATOMIC);
if (!key) {
rc = -ENOMEM;
goto bad;
}
memcpy(key, buf, len);
key[len] = 0;
rc = hashtab_insert(h, key, catdatum);
if (rc)
goto bad;
out:
return rc;
bad:
cat_destroy(key, catdatum, NULL);
goto out;
}
static flash_entry_header_t *find_entry(flash_file_token_t token)
{
for (int s = 0; sector_map[s].address; s++) {
h_magic_t *pmagic = (h_magic_t *) sector_map[s].address;
h_magic_t *pe = pmagic + (sector_map[s].size / sizeof(h_magic_t)) - 1;
/* Hunt for Magic Signature */
cont:
while (pmagic != pe && !valid_magic(pmagic)) {
pmagic++;
}
/* Did we reach the end
* if so try the next sector */
if (pmagic == pe) { continue; }
/* Found a magic So assume it is a file header */
flash_entry_header_t *pf = (flash_entry_header_t *) pmagic;
/* Test the CRC */
if (pf->crc == crc32(entry_crc_start(pf), entry_crc_length(pf))) {
/* Good CRC is it the one we are looking for ?*/
if (valid_entry(pf) && pf->file_token.t == token.t) {
return pf;
} else {
/* Not the one we wanted but we can trust the size */
pf = next_entry(pf);
pmagic = (h_magic_t *) pf;
/* If the next one is erased */
if (blank_entry(pf)) {
continue;
}
}
goto cont;
} else {
/* in valid CRC so keep looking */
pmagic++;
}
}
return NULL;
}
int tux_delete_entry(struct inode *dir, struct buffer_head *buffer,
tux_dirent *entry)
{
unsigned delta = tux3_get_current_delta();
tux_dirent *prev = NULL, *this = bufdata(buffer);
struct buffer_head *clone;
void *olddata;
while ((char *)this < (char *)entry) {
if (this->rec_len == 0) {
blockput(buffer);
tux_zero_len_error(dir, bufindex(buffer));
return -EIO;
}
prev = this;
this = next_entry(this);
}
/*
* The directory is protected by i_mutex.
* blockdirty() should never return -EAGAIN.
*/
olddata = bufdata(buffer);
clone = blockdirty(buffer, delta);
if (IS_ERR(clone)) {
assert(PTR_ERR(clone) != -EAGAIN);
blockput(buffer);
return PTR_ERR(clone);
}
entry = ptr_redirect(entry, olddata, bufdata(clone));
prev = ptr_redirect(prev, olddata, bufdata(clone));
if (prev)
prev->rec_len = tux_rec_len_to_disk((void *)next_entry(entry) - (void *)prev);
memset(entry->name, 0, entry->name_len);
entry->name_len = entry->type = 0;
entry->inum = 0;
mark_buffer_dirty_non(clone);
blockput(clone);
return 0;
}
int mls_read_perm(struct perm_datum *perdatum, void *fp)
{
u32 *buf;
buf = next_entry(fp, sizeof(u32));
if (!buf)
return -EINVAL;
perdatum->base_perms = le32_to_cpu(buf[0]);
return 0;
}
int mls_read_nlevels(struct policydb *p, void *fp)
{
u32 *buf;
buf = next_entry(fp, sizeof(u32));
if (!buf)
return -EINVAL;
p->nlevels = le32_to_cpu(buf[0]);
return 0;
}
int find_winner_euc(struct entries *codes, struct data_entry *sample,
struct winner_info *win, int knn)
{
struct data_entry *codetmp;
int dim, i, masked;
float diffsf, diff, difference;
eptr p;
dim = codes->dimension;
win->index = -1;
win->winner = NULL;
win->diff = -1.0;
/* Go through all code vectors */
codetmp = rewind_entries(codes, &p);
diffsf = FLT_MAX;
while (codetmp != NULL) {
difference = 0.0;
masked = 0;
/* Compute the distance between codebook and input entry */
for (i = 0; i < dim; i++)
{
if ((sample->mask != NULL) && (sample->mask[i] != 0))
{
masked++;
continue; /* ignore vector components that have 1 in mask */
}
diff = codetmp->points[i] - sample->points[i];
difference += diff * diff;
if (difference > diffsf) break;
}
if (masked == dim)
return 0; /* can't calculate winner, empty data vector */
/* If distance is smaller than previous distances */
if (difference < diffsf) {
win->winner = codetmp;
win->index = p.index;
win->diff = difference;
diffsf = difference;
}
codetmp = next_entry(&p);
}
if (win->index < 0)
ifverbose(3)
fprintf(stderr, "find_winner_euc: can't find winner\n");
return 1; /* number of neighbours */
}
int
hash_next (hashiter *iter, void **key, void **value)
{
hashbucket *bucket = next_entry (iter);
if (bucket == NULL)
return 0;
if (key)
*key = bucket->key;
if (value)
*value = bucket->value;
return 1;
}
static void erase_entry(struct exfat* ef, struct exfat_node* node)
{
cluster_t cluster = node->entry_cluster;
off64_t offset = node->entry_offset;
int name_entries = DIV_ROUND_UP(utf16_length(node->name), EXFAT_ENAME_MAX);
uint8_t entry_type;
entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID;
exfat_write_raw(&entry_type, 1, co2o(ef, cluster, offset), ef->fd);
next_entry(ef, node->parent, &cluster, &offset);
entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;
exfat_write_raw(&entry_type, 1, co2o(ef, cluster, offset), ef->fd);
while (name_entries--)
{
next_entry(ef, node->parent, &cluster, &offset);
entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID;
exfat_write_raw(&entry_type, 1, co2o(ef, cluster, offset), ef->fd);
}
}
void
archive_entry_linkresolver_free(struct archive_entry_linkresolver *res)
{
struct links_entry *le;
if (res == NULL)
return;
while ((le = next_entry(res, NEXT_ENTRY_ALL)) != NULL)
archive_entry_free(le->entry);
free(res->buckets);
free(res);
}
/* get next, previous entries */
int next_key(ENTRY *pe, IX_DESC *pix)
{
RECPOS address;
if(block_ptr->bend == 0)
{
return IX_FAIL;
}
pci = pix;
retrieve_block(pci->level, CB(pci->level));
address = ENT_ADR(block_ptr, CO(pci->level))->idxptr;
while (address != NULLREC)
{
retrieve_block(++(pci->level), address);
CO(pci->level) = -1;
address = block_ptr->p0;
}
next_entry(CO(pci->level));
if (CO(pci->level) == block_ptr->bend)
{
do
{
if(pci->level == 0)
{
last_key(pci);
return (EOIX);
}
--(pci->level);
retrieve_block(pci->level, CB(pci->level));
next_entry(CO(pci->level));
} while (CO(pci->level) == block_ptr->bend);
}
copy_entry(pe, ENT_ADR(block_ptr, CO(pci->level)));
return ( IX_OK );
}
static sector_descriptor_t *check_free_space_in_sector(flash_entry_header_t
*pf, size_t new_size)
{
sector_descriptor_t *sm = get_sector_info(pf);
uint8_t *psector_first = (uint8_t *) sm->address;
uint8_t *psector_last = psector_first + sm->size - 1;
uint8_t *pnext_end = (uint8_t *)(valid_magic((h_magic_t *)pf) ? next_entry(pf) : pf) + new_size;
if (pnext_end >= psector_first && pnext_end <= psector_last) {
sm = 0;
}
return sm;
}
int find_winner_euc2(struct entries *codes, struct data_entry *sample,
struct winner_info *win, int knn)
{
struct data_entry *codetmp;
int dim, i;
float diffsf, diff, difference, *s, *c;
eptr p;
if (sample->mask != NULL)
return find_winner_euc(codes, sample, win, knn);
dim = codes->dimension;
win->index = -1;
win->winner = NULL;
win->diff = -1.0;
/* Go through all code vectors */
codetmp = rewind_entries(codes, &p);
diffsf = FLT_MAX;
while (codetmp != NULL) {
difference = 0.0;
/* Compute the distance between codebook and input entry */
c = codetmp->points; s = sample->points;
for (i = 0; i < dim; i++)
{
diff = *c++ - *s++;
difference += diff * diff;
}
/* If distance is smaller than previous distances */
if (difference < diffsf) {
win->winner = codetmp;
win->index = p.index;
win->diff = difference;
diffsf = difference;
}
codetmp = next_entry(&p);
}
if (win->index < 0)
ifverbose(3)
fprintf(stderr, "find_winner_euc: can't find winner\n");
return 1; /* number of neighbours */
}
void
archive_entry_linkresolver_free(struct archive_entry_linkresolver *res)
{
struct links_entry *le;
if (res == NULL)
return;
if (res->buckets != NULL) {
while ((le = next_entry(res)) != NULL)
archive_entry_free(le->entry);
free(res->buckets);
res->buckets = NULL;
}
free(res);
}
/*
* Read a MLS perms structure from a policydb binary
* representation file.
*/
int mls_read_class(struct class_datum *cladatum, void *fp)
{
struct mls_perms *p = &cladatum->mlsperms;
u32 *buf;
buf = next_entry(fp, sizeof(u32)*4);
if (!buf) {
printk(KERN_ERR "security: mls: truncated mls permissions\n");
return -EINVAL;
}
p->read = le32_to_cpu(buf[0]);
p->readby = le32_to_cpu(buf[1]);
p->write = le32_to_cpu(buf[2]);
p->writeby = le32_to_cpu(buf[3]);
return 0;
}
static int
archive_read_format_iso9660_cleanup(struct archive_read *a)
{
struct iso9660 *iso9660;
struct file_info *file;
iso9660 = (struct iso9660 *)(a->format->data);
while ((file = next_entry(iso9660)) != NULL)
release_file(iso9660, file);
archive_string_free(&iso9660->pathname);
archive_string_free(&iso9660->previous_pathname);
if (iso9660->pending_files)
free(iso9660->pending_files);
free(iso9660);
(a->format->data) = NULL;
return (ARCHIVE_OK);
}
void exfat_flush_node(struct exfat* ef, struct exfat_node* node)
{
cluster_t cluster;
off64_t offset;
off64_t meta1_offset, meta2_offset;
struct exfat_entry_meta1 meta1;
struct exfat_entry_meta2 meta2;
if (ef->ro)
exfat_bug("unable to flush node to read-only FS");
if (node->parent == NULL)
return; /* do not flush unlinked node */
cluster = node->entry_cluster;
offset = node->entry_offset;
meta1_offset = co2o(ef, cluster, offset);
next_entry(ef, node->parent, &cluster, &offset);
meta2_offset = co2o(ef, cluster, offset);
exfat_read_raw(&meta1, sizeof(meta1), meta1_offset, ef->fd);
if (meta1.type != EXFAT_ENTRY_FILE)
exfat_bug("invalid type of meta1: 0x%hhx", meta1.type);
meta1.attrib = cpu_to_le16(node->flags);
exfat_unix2exfat(node->mtime, &meta1.mdate, &meta1.mtime, &meta1.mtime_cs);
exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL);
exfat_read_raw(&meta2, sizeof(meta2), meta2_offset, ef->fd);
if (meta2.type != EXFAT_ENTRY_FILE_INFO)
exfat_bug("invalid type of meta2: 0x%hhx", meta2.type);
meta2.size = meta2.real_size = cpu_to_le64(node->size);
meta2.start_cluster = cpu_to_le32(node->start_cluster);
meta2.flags = EXFAT_FLAG_ALWAYS1;
/* empty files must not be marked as contiguous */
if (node->size != 0 && IS_CONTIGUOUS(*node))
meta2.flags |= EXFAT_FLAG_CONTIGUOUS;
/* name hash remains unchanged, no need to recalculate it */
meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
exfat_write_raw(&meta1, sizeof(meta1), meta1_offset, ef->fd);
exfat_write_raw(&meta2, sizeof(meta2), meta2_offset, ef->fd);
node->flags &= ~EXFAT_ATTRIB_DIRTY;
}
/**
* De-regsiter a thread and de-allocate all resources. This function
* should be called when a thread exits.
*/
void rec_sched_deregister_thread(struct task** t_ptr)
{
struct task* t = *t_ptr;
pid_t tid = t->tid;
struct tasklist_entry* entry = get_entry(tid);
if (entry == current_entry) {
current_entry = next_entry(entry);
if (entry == current_entry) {
assert(num_active_threads == 1);
current_entry = NULL;
}
}
/* We expect tasks to usually exit by a call to exit() or
* exit_group(), so it's not helpful to warn about that. */
if (FIXEDSTACK_DEPTH(&t->pending_events) > 2
|| !(t->ev->type == EV_SYSCALL
&& (SYS_exit == t->ev->syscall.no
|| SYS_exit_group == t->ev->syscall.no))) {
log_warn("%d still has pending events. From top down:",
t->tid);
log_pending_events(t);
}
task_group_remove_and_unref(t);
CIRCLEQ_REMOVE(&head, entry, entries);
tid_to_entry[tid] = NULL;
num_active_threads--;
assert(num_active_threads >= 0);
/* delete all counter data */
cleanup_hpc(t);
sys_close(t->child_mem_fd);
close(t->desched_fd);
detach_and_reap(t);
/* finally, free the memory */
sighandlers_unref(&t->sighandlers);
sys_free((void**)entry);
*t_ptr = NULL;
}
