| // SPDX-License-Identifier: GPL-2.0 | |
| /* Copyright (C) 2019 ARM Limited */ | |
| #include <ctype.h> | |
| #include <string.h> | |
| #include "testcases.h" | |
| bool validate_extra_context(struct extra_context *extra, char **err, | |
| void **extra_data, size_t *extra_size) | |
| { | |
| struct _aarch64_ctx *term; | |
| if (!extra || !err) | |
| return false; | |
| fprintf(stderr, "Validating EXTRA...\n"); | |
| term = GET_RESV_NEXT_HEAD(&extra->head); | |
| if (!term || term->magic || term->size) { | |
| *err = "Missing terminator after EXTRA context"; | |
| return false; | |
| } | |
| if (extra->datap & 0x0fUL) | |
| *err = "Extra DATAP misaligned"; | |
| else if (extra->size & 0x0fUL) | |
| *err = "Extra SIZE misaligned"; | |
| else if (extra->datap != (uint64_t)term + 0x10UL) | |
| *err = "Extra DATAP misplaced (not contiguous)"; | |
| if (*err) | |
| return false; | |
| *extra_data = (void *)extra->datap; | |
| *extra_size = extra->size; | |
| return true; | |
| } | |
| bool validate_sve_context(struct sve_context *sve, char **err) | |
| { | |
| /* Size will be rounded up to a multiple of 16 bytes */ | |
| size_t regs_size | |
| = ((SVE_SIG_CONTEXT_SIZE(sve_vq_from_vl(sve->vl)) + 15) / 16) * 16; | |
| if (!sve || !err) | |
| return false; | |
| /* Either a bare sve_context or a sve_context followed by regs data */ | |
| if ((sve->head.size != sizeof(struct sve_context)) && | |
| (sve->head.size != regs_size)) { | |
| *err = "bad size for SVE context"; | |
| return false; | |
| } | |
| if (!sve_vl_valid(sve->vl)) { | |
| *err = "SVE VL invalid"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool validate_za_context(struct za_context *za, char **err) | |
| { | |
| /* Size will be rounded up to a multiple of 16 bytes */ | |
| size_t regs_size | |
| = ((ZA_SIG_CONTEXT_SIZE(sve_vq_from_vl(za->vl)) + 15) / 16) * 16; | |
| if (!za || !err) | |
| return false; | |
| /* Either a bare za_context or a za_context followed by regs data */ | |
| if ((za->head.size != sizeof(struct za_context)) && | |
| (za->head.size != regs_size)) { | |
| *err = "bad size for ZA context"; | |
| return false; | |
| } | |
| if (!sve_vl_valid(za->vl)) { | |
| *err = "SME VL in ZA context invalid"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool validate_zt_context(struct zt_context *zt, char **err) | |
| { | |
| if (!zt || !err) | |
| return false; | |
| /* If the context is present there should be at least one register */ | |
| if (zt->nregs == 0) { | |
| *err = "no registers"; | |
| return false; | |
| } | |
| /* Size should agree with the number of registers */ | |
| if (zt->head.size != ZT_SIG_CONTEXT_SIZE(zt->nregs)) { | |
| *err = "register count does not match size"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| bool validate_reserved(ucontext_t *uc, size_t resv_sz, char **err) | |
| { | |
| bool terminated = false; | |
| size_t offs = 0; | |
| int flags = 0; | |
| int new_flags, i; | |
| struct extra_context *extra = NULL; | |
| struct sve_context *sve = NULL; | |
| struct za_context *za = NULL; | |
| struct zt_context *zt = NULL; | |
| struct _aarch64_ctx *head = | |
| (struct _aarch64_ctx *)uc->uc_mcontext.__reserved; | |
| void *extra_data = NULL; | |
| size_t extra_sz = 0; | |
| char magic[4]; | |
| if (!err) | |
| return false; | |
| /* Walk till the end terminator verifying __reserved contents */ | |
| while (head && !terminated && offs < resv_sz) { | |
| if ((uint64_t)head & 0x0fUL) { | |
| *err = "Misaligned HEAD"; | |
| return false; | |
| } | |
| new_flags = 0; | |
| switch (head->magic) { | |
| case 0: | |
| if (head->size) { | |
| *err = "Bad size for terminator"; | |
| } else if (extra_data) { | |
| /* End of main data, walking the extra data */ | |
| head = extra_data; | |
| resv_sz = extra_sz; | |
| offs = 0; | |
| extra_data = NULL; | |
| extra_sz = 0; | |
| continue; | |
| } else { | |
| terminated = true; | |
| } | |
| break; | |
| case FPSIMD_MAGIC: | |
| if (flags & FPSIMD_CTX) | |
| *err = "Multiple FPSIMD_MAGIC"; | |
| else if (head->size != | |
| sizeof(struct fpsimd_context)) | |
| *err = "Bad size for fpsimd_context"; | |
| new_flags |= FPSIMD_CTX; | |
| break; | |
| case ESR_MAGIC: | |
| if (head->size != sizeof(struct esr_context)) | |
| *err = "Bad size for esr_context"; | |
| break; | |
| case POE_MAGIC: | |
| if (head->size != sizeof(struct poe_context)) | |
| *err = "Bad size for poe_context"; | |
| break; | |
| case TPIDR2_MAGIC: | |
| if (head->size != sizeof(struct tpidr2_context)) | |
| *err = "Bad size for tpidr2_context"; | |
| break; | |
| case SVE_MAGIC: | |
| if (flags & SVE_CTX) | |
| *err = "Multiple SVE_MAGIC"; | |
| /* Size is validated in validate_sve_context() */ | |
| sve = (struct sve_context *)head; | |
| new_flags |= SVE_CTX; | |
| break; | |
| case ZA_MAGIC: | |
| if (flags & ZA_CTX) | |
| *err = "Multiple ZA_MAGIC"; | |
| /* Size is validated in validate_za_context() */ | |
| za = (struct za_context *)head; | |
| new_flags |= ZA_CTX; | |
| break; | |
| case ZT_MAGIC: | |
| if (flags & ZT_CTX) | |
| *err = "Multiple ZT_MAGIC"; | |
| /* Size is validated in validate_za_context() */ | |
| zt = (struct zt_context *)head; | |
| new_flags |= ZT_CTX; | |
| break; | |
| case FPMR_MAGIC: | |
| if (flags & FPMR_CTX) | |
| *err = "Multiple FPMR_MAGIC"; | |
| else if (head->size != | |
| sizeof(struct fpmr_context)) | |
| *err = "Bad size for fpmr_context"; | |
| new_flags |= FPMR_CTX; | |
| break; | |
| case GCS_MAGIC: | |
| if (flags & GCS_CTX) | |
| *err = "Multiple GCS_MAGIC"; | |
| if (head->size != sizeof(struct gcs_context)) | |
| *err = "Bad size for gcs_context"; | |
| new_flags |= GCS_CTX; | |
| break; | |
| case EXTRA_MAGIC: | |
| if (flags & EXTRA_CTX) | |
| *err = "Multiple EXTRA_MAGIC"; | |
| else if (head->size != | |
| sizeof(struct extra_context)) | |
| *err = "Bad size for extra_context"; | |
| new_flags |= EXTRA_CTX; | |
| extra = (struct extra_context *)head; | |
| break; | |
| case KSFT_BAD_MAGIC: | |
| /* | |
| * This is a BAD magic header defined | |
| * artificially by a testcase and surely | |
| * unknown to the Kernel parse_user_sigframe(). | |
| * It MUST cause a Kernel induced SEGV | |
| */ | |
| *err = "BAD MAGIC !"; | |
| break; | |
| default: | |
| /* | |
| * A still unknown Magic: potentially freshly added | |
| * to the Kernel code and still unknown to the | |
| * tests. Magic numbers are supposed to be allocated | |
| * as somewhat meaningful ASCII strings so try to | |
| * print as such as well as the raw number. | |
| */ | |
| memcpy(magic, &head->magic, sizeof(magic)); | |
| for (i = 0; i < sizeof(magic); i++) | |
| if (!isalnum(magic[i])) | |
| magic[i] = '?'; | |
| fprintf(stdout, | |
| "SKIP Unknown MAGIC: 0x%X (%c%c%c%c) - Is KSFT arm64/signal up to date ?\n", | |
| head->magic, | |
| magic[3], magic[2], magic[1], magic[0]); | |
| break; | |
| } | |
| if (*err) | |
| return false; | |
| offs += head->size; | |
| if (resv_sz < offs + sizeof(*head)) { | |
| *err = "HEAD Overrun"; | |
| return false; | |
| } | |
| if (new_flags & EXTRA_CTX) | |
| if (!validate_extra_context(extra, err, | |
| &extra_data, &extra_sz)) | |
| return false; | |
| if (new_flags & SVE_CTX) | |
| if (!validate_sve_context(sve, err)) | |
| return false; | |
| if (new_flags & ZA_CTX) | |
| if (!validate_za_context(za, err)) | |
| return false; | |
| if (new_flags & ZT_CTX) | |
| if (!validate_zt_context(zt, err)) | |
| return false; | |
| flags |= new_flags; | |
| head = GET_RESV_NEXT_HEAD(head); | |
| } | |
| if (terminated && !(flags & FPSIMD_CTX)) { | |
| *err = "Missing FPSIMD"; | |
| return false; | |
| } | |
| if (terminated && (flags & ZT_CTX) && !(flags & ZA_CTX)) { | |
| *err = "ZT context but no ZA context"; | |
| return false; | |
| } | |
| return true; | |
| } | |
| /* | |
| * This function walks through the records inside the provided reserved area | |
| * trying to find enough space to fit @need_sz bytes: if not enough space is | |
| * available and an extra_context record is present, it throws away the | |
| * extra_context record. | |
| * | |
| * It returns a pointer to a new header where it is possible to start storing | |
| * our need_sz bytes. | |
| * | |
| * @shead: points to the start of reserved area | |
| * @need_sz: needed bytes | |
| * @resv_sz: reserved area size in bytes | |
| * @offset: if not null, this will be filled with the offset of the return | |
| * head pointer from @shead | |
| * | |
| * @return: pointer to a new head where to start storing need_sz bytes, or | |
| * NULL if space could not be made available. | |
| */ | |
| struct _aarch64_ctx *get_starting_head(struct _aarch64_ctx *shead, | |
| size_t need_sz, size_t resv_sz, | |
| size_t *offset) | |
| { | |
| size_t offs = 0; | |
| struct _aarch64_ctx *head; | |
| head = get_terminator(shead, resv_sz, &offs); | |
| /* not found a terminator...no need to update offset if any */ | |
| if (!head) | |
| return head; | |
| if (resv_sz - offs < need_sz) { | |
| fprintf(stderr, "Low on space:%zd. Discarding extra_context.\n", | |
| resv_sz - offs); | |
| head = get_header(shead, EXTRA_MAGIC, resv_sz, &offs); | |
| if (!head || resv_sz - offs < need_sz) { | |
| fprintf(stderr, | |
| "Failed to reclaim space on sigframe.\n"); | |
| return NULL; | |
| } | |
| } | |
| fprintf(stderr, "Available space:%zd\n", resv_sz - offs); | |
| if (offset) | |
| *offset = offs; | |
| return head; | |
| } |