1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2017 Arm Ltd.
3 #define pr_fmt(fmt) "sdei: " fmt
6 #include <linux/acpi.h>
7 #include <linux/arm_sdei.h>
8 #include <linux/arm-smccc.h>
9 #include <linux/atomic.h>
10 #include <linux/bitops.h>
11 #include <linux/compiler.h>
12 #include <linux/cpuhotplug.h>
13 #include <linux/cpu.h>
14 #include <linux/cpu_pm.h>
15 #include <linux/errno.h>
16 #include <linux/hardirq.h>
17 #include <linux/kernel.h>
18 #include <linux/kprobes.h>
19 #include <linux/kvm_host.h>
20 #include <linux/list.h>
21 #include <linux/mutex.h>
22 #include <linux/notifier.h>
24 #include <linux/of_platform.h>
25 #include <linux/percpu.h>
26 #include <linux/platform_device.h>
28 #include <linux/ptrace.h>
29 #include <linux/preempt.h>
30 #include <linux/reboot.h>
31 #include <linux/slab.h>
32 #include <linux/smp.h>
33 #include <linux/spinlock.h>
34 #include <linux/uaccess.h>
37 * The call to use to reach the firmware.
39 static asmlinkage void (*sdei_firmware_call)(unsigned long function_id,
40 unsigned long arg0, unsigned long arg1,
41 unsigned long arg2, unsigned long arg3,
42 unsigned long arg4, struct arm_smccc_res *res);
44 /* entry point from firmware to arch asm code */
45 static unsigned long sdei_entry_point;
47 static int sdei_hp_state;
50 /* These three are protected by the sdei_list_lock */
51 struct list_head list;
59 /* This pointer is handed to firmware as the event argument. */
62 struct sdei_registered_event *registered;
64 /* CPU private events */
65 struct sdei_registered_event __percpu *private_registered;
69 /* Take the mutex for any API call or modification. Take the mutex first. */
70 static DEFINE_MUTEX(sdei_events_lock);
72 /* and then hold this when modifying the list */
73 static DEFINE_SPINLOCK(sdei_list_lock);
74 static LIST_HEAD(sdei_list);
76 /* Private events are registered/enabled via IPI passing one of these */
77 struct sdei_crosscall_args {
78 struct sdei_event *event;
83 #define CROSSCALL_INIT(arg, event) \
86 arg.first_error = 0; \
87 atomic_set(&arg.errors, 0); \
90 static inline int sdei_do_local_call(smp_call_func_t fn,
91 struct sdei_event *event)
93 struct sdei_crosscall_args arg;
95 CROSSCALL_INIT(arg, event);
98 return arg.first_error;
101 static inline int sdei_do_cross_call(smp_call_func_t fn,
102 struct sdei_event *event)
104 struct sdei_crosscall_args arg;
106 CROSSCALL_INIT(arg, event);
107 on_each_cpu(fn, &arg, true);
109 return arg.first_error;
113 sdei_cross_call_return(struct sdei_crosscall_args *arg, int err)
115 if (err && (atomic_inc_return(&arg->errors) == 1))
116 arg->first_error = err;
119 static int sdei_to_linux_errno(unsigned long sdei_err)
122 case SDEI_NOT_SUPPORTED:
124 case SDEI_INVALID_PARAMETERS:
130 case SDEI_OUT_OF_RESOURCE:
137 static int invoke_sdei_fn(unsigned long function_id, unsigned long arg0,
138 unsigned long arg1, unsigned long arg2,
139 unsigned long arg3, unsigned long arg4,
143 struct arm_smccc_res res;
145 if (sdei_firmware_call) {
146 sdei_firmware_call(function_id, arg0, arg1, arg2, arg3, arg4,
148 err = sdei_to_linux_errno(res.a0);
151 * !sdei_firmware_call means we failed to probe or called
152 * sdei_mark_interface_broken(). -EIO is not an error returned
153 * by sdei_to_linux_errno() and is used to suppress messages
157 res.a0 = SDEI_NOT_SUPPORTED;
165 NOKPROBE_SYMBOL(invoke_sdei_fn);
167 static struct sdei_event *sdei_event_find(u32 event_num)
169 struct sdei_event *e, *found = NULL;
171 lockdep_assert_held(&sdei_events_lock);
173 spin_lock(&sdei_list_lock);
174 list_for_each_entry(e, &sdei_list, list) {
175 if (e->event_num == event_num) {
180 spin_unlock(&sdei_list_lock);
185 int sdei_api_event_context(u32 query, u64 *result)
187 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_CONTEXT, query, 0, 0, 0, 0,
190 NOKPROBE_SYMBOL(sdei_api_event_context);
192 static int sdei_api_event_get_info(u32 event, u32 info, u64 *result)
194 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_GET_INFO, event, info, 0,
198 static struct sdei_event *sdei_event_create(u32 event_num,
199 sdei_event_callback *cb,
204 struct sdei_event *event;
205 struct sdei_registered_event *reg;
207 lockdep_assert_held(&sdei_events_lock);
209 event = kzalloc(sizeof(*event), GFP_KERNEL);
215 INIT_LIST_HEAD(&event->list);
216 event->event_num = event_num;
218 err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_PRIORITY,
222 event->priority = result;
224 err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_TYPE,
228 event->type = result;
230 if (event->type == SDEI_EVENT_TYPE_SHARED) {
231 reg = kzalloc(sizeof(*reg), GFP_KERNEL);
237 reg->event_num = event->event_num;
238 reg->priority = event->priority;
241 reg->callback_arg = cb_arg;
242 event->registered = reg;
245 struct sdei_registered_event __percpu *regs;
247 regs = alloc_percpu(struct sdei_registered_event);
253 for_each_possible_cpu(cpu) {
254 reg = per_cpu_ptr(regs, cpu);
256 reg->event_num = event->event_num;
257 reg->priority = event->priority;
259 reg->callback_arg = cb_arg;
262 event->private_registered = regs;
265 spin_lock(&sdei_list_lock);
266 list_add(&event->list, &sdei_list);
267 spin_unlock(&sdei_list_lock);
276 static void sdei_event_destroy_llocked(struct sdei_event *event)
278 lockdep_assert_held(&sdei_events_lock);
279 lockdep_assert_held(&sdei_list_lock);
281 list_del(&event->list);
283 if (event->type == SDEI_EVENT_TYPE_SHARED)
284 kfree(event->registered);
286 free_percpu(event->private_registered);
291 static void sdei_event_destroy(struct sdei_event *event)
293 spin_lock(&sdei_list_lock);
294 sdei_event_destroy_llocked(event);
295 spin_unlock(&sdei_list_lock);
298 static int sdei_api_get_version(u64 *version)
300 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_VERSION, 0, 0, 0, 0, 0, version);
303 int sdei_mask_local_cpu(void)
307 err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PE_MASK, 0, 0, 0, 0, 0, NULL);
308 if (err && err != -EIO) {
309 pr_warn_once("failed to mask CPU[%u]: %d\n",
310 smp_processor_id(), err);
317 static void _ipi_mask_cpu(void *ignored)
319 WARN_ON_ONCE(preemptible());
320 sdei_mask_local_cpu();
323 int sdei_unmask_local_cpu(void)
327 err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PE_UNMASK, 0, 0, 0, 0, 0, NULL);
328 if (err && err != -EIO) {
329 pr_warn_once("failed to unmask CPU[%u]: %d\n",
330 smp_processor_id(), err);
337 static void _ipi_unmask_cpu(void *ignored)
339 WARN_ON_ONCE(preemptible());
340 sdei_unmask_local_cpu();
343 static void _ipi_private_reset(void *ignored)
347 WARN_ON_ONCE(preemptible());
349 err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PRIVATE_RESET, 0, 0, 0, 0, 0,
351 if (err && err != -EIO)
352 pr_warn_once("failed to reset CPU[%u]: %d\n",
353 smp_processor_id(), err);
356 static int sdei_api_shared_reset(void)
358 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_SHARED_RESET, 0, 0, 0, 0, 0,
362 static void sdei_mark_interface_broken(void)
364 pr_err("disabling SDEI firmware interface\n");
365 on_each_cpu(&_ipi_mask_cpu, NULL, true);
366 sdei_firmware_call = NULL;
369 static int sdei_platform_reset(void)
373 on_each_cpu(&_ipi_private_reset, NULL, true);
374 err = sdei_api_shared_reset();
376 pr_err("Failed to reset platform: %d\n", err);
377 sdei_mark_interface_broken();
383 static int sdei_api_event_enable(u32 event_num)
385 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_ENABLE, event_num, 0, 0, 0,
389 /* Called directly by the hotplug callbacks */
390 static void _local_event_enable(void *data)
393 struct sdei_crosscall_args *arg = data;
395 err = sdei_api_event_enable(arg->event->event_num);
397 sdei_cross_call_return(arg, err);
400 int sdei_event_enable(u32 event_num)
403 struct sdei_event *event;
405 mutex_lock(&sdei_events_lock);
406 event = sdei_event_find(event_num);
408 mutex_unlock(&sdei_events_lock);
414 if (event->type == SDEI_EVENT_TYPE_SHARED)
415 err = sdei_api_event_enable(event->event_num);
417 err = sdei_do_cross_call(_local_event_enable, event);
420 spin_lock(&sdei_list_lock);
421 event->reenable = true;
422 spin_unlock(&sdei_list_lock);
425 mutex_unlock(&sdei_events_lock);
430 static int sdei_api_event_disable(u32 event_num)
432 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_DISABLE, event_num, 0, 0,
436 static void _ipi_event_disable(void *data)
439 struct sdei_crosscall_args *arg = data;
441 err = sdei_api_event_disable(arg->event->event_num);
443 sdei_cross_call_return(arg, err);
446 int sdei_event_disable(u32 event_num)
449 struct sdei_event *event;
451 mutex_lock(&sdei_events_lock);
452 event = sdei_event_find(event_num);
454 mutex_unlock(&sdei_events_lock);
458 spin_lock(&sdei_list_lock);
459 event->reenable = false;
460 spin_unlock(&sdei_list_lock);
462 if (event->type == SDEI_EVENT_TYPE_SHARED)
463 err = sdei_api_event_disable(event->event_num);
465 err = sdei_do_cross_call(_ipi_event_disable, event);
466 mutex_unlock(&sdei_events_lock);
471 static int sdei_api_event_unregister(u32 event_num)
473 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_UNREGISTER, event_num, 0,
477 /* Called directly by the hotplug callbacks */
478 static void _local_event_unregister(void *data)
481 struct sdei_crosscall_args *arg = data;
483 err = sdei_api_event_unregister(arg->event->event_num);
485 sdei_cross_call_return(arg, err);
488 int sdei_event_unregister(u32 event_num)
491 struct sdei_event *event;
495 mutex_lock(&sdei_events_lock);
496 event = sdei_event_find(event_num);
498 pr_warn("Event %u not registered\n", event_num);
503 spin_lock(&sdei_list_lock);
504 event->reregister = false;
505 event->reenable = false;
506 spin_unlock(&sdei_list_lock);
508 if (event->type == SDEI_EVENT_TYPE_SHARED)
509 err = sdei_api_event_unregister(event->event_num);
511 err = sdei_do_cross_call(_local_event_unregister, event);
516 sdei_event_destroy(event);
518 mutex_unlock(&sdei_events_lock);
524 * unregister events, but don't destroy them as they are re-registered by
525 * sdei_reregister_shared().
527 static int sdei_unregister_shared(void)
530 struct sdei_event *event;
532 mutex_lock(&sdei_events_lock);
533 spin_lock(&sdei_list_lock);
534 list_for_each_entry(event, &sdei_list, list) {
535 if (event->type != SDEI_EVENT_TYPE_SHARED)
538 err = sdei_api_event_unregister(event->event_num);
542 spin_unlock(&sdei_list_lock);
543 mutex_unlock(&sdei_events_lock);
548 static int sdei_api_event_register(u32 event_num, unsigned long entry_point,
549 void *arg, u64 flags, u64 affinity)
551 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_REGISTER, event_num,
552 (unsigned long)entry_point, (unsigned long)arg,
553 flags, affinity, NULL);
556 /* Called directly by the hotplug callbacks */
557 static void _local_event_register(void *data)
560 struct sdei_registered_event *reg;
561 struct sdei_crosscall_args *arg = data;
563 reg = per_cpu_ptr(arg->event->private_registered, smp_processor_id());
564 err = sdei_api_event_register(arg->event->event_num, sdei_entry_point,
567 sdei_cross_call_return(arg, err);
570 int sdei_event_register(u32 event_num, sdei_event_callback *cb, void *arg)
573 struct sdei_event *event;
577 mutex_lock(&sdei_events_lock);
578 if (sdei_event_find(event_num)) {
579 pr_warn("Event %u already registered\n", event_num);
584 event = sdei_event_create(event_num, cb, arg);
586 err = PTR_ERR(event);
587 pr_warn("Failed to create event %u: %d\n", event_num, err);
592 if (event->type == SDEI_EVENT_TYPE_SHARED) {
593 err = sdei_api_event_register(event->event_num,
596 SDEI_EVENT_REGISTER_RM_ANY, 0);
598 err = sdei_do_cross_call(_local_event_register, event);
600 sdei_do_cross_call(_local_event_unregister, event);
604 sdei_event_destroy(event);
605 pr_warn("Failed to register event %u: %d\n", event_num, err);
609 spin_lock(&sdei_list_lock);
610 event->reregister = true;
611 spin_unlock(&sdei_list_lock);
615 mutex_unlock(&sdei_events_lock);
619 static int sdei_reregister_shared(void)
622 struct sdei_event *event;
624 mutex_lock(&sdei_events_lock);
625 spin_lock(&sdei_list_lock);
626 list_for_each_entry(event, &sdei_list, list) {
627 if (event->type != SDEI_EVENT_TYPE_SHARED)
630 if (event->reregister) {
631 err = sdei_api_event_register(event->event_num,
632 sdei_entry_point, event->registered,
633 SDEI_EVENT_REGISTER_RM_ANY, 0);
635 pr_err("Failed to re-register event %u\n",
637 sdei_event_destroy_llocked(event);
642 if (event->reenable) {
643 err = sdei_api_event_enable(event->event_num);
645 pr_err("Failed to re-enable event %u\n",
651 spin_unlock(&sdei_list_lock);
652 mutex_unlock(&sdei_events_lock);
657 static int sdei_cpuhp_down(unsigned int cpu)
659 struct sdei_event *event;
662 /* un-register private events */
663 spin_lock(&sdei_list_lock);
664 list_for_each_entry(event, &sdei_list, list) {
665 if (event->type == SDEI_EVENT_TYPE_SHARED)
668 err = sdei_do_local_call(_local_event_unregister, event);
670 pr_err("Failed to unregister event %u: %d\n",
671 event->event_num, err);
674 spin_unlock(&sdei_list_lock);
676 return sdei_mask_local_cpu();
679 static int sdei_cpuhp_up(unsigned int cpu)
681 struct sdei_event *event;
684 /* re-register/enable private events */
685 spin_lock(&sdei_list_lock);
686 list_for_each_entry(event, &sdei_list, list) {
687 if (event->type == SDEI_EVENT_TYPE_SHARED)
690 if (event->reregister) {
691 err = sdei_do_local_call(_local_event_register, event);
693 pr_err("Failed to re-register event %u: %d\n",
694 event->event_num, err);
698 if (event->reenable) {
699 err = sdei_do_local_call(_local_event_enable, event);
701 pr_err("Failed to re-enable event %u: %d\n",
702 event->event_num, err);
706 spin_unlock(&sdei_list_lock);
708 return sdei_unmask_local_cpu();
711 /* When entering idle, mask/unmask events for this cpu */
712 static int sdei_pm_notifier(struct notifier_block *nb, unsigned long action,
717 WARN_ON_ONCE(preemptible());
721 rv = sdei_mask_local_cpu();
724 case CPU_PM_ENTER_FAILED:
725 rv = sdei_unmask_local_cpu();
732 return notifier_from_errno(rv);
737 static struct notifier_block sdei_pm_nb = {
738 .notifier_call = sdei_pm_notifier,
741 static int sdei_device_suspend(struct device *dev)
743 on_each_cpu(_ipi_mask_cpu, NULL, true);
748 static int sdei_device_resume(struct device *dev)
750 on_each_cpu(_ipi_unmask_cpu, NULL, true);
756 * We need all events to be reregistered when we resume from hibernate.
758 * The sequence is freeze->thaw. Reboot. freeze->restore. We unregister
759 * events during freeze, then re-register and re-enable them during thaw
762 static int sdei_device_freeze(struct device *dev)
766 /* unregister private events */
767 cpuhp_remove_state(sdei_entry_point);
769 err = sdei_unregister_shared();
776 static int sdei_device_thaw(struct device *dev)
780 /* re-register shared events */
781 err = sdei_reregister_shared();
783 pr_warn("Failed to re-register shared events...\n");
784 sdei_mark_interface_broken();
788 err = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "SDEI",
789 &sdei_cpuhp_up, &sdei_cpuhp_down);
791 pr_warn("Failed to re-register CPU hotplug notifier...\n");
799 static int sdei_device_restore(struct device *dev)
803 err = sdei_platform_reset();
807 return sdei_device_thaw(dev);
810 static const struct dev_pm_ops sdei_pm_ops = {
811 .suspend = sdei_device_suspend,
812 .resume = sdei_device_resume,
813 .freeze = sdei_device_freeze,
814 .thaw = sdei_device_thaw,
815 .restore = sdei_device_restore,
819 * Mask all CPUs and unregister all events on panic, reboot or kexec.
821 static int sdei_reboot_notifier(struct notifier_block *nb, unsigned long action,
825 * We are going to reset the interface, after this there is no point
826 * doing work when we take CPUs offline.
828 cpuhp_remove_state(sdei_hp_state);
830 sdei_platform_reset();
835 static struct notifier_block sdei_reboot_nb = {
836 .notifier_call = sdei_reboot_notifier,
839 static void sdei_smccc_smc(unsigned long function_id,
840 unsigned long arg0, unsigned long arg1,
841 unsigned long arg2, unsigned long arg3,
842 unsigned long arg4, struct arm_smccc_res *res)
844 arm_smccc_smc(function_id, arg0, arg1, arg2, arg3, arg4, 0, 0, res);
846 NOKPROBE_SYMBOL(sdei_smccc_smc);
848 static void sdei_smccc_hvc(unsigned long function_id,
849 unsigned long arg0, unsigned long arg1,
850 unsigned long arg2, unsigned long arg3,
851 unsigned long arg4, struct arm_smccc_res *res)
853 arm_smccc_hvc(function_id, arg0, arg1, arg2, arg3, arg4, 0, 0, res);
855 NOKPROBE_SYMBOL(sdei_smccc_hvc);
857 int sdei_register_ghes(struct ghes *ghes, sdei_event_callback *normal_cb,
858 sdei_event_callback *critical_cb)
863 sdei_event_callback *cb;
865 if (!IS_ENABLED(CONFIG_ACPI_APEI_GHES))
868 event_num = ghes->generic->notify.vector;
869 if (event_num == 0) {
871 * Event 0 is reserved by the specification for
877 err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_PRIORITY,
882 if (result == SDEI_EVENT_PRIORITY_CRITICAL)
887 err = sdei_event_register(event_num, cb, ghes);
889 err = sdei_event_enable(event_num);
894 int sdei_unregister_ghes(struct ghes *ghes)
898 u32 event_num = ghes->generic->notify.vector;
902 if (!IS_ENABLED(CONFIG_ACPI_APEI_GHES))
906 * The event may be running on another CPU. Disable it
907 * to stop new events, then try to unregister a few times.
909 err = sdei_event_disable(event_num);
913 for (i = 0; i < 3; i++) {
914 err = sdei_event_unregister(event_num);
915 if (err != -EINPROGRESS)
924 static int sdei_get_conduit(struct platform_device *pdev)
927 struct device_node *np = pdev->dev.of_node;
929 sdei_firmware_call = NULL;
931 if (of_property_read_string(np, "method", &method)) {
932 pr_warn("missing \"method\" property\n");
933 return SMCCC_CONDUIT_NONE;
936 if (!strcmp("hvc", method)) {
937 sdei_firmware_call = &sdei_smccc_hvc;
938 return SMCCC_CONDUIT_HVC;
939 } else if (!strcmp("smc", method)) {
940 sdei_firmware_call = &sdei_smccc_smc;
941 return SMCCC_CONDUIT_SMC;
944 pr_warn("invalid \"method\" property: %s\n", method);
945 } else if (!acpi_disabled) {
946 if (acpi_psci_use_hvc()) {
947 sdei_firmware_call = &sdei_smccc_hvc;
948 return SMCCC_CONDUIT_HVC;
950 sdei_firmware_call = &sdei_smccc_smc;
951 return SMCCC_CONDUIT_SMC;
955 return SMCCC_CONDUIT_NONE;
958 static int sdei_probe(struct platform_device *pdev)
964 conduit = sdei_get_conduit(pdev);
965 if (!sdei_firmware_call)
968 err = sdei_api_get_version(&ver);
970 pr_err("Failed to get SDEI version: %d\n", err);
971 sdei_mark_interface_broken();
975 pr_info("SDEIv%d.%d (0x%x) detected in firmware.\n",
976 (int)SDEI_VERSION_MAJOR(ver), (int)SDEI_VERSION_MINOR(ver),
977 (int)SDEI_VERSION_VENDOR(ver));
979 if (SDEI_VERSION_MAJOR(ver) != 1) {
980 pr_warn("Conflicting SDEI version detected.\n");
981 sdei_mark_interface_broken();
985 err = sdei_platform_reset();
989 sdei_entry_point = sdei_arch_get_entry_point(conduit);
990 if (!sdei_entry_point) {
991 /* Not supported due to hardware or boot configuration */
992 sdei_mark_interface_broken();
996 err = cpu_pm_register_notifier(&sdei_pm_nb);
998 pr_warn("Failed to register CPU PM notifier...\n");
1002 err = register_reboot_notifier(&sdei_reboot_nb);
1004 pr_warn("Failed to register reboot notifier...\n");
1008 err = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "SDEI",
1009 &sdei_cpuhp_up, &sdei_cpuhp_down);
1011 pr_warn("Failed to register CPU hotplug notifier...\n");
1015 sdei_hp_state = err;
1020 unregister_reboot_notifier(&sdei_reboot_nb);
1023 cpu_pm_unregister_notifier(&sdei_pm_nb);
1026 sdei_mark_interface_broken();
1030 static const struct of_device_id sdei_of_match[] = {
1031 { .compatible = "arm,sdei-1.0" },
1035 static struct platform_driver sdei_driver = {
1039 .of_match_table = sdei_of_match,
1041 .probe = sdei_probe,
1044 static bool __init sdei_present_acpi(void)
1047 struct acpi_table_header *sdei_table_header;
1052 status = acpi_get_table(ACPI_SIG_SDEI, 0, &sdei_table_header);
1053 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
1054 const char *msg = acpi_format_exception(status);
1056 pr_info("Failed to get ACPI:SDEI table, %s\n", msg);
1058 if (ACPI_FAILURE(status))
1061 acpi_put_table(sdei_table_header);
1066 void __init sdei_init(void)
1068 struct platform_device *pdev;
1071 ret = platform_driver_register(&sdei_driver);
1072 if (ret || !sdei_present_acpi())
1075 pdev = platform_device_register_simple(sdei_driver.driver.name,
1078 ret = PTR_ERR(pdev);
1079 platform_driver_unregister(&sdei_driver);
1080 pr_info("Failed to register ACPI:SDEI platform device %d\n",
1085 int sdei_event_handler(struct pt_regs *regs,
1086 struct sdei_registered_event *arg)
1089 mm_segment_t orig_addr_limit;
1090 u32 event_num = arg->event_num;
1093 * Save restore 'fs'.
1094 * The architecture's entry code save/restores 'fs' when taking an
1095 * exception from the kernel. This ensures addr_limit isn't inherited
1096 * if you interrupted something that allowed the uaccess routines to
1097 * access kernel memory.
1098 * Do the same here because this doesn't come via the same entry code.
1100 orig_addr_limit = force_uaccess_begin();
1102 err = arg->callback(event_num, regs, arg->callback_arg);
1104 pr_err_ratelimited("event %u on CPU %u failed with error: %d\n",
1105 event_num, smp_processor_id(), err);
1107 force_uaccess_end(orig_addr_limit);
1111 NOKPROBE_SYMBOL(sdei_event_handler);
1113 void sdei_handler_abort(void)
1116 * If the crash happened in an SDEI event handler then we need to
1117 * finish the handler with the firmware so that we can have working
1118 * interrupts in the crash kernel.
1120 if (__this_cpu_read(sdei_active_critical_event)) {
1121 pr_warn("still in SDEI critical event context, attempting to finish handler.\n");
1122 __sdei_handler_abort();
1123 __this_cpu_write(sdei_active_critical_event, NULL);
1125 if (__this_cpu_read(sdei_active_normal_event)) {
1126 pr_warn("still in SDEI normal event context, attempting to finish handler.\n");
1127 __sdei_handler_abort();
1128 __this_cpu_write(sdei_active_normal_event, NULL);