Lines Matching defs:user
85 * Save the user access state into ua_state and reset it to disable any
104 * Set the user access state for invoking the signal handler.
115 * Restore the user access state to the values saved in ua_state.
125 static void init_user_layout(struct rt_sigframe_user_layout *user)
128 sizeof(user->sigframe->uc.uc_mcontext.__reserved);
130 memset(user, 0, sizeof(*user));
131 user->size = offsetof(struct rt_sigframe, uc.uc_mcontext.__reserved);
133 user->limit = user->size + reserved_size;
135 user->limit -= TERMINATOR_SIZE;
136 user->limit -= EXTRA_CONTEXT_SIZE;
140 static size_t sigframe_size(struct rt_sigframe_user_layout const *user)
142 return round_up(max(user->size, sizeof(struct rt_sigframe)), 16);
153 static int __sigframe_alloc(struct rt_sigframe_user_layout *user,
158 if (padded_size > user->limit - user->size &&
159 !user->extra_offset &&
163 user->limit += EXTRA_CONTEXT_SIZE;
164 ret = __sigframe_alloc(user, &user->extra_offset,
167 user->limit -= EXTRA_CONTEXT_SIZE;
172 user->size += TERMINATOR_SIZE;
178 user->limit = SIGFRAME_MAXSZ - TERMINATOR_SIZE;
182 if (padded_size > user->limit - user->size)
185 *offset = user->size;
186 user->size += padded_size;
192 * Allocate space for an optional record of <size> bytes in the user
196 static int sigframe_alloc(struct rt_sigframe_user_layout *user,
199 return __sigframe_alloc(user, offset, size, true);
203 static int sigframe_alloc_end(struct rt_sigframe_user_layout *user)
208 user->limit += TERMINATOR_SIZE;
210 ret = sigframe_alloc(user, &user->end_offset,
216 user->limit = user->size;
221 struct rt_sigframe_user_layout const *user, unsigned long offset)
223 char __user *base = (char __user *)user->sigframe;
268 struct user_ctxs *user)
273 if (user->fpsimd_size != sizeof(struct fpsimd_context))
277 err = __copy_from_user(fpsimd->vregs, &(user->fpsimd->vregs),
279 __get_user_error(fpsimd->fpsr, &(user->fpsimd->fpsr), err);
280 __get_user_error(fpsimd->fpcr, &(user->fpsimd->fpcr), err);
285 static int restore_fpsimd_context(struct user_ctxs *user)
290 err = read_fpsimd_context(&fpsimd, user);
314 static int restore_fpmr_context(struct user_ctxs *user)
319 if (user->fpmr_size != sizeof(*user->fpmr))
322 __get_user_error(fpmr, &user->fpmr->fpmr, err);
341 static int restore_poe_context(struct user_ctxs *user,
347 if (user->poe_size != sizeof(*user->poe))
350 __get_user_error(por_el0, &(user->poe->por_el0), err);
394 static int restore_sve_fpsimd_context(struct user_ctxs *user)
402 if (user->sve_size < sizeof(*user->sve))
405 __get_user_error(user_vl, &(user->sve->vl), err);
406 __get_user_error(flags, &(user->sve->flags), err);
440 if (!sm && user->sve_size == sizeof(*user->sve))
441 return restore_fpsimd_context(user);
445 if (user->sve_size < SVE_SIG_CONTEXT_SIZE(vq))
455 (char __user const *)user->sve +
467 err = read_fpsimd_context(&fpsimd, user);
479 static int restore_sve_fpsimd_context(struct user_ctxs *user)
504 static int restore_tpidr2_context(struct user_ctxs *user)
509 if (user->tpidr2_size != sizeof(*user->tpidr2))
512 __get_user_error(tpidr2_el0, &user->tpidr2->tpidr2, err);
549 static int restore_za_context(struct user_ctxs *user)
555 if (user->za_size < sizeof(*user->za))
558 __get_user_error(user_vl, &(user->za->vl), err);
565 if (user->za_size == sizeof(*user->za)) {
572 if (user->za_size < ZA_SIG_CONTEXT_SIZE(vq))
583 (char __user const *)user->za +
619 static int restore_zt_context(struct user_ctxs *user)
628 if (user->zt_size != ZT_SIG_CONTEXT_SIZE(1))
631 if (__copy_from_user(&nregs, &(user->zt->nregs), sizeof(nregs)))
638 (char __user const *)user->zt +
651 extern int restore_tpidr2_context(struct user_ctxs *user);
653 extern int restore_za_context(struct user_ctxs *user);
655 extern int restore_zt_context(struct user_ctxs *user);
686 static int restore_gcs_context(struct user_ctxs *user)
691 if (user->gcs_size != sizeof(*user->gcs))
694 __get_user_error(gcspr, &user->gcs->gcspr, err);
695 __get_user_error(enabled, &user->gcs->features_enabled, err);
731 extern int restore_gcs_context(struct user_ctxs *user);
735 static int parse_user_sigframe(struct user_ctxs *user,
746 user->fpsimd = NULL;
747 user->sve = NULL;
748 user->tpidr2 = NULL;
749 user->za = NULL;
750 user->zt = NULL;
751 user->fpmr = NULL;
752 user->poe = NULL;
753 user->gcs = NULL;
793 if (user->fpsimd)
796 user->fpsimd = (struct fpsimd_context __user *)head;
797 user->fpsimd_size = size;
808 if (user->poe)
811 user->poe = (struct poe_context __user *)head;
812 user->poe_size = size;
819 if (user->sve)
822 user->sve = (struct sve_context __user *)head;
823 user->sve_size = size;
830 if (user->tpidr2)
833 user->tpidr2 = (struct tpidr2_context __user *)head;
834 user->tpidr2_size = size;
841 if (user->za)
844 user->za = (struct za_context __user *)head;
845 user->za_size = size;
852 if (user->zt)
855 user->zt = (struct zt_context __user *)head;
856 user->zt_size = size;
863 if (user->fpmr)
866 user->fpmr = (struct fpmr_context __user *)head;
867 user->fpmr_size = size;
874 if (user->gcs)
877 user->gcs = (struct gcs_context __user *)head;
878 user->gcs_size = size;
969 struct user_ctxs user;
991 err = parse_user_sigframe(&user, sf);
994 if (!user.fpsimd)
997 if (user.sve)
998 err = restore_sve_fpsimd_context(&user);
1000 err = restore_fpsimd_context(&user);
1003 if (err == 0 && system_supports_gcs() && user.gcs)
1004 err = restore_gcs_context(&user);
1006 if (err == 0 && system_supports_tpidr2() && user.tpidr2)
1007 err = restore_tpidr2_context(&user);
1009 if (err == 0 && system_supports_fpmr() && user.fpmr)
1010 err = restore_fpmr_context(&user);
1012 if (err == 0 && system_supports_sme() && user.za)
1013 err = restore_za_context(&user);
1015 if (err == 0 && system_supports_sme2() && user.zt)
1016 err = restore_zt_context(&user);
1018 if (err == 0 && system_supports_poe() && user.poe)
1019 err = restore_poe_context(&user, ua_state);
1122 static int setup_sigframe_layout(struct rt_sigframe_user_layout *user,
1128 err = sigframe_alloc(user, &user->fpsimd_offset,
1136 err = sigframe_alloc(user, &user->esr_offset,
1144 err = sigframe_alloc(user, &user->gcs_offset,
1164 err = sigframe_alloc(user, &user->sve_offset,
1171 err = sigframe_alloc(user, &user->tpidr2_offset,
1189 err = sigframe_alloc(user, &user->za_offset,
1197 err = sigframe_alloc(user, &user->zt_offset,
1205 err = sigframe_alloc(user, &user->fpmr_offset,
1212 err = sigframe_alloc(user, &user->poe_offset,
1218 return sigframe_alloc_end(user);
1221 static int setup_sigframe(struct rt_sigframe_user_layout *user,
1226 struct rt_sigframe __user *sf = user->sigframe;
1229 __put_user_error(regs->regs[29], &user->next_frame->fp, err);
1230 __put_user_error(regs->regs[30], &user->next_frame->lr, err);
1245 apply_user_offset(user, user->fpsimd_offset);
1250 if (err == 0 && user->esr_offset) {
1252 apply_user_offset(user, user->esr_offset);
1259 if (system_supports_gcs() && err == 0 && user->gcs_offset) {
1261 apply_user_offset(user, user->gcs_offset);
1267 err == 0 && user->sve_offset) {
1269 apply_user_offset(user, user->sve_offset);
1276 apply_user_offset(user, user->tpidr2_offset);
1283 apply_user_offset(user, user->fpmr_offset);
1289 apply_user_offset(user, user->poe_offset);
1295 if (system_supports_sme() && err == 0 && user->za_offset) {
1297 apply_user_offset(user, user->za_offset);
1302 if (system_supports_sme2() && err == 0 && user->zt_offset) {
1304 apply_user_offset(user, user->zt_offset);
1308 if (err == 0 && user->extra_offset) {
1309 char __user *sfp = (char __user *)user->sigframe;
1311 apply_user_offset(user, user->extra_offset);
1330 extra_size = sfp + round_up(user->size, 16) - userp;
1345 apply_user_offset(user, user->end_offset);
1354 static int get_sigframe(struct rt_sigframe_user_layout *user,
1360 init_user_layout(user);
1361 err = setup_sigframe_layout(user, false);
1368 user->next_frame = (struct frame_record __user *)sp;
1370 sp = round_down(sp, 16) - sigframe_size(user);
1371 user->sigframe = (struct rt_sigframe __user *)sp;
1376 if (!access_ok(user->sigframe, sp_top - sp))
1426 struct rt_sigframe_user_layout *user, int usig)
1450 regs->regs[1] = (unsigned long)&user->sigframe->info;
1451 regs->regs[2] = (unsigned long)&user->sigframe->uc;
1453 regs->sp = (unsigned long)user->sigframe;
1454 regs->regs[29] = (unsigned long)&user->next_frame->fp;
1490 struct rt_sigframe_user_layout user;
1497 if (get_sigframe(&user, ksig, regs))
1501 frame = user.sigframe;
1507 err |= setup_sigframe(&user, regs, set, &ua_state);
1512 err = setup_return(regs, ksig, &user, usig);
1573 * the kernel can handle, and then we build all the user-level signal handling
1656 struct rt_sigframe_user_layout user;
1658 init_user_layout(&user);
1664 if (WARN_ON(setup_sigframe_layout(&user, true)))
1667 signal_minsigstksz = sigframe_size(&user) +