int pt_image_add(struct pt_image *image, struct pt_section *section)
{
struct pt_section_list **list, *next;
uint64_t begin, end;
if (!image || !section)
return -pte_invalid;
begin = pt_section_begin(section);
end = pt_section_end(section);
/* Check for overlaps while we move to the end of the list. */
for (list = &(image->sections); *list; list = &((*list)->next)) {
uint64_t lbegin, lend;
lbegin = pt_section_begin((*list)->section);
lend = pt_section_end((*list)->section);
if (end < lbegin)
continue;
if (lend <= begin)
continue;
return -pte_bad_context;
}
next = pt_mk_section_list(section);
if (!next)
return -pte_nomap;
*list = next;
return 0;
}
static int pt_image_clone(struct pt_section_list **list,
const struct pt_mapped_section *msec,
uint64_t begin, uint64_t end, int isid)
{
const struct pt_asid *masid;
struct pt_section_list *next;
struct pt_section *section, *sec;
uint64_t mbegin, sbegin, offset, size;
int errcode;
if (!list || !msec)
return -pte_internal;
sec = pt_msec_section(msec);
masid = pt_msec_asid(msec);
mbegin = pt_msec_begin(msec);
sbegin = pt_section_offset(sec);
if (end <= begin)
return -pte_internal;
if (begin < mbegin)
return -pte_internal;
offset = begin - mbegin;
size = end - begin;
errcode = pt_section_clone(§ion, sec, sbegin + offset, size);
if (errcode < 0)
return errcode;
next = pt_mk_section_list(section, masid, begin, isid);
if (!next) {
(void) pt_section_put(section);
return -pte_nomem;
}
/* The image list got its own reference; let's drop ours. */
errcode = pt_section_put(section);
if (errcode < 0) {
pt_section_list_free(next);
return errcode;
}
/* Add the new section. */
next->next = *list;
*list = next;
return 0;
}
int pt_image_add(struct pt_image *image, struct pt_section *section,
const struct pt_asid *asid, uint64_t vaddr)
{
struct pt_section_list **list, *next;
uint64_t begin, end;
int errcode;
if (!image || !section)
return -pte_internal;
begin = vaddr;
end = begin + pt_section_size(section);
/* Check for overlaps while we move to the end of the list. */
for (list = &(image->sections); *list; list = &((*list)->next)) {
const struct pt_mapped_section *msec;
uint64_t lbegin, lend;
msec = &(*list)->section;
errcode = pt_msec_matches_asid(msec, asid);
if (errcode < 0)
return errcode;
if (!errcode)
continue;
lbegin = pt_msec_begin(msec);
lend = pt_msec_end(msec);
if (end <= lbegin)
continue;
if (lend <= begin)
continue;
return -pte_bad_image;
}
next = pt_mk_section_list(section, asid, vaddr);
if (!next)
return -pte_nomap;
*list = next;
return 0;
}
int pt_image_add(struct pt_image *image, struct pt_section *section,
const struct pt_asid *asid, uint64_t vaddr, int isid)
{
struct pt_section_list **list, *next, *removed;
uint64_t begin, end;
int errcode;
if (!image || !section)
return -pte_internal;
next = pt_mk_section_list(section, asid, vaddr, isid);
if (!next)
return -pte_nomem;
removed = NULL;
errcode = 0;
begin = vaddr;
end = begin + pt_section_size(section);
/* Check for overlaps while we move to the end of the list. */
list = &(image->sections);
while (*list) {
const struct pt_mapped_section *msec;
const struct pt_asid *masid;
struct pt_section_list *current;
struct pt_section *lsec;
uint64_t lbegin, lend;
current = *list;
msec = ¤t->section;
masid = pt_msec_asid(msec);
errcode = pt_asid_match(masid, asid);
if (errcode < 0)
break;
if (!errcode) {
list = &((*list)->next);
continue;
}
lbegin = pt_msec_begin(msec);
lend = pt_msec_end(msec);
if ((end <= lbegin) || (lend <= begin)) {
list = &((*list)->next);
continue;
}
/* The new section overlaps with @msec's section. */
lsec = pt_msec_section(msec);
/* Let's check for an identical overlap that may be the result
* of repeatedly copying images or repeatedly adding the same
* file.
*/
if ((begin == lbegin) && (end == lend) &&
(isid == current->isid)) {
const char *fname, *lfname;
fname = pt_section_filename(section);
lfname = pt_section_filename(lsec);
if (!fname || !lfname) {
errcode = -pte_internal;
break;
}
if (strcmp(fname, lfname) == 0) {
/* There should not have been any removals or
* additions.
*/
if (removed || next->next) {
errcode = -pte_internal;
break;
}
pt_section_list_free(next);
return 0;
}
}
/* We remove @msec and insert new sections for the remaining
* parts, if any. Those new sections are not mapped initially
* and need to be added to the end of the section list.
*/
*list = current->next;
/* Keep a list of removed sections so we can re-add them in case
* of errors.
*/
current->next = removed;
removed = current;
/* Unmap the removed section. If we need to re-add it, it will
* be moved to the end of the section list where the unmapped
* sections are.
*/
if (current->mapped) {
pt_section_unmap(lsec);
current->mapped = 0;
}
/* Add a section covering the remaining bytes at the front.
*
* We preserve the section identifier to indicate that the new
* section originated from the original section.
*/
if (lbegin < begin) {
errcode = pt_image_clone(&next, msec, lbegin, begin,
current->isid);
if (errcode < 0)
break;
}
/* Add a section covering the remaining bytes at the back.
*
* We preserve the section identifier to indicate that the new
* section originated from the original section.
*/
if (end < lend) {
errcode = pt_image_clone(&next, msec, end, lend,
current->isid);
if (errcode < 0)
break;
}
}
if (errcode < 0) {
pt_section_list_free_tail(next);
/* Re-add removed sections to the tail of the section list. */
for (; *list; list = &((*list)->next))
;
*list = removed;
return errcode;
}
pt_section_list_free_tail(removed);
*list = next;
return 0;
}