leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

powerpc/powernv: Add queue mechanism for early messages

Browse Source 
When issuing a BMC soft poweroff during IPL, the poweroff can be lost
so the machine would not poweroff.

This is because opal messages can be received before the opal-power
code registered its notifiers.

Fix it by buffering messages. If we receive a message and do not yet
have a handler for that type, store the message and replay when a
handler for that type is registered.

Signed-off-by: Deb McLemore <debmc@linux.vnet.ibm.com>
[mpe: Single unlock path in opal_message_notifier_register(), tweak
      comments/formatting and change log.]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/1526868278-4204-1-git-send-email-debmc@linux.vnet.ibm.com
This commit is contained in:
Deb McLemore 2018-05-20 21:04:38 -05:00 committed by Michael Ellerman
parent 29674a1c71
commit a9336ddf44
1 changed files with 84 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
arch/powerpc/platforms/powernv/opal.c
View File

@ -35,6 +35,16 @@
#include "powernv.h"
#define OPAL_MSG_QUEUE_MAX 16
struct opal_msg_node {
struct list_head list;
struct opal_msg msg;
};
static DEFINE_SPINLOCK(msg_list_lock);
static LIST_HEAD(msg_list);
/* /sys/firmware/opal */
struct kobject *opal_kobj;
@ -50,6 +60,8 @@ struct mcheck_recoverable_range {
u64 recover_addr;
};
static int msg_list_size;
static struct mcheck_recoverable_range *mc_recoverable_range;
static int mc_recoverable_range_len;
@ -237,6 +249,43 @@ static int __init opal_register_exception_handlers(void)
}
machine_early_initcall(powernv, opal_register_exception_handlers);
static void queue_replay_msg(void *msg)
{
struct opal_msg_node *msg_node;
if (msg_list_size < OPAL_MSG_QUEUE_MAX) {
msg_node = kzalloc(sizeof(*msg_node), GFP_ATOMIC);
if (msg_node) {
INIT_LIST_HEAD(&msg_node->list);
memcpy(&msg_node->msg, msg, sizeof(struct opal_msg));
list_add_tail(&msg_node->list, &msg_list);
msg_list_size++;
} else
pr_warn_once("message queue no memory\n");
if (msg_list_size >= OPAL_MSG_QUEUE_MAX)
pr_warn_once("message queue full\n");
}
}
static void dequeue_replay_msg(enum opal_msg_type msg_type)
{
struct opal_msg_node *msg_node, *tmp;
list_for_each_entry_safe(msg_node, tmp, &msg_list, list) {
if (be32_to_cpu(msg_node->msg.msg_type) != msg_type)
continue;
atomic_notifier_call_chain(&opal_msg_notifier_head[msg_type],
msg_type,
&msg_node->msg);
list_del(&msg_node->list);
kfree(msg_node);
msg_list_size--;
}
}
/*
* Opal message notifier based on message type. Allow subscribers to get
* notified for specific messgae type.
@ -244,14 +293,30 @@ machine_early_initcall(powernv, opal_register_exception_handlers);
int opal_message_notifier_register(enum opal_msg_type msg_type,
struct notifier_block *nb)
{
int ret;
unsigned long flags;
if (!nb || msg_type >= OPAL_MSG_TYPE_MAX) {
pr_warn("%s: Invalid arguments, msg_type:%d\n",
__func__, msg_type);
return -EINVAL;
}
return atomic_notifier_chain_register(
&opal_msg_notifier_head[msg_type], nb);
spin_lock_irqsave(&msg_list_lock, flags);
ret = atomic_notifier_chain_register(
&opal_msg_notifier_head[msg_type], nb);
/*
* If the registration succeeded, replay any queued messages that came
* in prior to the notifier chain registration. msg_list_lock held here
* to ensure they're delivered prior to any subsequent messages.
*/
if (ret == 0)
dequeue_replay_msg(msg_type);
spin_unlock_irqrestore(&msg_list_lock, flags);
return ret;
}
EXPORT_SYMBOL_GPL(opal_message_notifier_register);
@ -265,6 +330,23 @@ EXPORT_SYMBOL_GPL(opal_message_notifier_unregister);
static void opal_message_do_notify(uint32_t msg_type, void *msg)
{
unsigned long flags;
bool queued = false;
spin_lock_irqsave(&msg_list_lock, flags);
if (opal_msg_notifier_head[msg_type].head == NULL) {
/*
* Queue up the msg since no notifiers have registered
* yet for this msg_type.
*/
queue_replay_msg(msg);
queued = true;
}
spin_unlock_irqrestore(&msg_list_lock, flags);
if (queued)
return;
/* notify subscribers */
atomic_notifier_call_chain(&opal_msg_notifier_head[msg_type],
msg_type, msg);