Add submodule dependency filesHEADmaster

Change-Id: Iaf8d18082d3991dec7c0ebbea540f092188eb4ec

1 files changed, 700 insertions, 0 deletions

diff --git a/roms/skiboot/core/opal.c b/roms/skiboot/core/opal.c
new file mode 100644
index 000000000..2898a45ce
--- /dev/null
+++ b/roms/skiboot/core/opal.c
@@ -0,0 +1,700 @@
+// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
+/*
+ * Base support for OPAL calls
+ *
+ * Copyright 2013-2019 IBM Corp.
+ */
+
+#include <skiboot.h>
+#include <opal.h>
+#include <stack.h>
+#include <lock.h>
+#include <fsp.h>
+#include <cpu.h>
+#include <interrupts.h>
+#include <op-panel.h>
+#include <device.h>
+#include <console.h>
+#include <trace.h>
+#include <timebase.h>
+#include <affinity.h>
+#include <opal-msg.h>
+#include <timer.h>
+#include <elf-abi.h>
+#include <errorlog.h>
+#include <occ.h>
+
+/* Pending events to signal via opal_poll_events */
+uint64_t opal_pending_events;
+
+/* OPAL dispatch table defined in head.S */
+extern const uint64_t opal_branch_table[];
+
+/* Number of args expected for each call. */
+static const u8 opal_num_args[OPAL_LAST+1];
+
+/* OPAL anchor node */
+struct dt_node *opal_node;
+
+/* mask of dynamic vs fixed events; opal_allocate_dynamic_event will
+ * only allocate from this range */
+static const uint64_t opal_dynamic_events_mask = 0xffffffff00000000ul;
+static uint64_t opal_dynamic_events;
+
+extern uint32_t attn_trigger;
+extern uint32_t hir_trigger;
+
+
+void opal_table_init(void)
+{
+	struct opal_table_entry *s = __opal_table_start;
+	struct opal_table_entry *e = __opal_table_end;
+
+	prlog(PR_DEBUG, "OPAL table: %p .. %p, branch table: %p\n",
+	      s, e, opal_branch_table);
+	while(s < e) {
+		((uint64_t *)opal_branch_table)[s->token] = function_entry_address(s->func);
+		((u8 *)opal_num_args)[s->token] = s->nargs;
+		s++;
+	}
+}
+
+/* Called from head.S, thus no prototype */
+long opal_bad_token(uint64_t token);
+
+long opal_bad_token(uint64_t token)
+{
+	/**
+	 * @fwts-label OPALBadToken
+	 * @fwts-advice OPAL was called with a bad token. On POWER8 and
+	 * earlier, Linux kernels had a bug where they wouldn't check
+	 * if firmware supported particular OPAL calls before making them.
+	 * It is, in fact, harmless for these cases. On systems newer than
+	 * POWER8, this should never happen and indicates a kernel bug
+	 * where OPAL_CHECK_TOKEN isn't being called where it should be.
+	 */
+	prlog(PR_ERR, "OPAL: Called with bad token %lld !\n", token);
+
+	return OPAL_PARAMETER;
+}
+
+#ifdef OPAL_TRACE_ENTRY
+static void opal_trace_entry(struct stack_frame *eframe __unused)
+{
+	union trace t;
+	unsigned nargs, i;
+
+	if (eframe->gpr[0] > OPAL_LAST)
+		nargs = 0;
+	else
+		nargs = opal_num_args[eframe->gpr[0]];
+
+	t.opal.token = cpu_to_be64(eframe->gpr[0]);
+	t.opal.lr = cpu_to_be64(eframe->lr);
+	t.opal.sp = cpu_to_be64(eframe->gpr[1]);
+	for(i=0; i<nargs; i++)
+		t.opal.r3_to_11[i] = cpu_to_be64(eframe->gpr[3+i]);
+
+	trace_add(&t, TRACE_OPAL, offsetof(struct trace_opal, r3_to_11[nargs]));
+}
+#endif
+
+/*
+ * opal_quiesce_state is used as a lock. Don't use an actual lock to avoid
+ * lock busting.
+ */
+static uint32_t opal_quiesce_state;	/* 0 or QUIESCE_HOLD/QUIESCE_REJECT */
+static int32_t opal_quiesce_owner;	/* PIR */
+static int32_t opal_quiesce_target;	/* -1 or PIR */
+
+static int64_t opal_check_token(uint64_t token);
+
+/* Called from head.S, thus no prototype */
+int64_t opal_entry_check(struct stack_frame *eframe);
+
+int64_t opal_entry_check(struct stack_frame *eframe)
+{
+	struct cpu_thread *cpu = this_cpu();
+	uint64_t token = eframe->gpr[0];
+
+	if (cpu->pir != mfspr(SPR_PIR)) {
+		printf("CPU MISMATCH ! PIR=%04lx cpu @%p -> pir=%04x token=%llu\n",
+		       mfspr(SPR_PIR), cpu, cpu->pir, token);
+		abort();
+	}
+
+#ifdef OPAL_TRACE_ENTRY
+	opal_trace_entry(eframe);
+#endif
+
+	if (!opal_check_token(token))
+		return opal_bad_token(token);
+
+	if (!opal_quiesce_state && cpu->in_opal_call > 1) {
+		disable_fast_reboot("Kernel re-entered OPAL");
+		switch (token) {
+		case OPAL_CONSOLE_READ:
+		case OPAL_CONSOLE_WRITE:
+		case OPAL_CONSOLE_WRITE_BUFFER_SPACE:
+		case OPAL_CONSOLE_FLUSH:
+		case OPAL_POLL_EVENTS:
+		case OPAL_CHECK_TOKEN:
+		case OPAL_CEC_REBOOT:
+		case OPAL_CEC_REBOOT2:
+		case OPAL_SIGNAL_SYSTEM_RESET:
+			break;
+		default:
+			printf("CPU ATTEMPT TO RE-ENTER FIRMWARE! PIR=%04lx cpu @%p -> pir=%04x token=%llu\n",
+			       mfspr(SPR_PIR), cpu, cpu->pir, token);
+			if (cpu->in_opal_call > 2) {
+				printf("Emergency stack is destroyed, can't continue.\n");
+				abort();
+			}
+			return OPAL_INTERNAL_ERROR;
+		}
+	}
+
+	cpu->entered_opal_call_at = mftb();
+	return OPAL_SUCCESS;
+}
+
+int64_t opal_exit_check(int64_t retval, struct stack_frame *eframe);
+
+int64_t opal_exit_check(int64_t retval, struct stack_frame *eframe)
+{
+	struct cpu_thread *cpu = this_cpu();
+	uint64_t token = eframe->gpr[0];
+	uint64_t now = mftb();
+	uint64_t call_time = tb_to_msecs(now - cpu->entered_opal_call_at);
+
+	if (!cpu->in_opal_call) {
+		disable_fast_reboot("Un-accounted firmware entry");
+		printf("CPU UN-ACCOUNTED FIRMWARE ENTRY! PIR=%04lx cpu @%p -> pir=%04x token=%llu retval=%lld\n",
+		       mfspr(SPR_PIR), cpu, cpu->pir, token, retval);
+		cpu->in_opal_call++; /* avoid exit path underflowing */
+	} else {
+		if (cpu->in_opal_call > 2) {
+			printf("Emergency stack is destroyed, can't continue.\n");
+			abort();
+		}
+		if (!list_empty(&cpu->locks_held)) {
+			prlog(PR_ERR, "OPAL exiting with locks held, pir=%04x token=%llu retval=%lld\n",
+			      cpu->pir, token, retval);
+			drop_my_locks(true);
+		}
+	}
+
+	if (call_time > 100 && token != OPAL_RESYNC_TIMEBASE) {
+		prlog((call_time < 1000) ? PR_DEBUG : PR_WARNING,
+		      "Spent %llu msecs in OPAL call %llu!\n",
+		      call_time, token);
+	}
+
+	cpu->current_token = 0;
+
+	return retval;
+}
+
+int64_t opal_quiesce(uint32_t quiesce_type, int32_t cpu_target)
+{
+	struct cpu_thread *cpu = this_cpu();
+	struct cpu_thread *target = NULL;
+	struct cpu_thread *c;
+	uint64_t end;
+	bool stuck = false;
+
+	if (cpu_target >= 0) {
+		target = find_cpu_by_server(cpu_target);
+		if (!target)
+			return OPAL_PARAMETER;
+	} else if (cpu_target != -1) {
+		return OPAL_PARAMETER;
+	}
+
+	if (quiesce_type == QUIESCE_HOLD || quiesce_type == QUIESCE_REJECT) {
+		if (cmpxchg32(&opal_quiesce_state, 0, quiesce_type) != 0) {
+			if (opal_quiesce_owner != cpu->pir) {
+				/*
+				 * Nested is allowed for now just for
+				 * internal uses, so an error is returned
+				 * for OS callers, but no error message
+				 * printed if we are nested.
+				 */
+				printf("opal_quiesce already quiescing\n");
+			}
+			return OPAL_BUSY;
+		}
+		opal_quiesce_owner = cpu->pir;
+		opal_quiesce_target = cpu_target;
+	}
+
+	if (opal_quiesce_owner != cpu->pir) {
+		printf("opal_quiesce CPU does not own quiesce state (must call QUIESCE_HOLD or QUIESCE_REJECT)\n");
+		return OPAL_BUSY;
+	}
+
+	/* Okay now we own the quiesce state */
+
+	if (quiesce_type == QUIESCE_RESUME ||
+			quiesce_type == QUIESCE_RESUME_FAST_REBOOT) {
+		bust_locks = false;
+		sync(); /* release barrier vs opal entry */
+		if (target) {
+			target->quiesce_opal_call = 0;
+		} else {
+			for_each_cpu(c) {
+				if (quiesce_type == QUIESCE_RESUME_FAST_REBOOT)
+					c->in_opal_call = 0;
+
+				if (c == cpu) {
+					assert(!c->quiesce_opal_call);
+					continue;
+				}
+				c->quiesce_opal_call = 0;
+			}
+		}
+		sync();
+		opal_quiesce_state = 0;
+		return OPAL_SUCCESS;
+	}
+
+	if (quiesce_type == QUIESCE_LOCK_BREAK) {
+		if (opal_quiesce_target != -1) {
+			printf("opal_quiesce has not quiesced all CPUs (must target -1)\n");
+			return OPAL_BUSY;
+		}
+		bust_locks = true;
+		return OPAL_SUCCESS;
+	}
+
+	if (target) {
+		target->quiesce_opal_call = quiesce_type;
+	} else {
+		for_each_cpu(c) {
+			if (c == cpu)
+				continue;
+			c->quiesce_opal_call = quiesce_type;
+		}
+	}
+
+	sync(); /* Order stores to quiesce_opal_call vs loads of in_opal_call */
+
+	end = mftb() + msecs_to_tb(1000);
+
+	smt_lowest();
+	if (target) {
+		while (target->in_opal_call) {
+			if (tb_compare(mftb(), end) == TB_AAFTERB) {
+				printf("OPAL quiesce CPU:%04x stuck in OPAL\n", target->pir);
+				stuck = true;
+				break;
+			}
+			barrier();
+		}
+	} else {
+		for_each_cpu(c) {
+			if (c == cpu)
+				continue;
+			while (c->in_opal_call) {
+				if (tb_compare(mftb(), end) == TB_AAFTERB) {
+					printf("OPAL quiesce CPU:%04x stuck in OPAL\n", c->pir);
+					stuck = true;
+					break;
+				}
+				barrier();
+			}
+		}
+	}
+	smt_medium();
+	sync(); /* acquire barrier vs opal entry */
+
+	if (stuck) {
+		printf("OPAL quiesce could not kick all CPUs out of OPAL\n");
+		return OPAL_PARTIAL;
+	}
+
+	return OPAL_SUCCESS;
+}
+opal_call(OPAL_QUIESCE, opal_quiesce, 2);
+
+void __opal_register(uint64_t token, void *func, unsigned int nargs)
+{
+	assert(token <= OPAL_LAST);
+
+	((uint64_t *)opal_branch_table)[token] = function_entry_address(func);
+	((u8 *)opal_num_args)[token] = nargs;
+}
+
+/*
+ * add_opal_firmware_exports_node: adds properties to the device-tree which
+ * the OS will then change into sysfs nodes.
+ * The properties must be placed under /ibm,opal/firmware/exports.
+ * The new sysfs nodes are created under /opal/exports.
+ * To be correctly exported the properties must contain:
+ * 	name
+ * 	base memory location (u64)
+ * 	size 		     (u64)
+ */
+static void add_opal_firmware_exports_node(struct dt_node *node)
+{
+	struct dt_node *exports = dt_new(node, "exports");
+	uint64_t sym_start = (uint64_t)__sym_map_start;
+	uint64_t sym_size = (uint64_t)__sym_map_end - sym_start;
+
+	/*
+	 * These property names will be used by Linux as the user-visible file
+	 * name, so make them meaningful if possible. We use _ as the separator
+	 * here to remain consistent with existing file names in /sys/opal.
+	 */
+	dt_add_property_u64s(exports, "symbol_map", sym_start, sym_size);
+	dt_add_property_u64s(exports, "hdat_map", SPIRA_HEAP_BASE,
+				SPIRA_HEAP_SIZE);
+#ifdef SKIBOOT_GCOV
+	dt_add_property_u64s(exports, "gcov", SKIBOOT_BASE,
+				HEAP_BASE - SKIBOOT_BASE);
+#endif
+}
+
+static void add_opal_firmware_node(void)
+{
+	struct dt_node *firmware = dt_new(opal_node, "firmware");
+	uint64_t sym_start = (uint64_t)__sym_map_start;
+	uint64_t sym_size = (uint64_t)__sym_map_end - sym_start;
+
+	dt_add_property_string(firmware, "compatible", "ibm,opal-firmware");
+	dt_add_property_string(firmware, "name", "firmware");
+	dt_add_property_string(firmware, "version", version);
+	/*
+	 * As previous OS versions use symbol-map located at
+	 * /ibm,opal/firmware we will keep a copy of symbol-map here
+	 * for backwards compatibility
+	 */
+	dt_add_property_u64s(firmware, "symbol-map", sym_start, sym_size);
+
+	add_opal_firmware_exports_node(firmware);
+}
+
+void add_opal_node(void)
+{
+	uint64_t base, entry, size;
+	extern uint32_t opal_entry;
+	extern uint32_t boot_entry;
+	struct dt_node *opal_event;
+
+	/* XXX TODO: Reorg this. We should create the base OPAL
+	 * node early on, and have the various sub modules populate
+	 * their own entries (console etc...)
+	 *
+	 * The logic of which console backend to use should be
+	 * extracted
+	 */
+
+	entry = (uint64_t)&opal_entry;
+	base = SKIBOOT_BASE;
+	size = (CPU_STACKS_BASE +
+		(uint64_t)(cpu_max_pir + 1) * STACK_SIZE) - SKIBOOT_BASE;
+
+	opal_node = dt_new_check(dt_root, "ibm,opal");
+	dt_add_property_cells(opal_node, "#address-cells", 0);
+	dt_add_property_cells(opal_node, "#size-cells", 0);
+
+	if (proc_gen < proc_gen_p9)
+		dt_add_property_strings(opal_node, "compatible", "ibm,opal-v2",
+					"ibm,opal-v3");
+	else
+		dt_add_property_strings(opal_node, "compatible", "ibm,opal-v3");
+
+	dt_add_property_cells(opal_node, "opal-msg-async-num", OPAL_MAX_ASYNC_COMP);
+	dt_add_property_cells(opal_node, "opal-msg-size", OPAL_MSG_SIZE);
+	dt_add_property_u64(opal_node, "opal-base-address", base);
+	dt_add_property_u64(opal_node, "opal-entry-address", entry);
+	dt_add_property_u64(opal_node, "opal-boot-address", (uint64_t)&boot_entry);
+	dt_add_property_u64(opal_node, "opal-runtime-size", size);
+
+	/* Add irqchip interrupt controller */
+	opal_event = dt_new(opal_node, "event");
+	dt_add_property_strings(opal_event, "compatible", "ibm,opal-event");
+	dt_add_property_cells(opal_event, "#interrupt-cells", 0x1);
+	dt_add_property(opal_event, "interrupt-controller", NULL, 0);
+
+	add_opal_firmware_node();
+	add_associativity_ref_point();
+	memcons_add_properties();
+}
+
+static struct lock evt_lock = LOCK_UNLOCKED;
+
+void opal_update_pending_evt(uint64_t evt_mask, uint64_t evt_values)
+{
+	uint64_t new_evts;
+
+	lock(&evt_lock);
+	new_evts = (opal_pending_events & ~evt_mask) | evt_values;
+	if (opal_pending_events != new_evts) {
+		uint64_t tok;
+
+#ifdef OPAL_TRACE_EVT_CHG
+		printf("OPAL: Evt change: 0x%016llx -> 0x%016llx\n",
+		       opal_pending_events, new_evts);
+#endif
+		/*
+		 * If an event gets *set* while we are in a different call chain
+		 * than opal_handle_interrupt() or opal_handle_hmi(), then we
+		 * artificially generate an interrupt (OCC interrupt specifically)
+		 * to ensure that Linux properly broadcast the event change internally
+		 */
+		if ((new_evts & ~opal_pending_events) != 0) {
+			tok = this_cpu()->current_token;
+			if (tok != OPAL_HANDLE_INTERRUPT && tok != OPAL_HANDLE_HMI)
+				occ_send_dummy_interrupt();
+		}
+		opal_pending_events = new_evts;
+	}
+	unlock(&evt_lock);
+}
+
+uint64_t opal_dynamic_event_alloc(void)
+{
+	uint64_t new_event;
+	int n;
+
+	lock(&evt_lock);
+
+	/* Create the event mask. This set-bit will be within the event mask
+	 * iff there are free events, or out of the mask if there are no free
+	 * events. If opal_dynamic_events is all ones (ie, all events are
+	 * dynamic, and allocated), then ilog2 will return -1, and we'll have a
+	 * zero mask.
+	 */
+	n = ilog2(~opal_dynamic_events);
+	new_event = 1ull << n;
+
+	/* Ensure we're still within the allocatable dynamic events range */
+	if (new_event & opal_dynamic_events_mask)
+		opal_dynamic_events |= new_event;
+	else
+		new_event = 0;
+
+	unlock(&evt_lock);
+	return new_event;
+}
+
+void opal_dynamic_event_free(uint64_t event)
+{
+	lock(&evt_lock);
+	opal_dynamic_events &= ~event;
+	unlock(&evt_lock);
+}
+
+static uint64_t opal_test_func(uint64_t arg)
+{
+	printf("OPAL: Test function called with arg 0x%llx\n", arg);
+
+	return 0xfeedf00d;
+}
+opal_call(OPAL_TEST, opal_test_func, 1);
+
+struct opal_poll_entry {
+	struct list_node	link;
+	void			(*poller)(void *data);
+	void			*data;
+};
+
+static struct list_head opal_pollers = LIST_HEAD_INIT(opal_pollers);
+static struct lock opal_poll_lock = LOCK_UNLOCKED;
+
+void opal_add_poller(void (*poller)(void *data), void *data)
+{
+	struct opal_poll_entry *ent;
+
+	ent = zalloc(sizeof(struct opal_poll_entry));
+	assert(ent);
+	ent->poller = poller;
+	ent->data = data;
+	lock(&opal_poll_lock);
+	list_add_tail(&opal_pollers, &ent->link);
+	unlock(&opal_poll_lock);
+}
+
+void opal_del_poller(void (*poller)(void *data))
+{
+	struct opal_poll_entry *ent;
+
+	/* XXX This is currently unused. To solve various "interesting"
+	 * locking issues, the pollers are run locklessly, so if we were
+	 * to free them, we would have to be careful, using something
+	 * akin to RCU to synchronize with other OPAL entries. For now
+	 * if anybody uses it, print a warning and leak the entry, don't
+	 * free it.
+	 */
+	/**
+	 * @fwts-label UnsupportedOPALdelpoller
+	 * @fwts-advice Currently removing a poller is DANGEROUS and
+	 * MUST NOT be done in production firmware.
+	 */
+	prlog(PR_ALERT, "WARNING: Unsupported opal_del_poller."
+	      " Interesting locking issues, don't call this.\n");
+
+	lock(&opal_poll_lock);
+	list_for_each(&opal_pollers, ent, link) {
+		if (ent->poller == poller) {
+			list_del(&ent->link);
+			/* free(ent); */
+			break;
+		}
+	}
+	unlock(&opal_poll_lock);
+}
+
+void opal_run_pollers(void)
+{
+	static int pollers_with_lock_warnings = 0;
+	static int poller_recursion = 0;
+	struct opal_poll_entry *poll_ent;
+	bool was_in_poller;
+
+	/* Don't re-enter on this CPU, unless it was an OPAL re-entry */
+	if (this_cpu()->in_opal_call == 1 && this_cpu()->in_poller) {
+
+		/**
+		 * @fwts-label OPALPollerRecursion
+		 * @fwts-advice Recursion detected in opal_run_pollers(). This
+		 * indicates a bug in OPAL where a poller ended up running
+		 * pollers, which doesn't lead anywhere good.
+		 */
+		poller_recursion++;
+		if (poller_recursion <= 16) {
+			disable_fast_reboot("Poller recursion detected.");
+			prlog(PR_ERR, "OPAL: Poller recursion detected.\n");
+			backtrace();
+
+		}
+
+		if (poller_recursion == 16)
+			prlog(PR_ERR, "OPAL: Squashing future poller recursion warnings (>16).\n");
+
+		return;
+	}
+	was_in_poller = this_cpu()->in_poller;
+	this_cpu()->in_poller = true;
+
+	if (!list_empty(&this_cpu()->locks_held) && pollers_with_lock_warnings < 64) {
+		/**
+		 * @fwts-label OPALPollerWithLock
+		 * @fwts-advice opal_run_pollers() was called with a lock
+		 * held, which could lead to deadlock if not excessively
+		 * lucky/careful.
+		 */
+		prlog(PR_ERR, "Running pollers with lock held !\n");
+		dump_locks_list();
+		backtrace();
+		pollers_with_lock_warnings++;
+		if (pollers_with_lock_warnings == 64) {
+			/**
+			 * @fwts-label OPALPollerWithLock64
+			 * @fwts-advice Your firmware is buggy, see the 64
+			 * messages complaining about opal_run_pollers with
+			 * lock held.
+			 */
+			prlog(PR_ERR, "opal_run_pollers with lock run 64 "
+			      "times, disabling warning.\n");
+		}
+	}
+
+	/* We run the timers first */
+	check_timers(false);
+
+	/* The pollers are run lokelessly, see comment in opal_del_poller */
+	list_for_each(&opal_pollers, poll_ent, link)
+		poll_ent->poller(poll_ent->data);
+
+	/* Disable poller flag */
+	this_cpu()->in_poller = was_in_poller;
+
+	/* On debug builds, print max stack usage */
+	check_stacks();
+}
+
+static int64_t opal_poll_events(__be64 *outstanding_event_mask)
+{
+
+	if (!opal_addr_valid(outstanding_event_mask))
+		return OPAL_PARAMETER;
+
+	/* Check if we need to trigger an attn for test use */
+	if (attn_trigger == 0xdeadbeef) {
+		prlog(PR_EMERG, "Triggering attn\n");
+		assert(false);
+	}
+
+	opal_run_pollers();
+
+	if (outstanding_event_mask)
+		*outstanding_event_mask = cpu_to_be64(opal_pending_events);
+
+	return OPAL_SUCCESS;
+}
+opal_call(OPAL_POLL_EVENTS, opal_poll_events, 1);
+
+static int64_t opal_check_token(uint64_t token)
+{
+	if (token > OPAL_LAST)
+		return OPAL_TOKEN_ABSENT;
+
+	if (opal_branch_table[token])
+		return OPAL_TOKEN_PRESENT;
+
+	return OPAL_TOKEN_ABSENT;
+}
+opal_call(OPAL_CHECK_TOKEN, opal_check_token, 1);
+
+struct opal_sync_entry {
+	struct list_node	link;
+	bool			(*notify)(void *data);
+	void			*data;
+};
+
+static struct list_head opal_syncers = LIST_HEAD_INIT(opal_syncers);
+
+void opal_add_host_sync_notifier(bool (*notify)(void *data), void *data)
+{
+	struct opal_sync_entry *ent;
+
+	ent = zalloc(sizeof(struct opal_sync_entry));
+	assert(ent);
+	ent->notify = notify;
+	ent->data = data;
+	list_add_tail(&opal_syncers, &ent->link);
+}
+
+/*
+ * Remove a host sync notifier for given callback and data
+ */
+void opal_del_host_sync_notifier(bool (*notify)(void *data), void *data)
+{
+	struct opal_sync_entry *ent;
+
+	list_for_each(&opal_syncers, ent, link) {
+		if (ent->notify == notify && ent->data == data) {
+			list_del(&ent->link);
+			free(ent);
+			return;
+		}
+	}
+}
+
+/*
+ * OPAL call to handle host kexec'ing scenario
+ */
+static int64_t opal_sync_host_reboot(void)
+{
+	struct opal_sync_entry *ent, *nxt;
+	int ret = OPAL_SUCCESS;
+
+	list_for_each_safe(&opal_syncers, ent, nxt, link)
+		if (! ent->notify(ent->data))
+			ret = OPAL_BUSY_EVENT;
+
+	return ret;
+}
+opal_call(OPAL_SYNC_HOST_REBOOT, opal_sync_host_reboot, 0);