static struct ptunit_result read_offset(struct section_fixture *sfix)
{
uint8_t bytes[] = { 0xcc, 0x2, 0x4, 0x6 };
uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
int status;
sfix_write(sfix, bytes);
sfix->section = pt_mk_section(sfix->name, 0x1ull, 0x3ull);
ptu_ptr(sfix->section);
status = pt_section_map(sfix->section);
ptu_int_eq(status, 0);
status = pt_section_read(sfix->section, buffer, 2, 0x1ull);
ptu_int_eq(status, 2);
ptu_uint_eq(buffer[0], bytes[2]);
ptu_uint_eq(buffer[1], bytes[3]);
ptu_uint_eq(buffer[2], 0xcc);
status = pt_section_unmap(sfix->section);
ptu_int_eq(status, 0);
return ptu_passed();
}
static struct ptunit_result map_null(void)
{
int errcode;
errcode = pt_section_map(NULL);
ptu_int_eq(errcode, -pte_internal);
return ptu_passed();
}
static int pt_image_read_cold(struct pt_image *image, int *isid,
uint8_t *buffer, uint16_t size,
const struct pt_asid *asid, uint64_t addr)
{
struct pt_mapped_section *msec;
struct pt_section_list *section;
int errcode;
if (!image || !isid)
return -pte_internal;
errcode = pt_image_fetch_section(image, asid, addr);
if (errcode < 0) {
if (errcode != -pte_nomap)
return errcode;
}
section = image->sections;
if (!section)
return pt_image_read_callback(image, isid, buffer, size, asid,
addr);
msec = §ion->section;
errcode = pt_image_check_msec(msec, asid, addr);
if (errcode < 0) {
if (errcode != -pte_nomap)
return errcode;
return pt_image_read_callback(image, isid, buffer, size, asid,
addr);
}
*isid = section->isid;
if (section->mapped)
return pt_image_read_msec(buffer, size, msec, addr);
else {
struct pt_section *sec;
int status;
sec = pt_msec_section(msec);
errcode = pt_section_map(sec);
if (errcode < 0)
return errcode;
status = pt_image_read_msec(buffer, size, msec, addr);
errcode = pt_section_unmap(sec);
if (errcode < 0)
return errcode;
return status;
}
}
static struct ptunit_result map_unmap(struct section_fixture *sfix)
{
uint8_t bytes[] = { 0xcc, 0x2, 0x4, 0x6 };
int errcode;
sfix_write(sfix, bytes);
sfix->section = pt_mk_section(sfix->name, 0x1ull, 0x3ull);
ptu_ptr(sfix->section);
errcode = pt_section_map(sfix->section);
ptu_int_eq(errcode, 0);
errcode = pt_section_map(sfix->section);
ptu_int_eq(errcode, 0);
errcode = pt_section_unmap(sfix->section);
ptu_int_eq(errcode, 0);
errcode = pt_section_unmap(sfix->section);
ptu_int_eq(errcode, 0);
return ptu_passed();
}
static int worker(void *arg)
{
struct section_fixture *sfix;
int it, errcode;
sfix = arg;
if (!sfix)
return -pte_internal;
for (it = 0; it < num_work; ++it) {
uint8_t buffer[] = { 0xcc, 0xcc, 0xcc };
int read;
errcode = pt_section_get(sfix->section);
if (errcode < 0)
return errcode;
errcode = pt_section_map(sfix->section);
if (errcode < 0)
goto out_put;
read = pt_section_read(sfix->section, buffer, 2, 0x0ull);
if (read < 0)
goto out_unmap;
errcode = -pte_invalid;
if ((read != 2) || (buffer[0] != 0x2) || (buffer[1] != 0x4))
goto out_unmap;
errcode = pt_section_unmap(sfix->section);
if (errcode < 0)
goto out_put;
errcode = pt_section_put(sfix->section);
if (errcode < 0)
return errcode;
}
return 0;
out_unmap:
(void) pt_section_unmap(sfix->section);
out_put:
(void) pt_section_put(sfix->section);
return errcode;
}
int pt_iscache_read(struct pt_image_section_cache *iscache, uint8_t *buffer,
uint64_t size, int isid, uint64_t vaddr)
{
struct pt_section *section;
uint64_t laddr;
int errcode, status;
if (!iscache || !buffer || !size)
return -pte_invalid;
errcode = pt_iscache_lookup(iscache, §ion, &laddr, isid);
if (errcode < 0)
return errcode;
if (vaddr < laddr) {
(void) pt_section_put(section);
return -pte_nomap;
}
vaddr -= laddr;
errcode = pt_section_map(section);
if (errcode < 0) {
(void) pt_section_put(section);
return errcode;
}
/* We truncate the read if it gets too big. The user is expected to
* issue further reads for the remaining part.
*/
if (UINT16_MAX < size)
size = UINT16_MAX;
status = pt_section_read(section, buffer, (uint16_t) size, vaddr);
errcode = pt_section_unmap(section);
if (errcode < 0) {
(void) pt_section_put(section);
return errcode;
}
errcode = pt_section_put(section);
if (errcode < 0)
return errcode;
return status;
}
static struct ptunit_result map_overflow(struct section_fixture *sfix)
{
uint8_t bytes[] = { 0xcc, 0x2, 0x4, 0x6 };
int errcode;
sfix_write(sfix, bytes);
sfix->section = pt_mk_section(sfix->name, 0x1ull, 0x3ull);
ptu_ptr(sfix->section);
sfix->section->mcount = UINT16_MAX;
errcode = pt_section_map(sfix->section);
ptu_int_eq(errcode, -pte_internal);
sfix->section->mcount = 0;
return ptu_passed();
}
int pt_msec_read(const struct pt_mapped_section *msec, uint8_t *buffer,
uint16_t size, const struct pt_asid *asid, uint64_t addr)
{
struct pt_section *sec;
int errcode, status;
if (!msec)
return -pte_internal;
sec = msec->section;
errcode = pt_section_map(sec);
if (errcode < 0)
return errcode;
status = pt_msec_read_mapped(msec, buffer, size, asid, addr);
errcode = pt_section_unmap(sec);
if (errcode < 0)
return errcode;
return status;
}
static struct ptunit_result read_overflow_32bit(struct section_fixture *sfix)
{
uint8_t bytes[] = { 0xcc, 0x2, 0x4, 0x6 }, buffer[] = { 0xcc };
int status;
sfix_write(sfix, bytes);
sfix->section = pt_mk_section(sfix->name, 0x1ull, 0x3ull);
ptu_ptr(sfix->section);
status = pt_section_map(sfix->section);
ptu_int_eq(status, 0);
status = pt_section_read(sfix->section, buffer, 1,
0xff00000000ull);
ptu_int_eq(status, -pte_nomap);
ptu_uint_eq(buffer[0], 0xcc);
status = pt_section_unmap(sfix->section);
ptu_int_eq(status, 0);
return ptu_passed();
}
/* Find the section containing a given address in a given address space.
*
* On success, the found section is moved to the front of the section list.
* If caching is enabled, maps the section.
*
* Returns zero on success, a negative error code otherwise.
*/
static int pt_image_fetch_section(struct pt_image *image,
const struct pt_asid *asid, uint64_t vaddr)
{
struct pt_section_list **start, **list;
if (!image)
return -pte_internal;
start = &image->sections;
for (list = start; *list;) {
struct pt_mapped_section *msec;
struct pt_section_list *elem;
int errcode;
elem = *list;
msec = &elem->section;
errcode = pt_image_check_msec(msec, asid, vaddr);
if (errcode < 0) {
if (errcode != -pte_nomap)
return errcode;
list = &elem->next;
continue;
}
/* Move the section to the front if it isn't already. */
if (list != start) {
*list = elem->next;
elem->next = *start;
*start = elem;
}
/* Map the section if it isn't already - provided we do cache
* recently used sections.
*/
if (!elem->mapped) {
uint16_t cache, already;
already = image->mapped;
cache = image->cache;
if (cache) {
struct pt_section *section;
section = pt_msec_section(msec);
errcode = pt_section_map(section);
if (errcode < 0)
return errcode;
elem->mapped = 1;
already += 1;
image->mapped = already;
if (cache < already)
return pt_image_prune_cache(image);
}
}
return 0;
}
return -pte_nomap;
}
static int pt_image_read_cold(struct pt_image *image,
struct pt_section_list **list,
uint8_t *buffer, uint16_t size,
const struct pt_asid *asid, uint64_t addr)
{
struct pt_section_list **start;
if (!image || !list)
return -pte_internal;
start = &image->sections;
while (*list) {
struct pt_mapped_section *msec;
struct pt_section_list *elem;
struct pt_section *sec;
int mapped, errcode, status;
elem = *list;
msec = &elem->section;
sec = msec->section;
mapped = elem->mapped;
if (!mapped) {
errcode = pt_section_map(sec);
if (errcode < 0)
return errcode;
}
status = pt_msec_read_mapped(msec, buffer, size, asid, addr);
if (status < 0) {
if (!mapped) {
errcode = pt_section_unmap(sec);
if (errcode < 0)
return errcode;
}
list = &elem->next;
continue;
}
/* Move the section to the front if it isn't already. */
if (list != start) {
*list = elem->next;
elem->next = *start;
*start = elem;
}
/* Keep the section mapped if it isn't already - provided we
* do cache recently used sections.
*/
if (!mapped) {
uint16_t cache, already;
already = image->mapped;
cache = image->cache;
if (cache) {
elem->mapped = 1;
already += 1;
image->mapped = already;
if (cache < already) {
errcode = pt_image_prune_cache(image);
if (errcode < 0)
return errcode;
}
} else {
errcode = pt_section_unmap(sec);
if (errcode < 0)
return errcode;
}
}
return status;
}
return pt_image_read_callback(image, buffer, size, asid, addr);
}
