Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1206821 > unrolled thread

Re: [PATCH 6/7] ipmi: Handle queued messages more certainly on panic

Back to article view | Back to linux.kernel

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  Re: [PATCH 6/7] ipmi: Handle queued messages more certainly on panic Corey Minyard <minyard@acm.org> - 2015-08-13 15:50 +0200
    RE: [PATCH 6/7] ipmi: Handle queued messages more certainly on panic 河合英宏 / KAWAI，HIDEHIRO   <hidehiro.kawai.ez@hitachi.com> - 2015-08-18 04:10 +0200

#1206821 — Re: [PATCH 6/7] ipmi: Handle queued messages more certainly on panic

On 07/27/2015 12:55 AM, Hidehiro Kawai wrote:
> panic_event() called as a panic notifier tries to flush queued
> messages, but it can't handle them if the kernel panic happens
> while processing a message.  What happens depends on when the
> kernel panics.

Sorry this took so long, I've been traveling.

I have queued the patches before this one.  They all look good and
necessary.

I'm not so sure about this patch.  It looks like the only thing that is
a real issue is #2 below.
It's not so important to avoid dropping messages.

Can this be simplified somehow to work around the issue at panic time if
intf->curr_msg is set and smi_info->waiting_msg is not?

Thank you,

-corey

>
> Here is the summary of message sending process.
>
>     smi_send()
>      smi_add_send_msg()
> (1)   intf->curr_msg = msg
>      sender()
> (2)   smi_info->waiting_msg = msg
>
>     <asynchronously called>
>     check_start_timer_thread()
>      start_next_msg()
>       smi_info->curr_msg = smi_info->waiting_msg
> (3)   smi_info->waiting_msg = NULL
> (4)   smi_info->handlers->start_transaction()
>
>     <asynchronously called>
>     smi_event_handler()
> (5)  handle_transaction_done()
>       smi_info->curr_msg = NULL
>       deliver_recv_msg()
>        ipmi_smi_msg_received()
>         intf->curr_msg = NULL
>
> If the kernel panics before (1), the requested message will be
> lost.  But it can't be helped.
>
> If the kernel panics before (2), new message sent by
> send_panic_events() is queued to intf->xmit_msgs because
> intf->curr_msg is non-NULL.  But the new message will be never
> sent because no one sends intf->curr_msg.  As the result, the
> kernel hangs up.
>
> If the kernel panics before (3), intf->curr_msg will be sent by
> set_run_to_completion().  It's no problem.
>
> If the kernel panics before (4), intf->curr_msg will be lost.
> However, messages on intf->xmit_msgs will be handled.
>
> If the kernel panics before (5), we try to continue running the
> state machine.  It may successfully complete.
>
> If the kernel panics after (5), we will miss the response message
> handling, but it's not much problem in the panic context.
>
> This patch tries to handle messages in intf->curr_msg and
> intf->xmit_msgs only once without losing them.  To achieve this,
> this patch does that:
>   - if a message is in intf->curr_msg or intf->xmit_msgs and
>     start_transaction() for the message hasn't been done yet,
>     resend it
>   - if start_transaction() for a message has been called,
>     just continue to run the state machine
>   - if the transaction has been completed, do nothing
>
> >From the perspective of implementation, these are done by keeping
> smi_info->waiting_msg until start_transaction() is completed and
> by keeping new flag IPMI_MSG_RESEND_ON_PANIC just before starting
> the state machine.
>
> Signed-off-by: Hidehiro Kawai <hidehiro.kawai.ez@hitachi.com>
> ---
>  drivers/char/ipmi/ipmi_msghandler.c |   36 +++++++++++++++++++++++++++++++++++
>  drivers/char/ipmi/ipmi_si_intf.c    |    5 ++++-
>  include/linux/ipmi_smi.h            |    5 +++++
>  3 files changed, 45 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
> index 5a2d9fe..3dcd814 100644
> --- a/drivers/char/ipmi/ipmi_msghandler.c
> +++ b/drivers/char/ipmi/ipmi_msghandler.c
> @@ -1493,6 +1493,8 @@ static struct ipmi_smi_msg *smi_add_send_msg(ipmi_smi_t intf,
>  					     struct ipmi_smi_msg *smi_msg,
>  					     int priority)
>  {
> +	smi_msg->flags |= IPMI_MSG_RESEND_ON_PANIC;
> +
>  	if (intf->curr_msg) {
>  		if (priority > 0)
>  			list_add_tail(&smi_msg->link, &intf->hp_xmit_msgs);
> @@ -4223,6 +4225,7 @@ struct ipmi_smi_msg *ipmi_alloc_smi_msg(void)
>  		rv->done = free_smi_msg;
>  		rv->user_data = NULL;
>  		atomic_inc(&smi_msg_inuse_count);
> +		rv->flags = 0;
>  	}
>  	return rv;
>  }
> @@ -4531,7 +4534,40 @@ static int panic_event(struct notifier_block *this,
>  			spin_unlock(&intf->waiting_rcv_msgs_lock);
>  
>  		intf->run_to_completion = 1;
> +restart:
>  		intf->handlers->set_run_to_completion(intf->send_info, 1);
> +
> +		if (intf->curr_msg) {
> +			/*
> +			 * This can happen if the kernel panics before
> +			 * setting msg to smi_info->waiting_msg or while
> +			 * processing a response.  For the former case, we
> +			 * resend the message by re-queueing it.  For the
> +			 * latter case, we simply ignore it because handling
> +			 * response is not much meaningful in the panic
> +			 * context.
> +			 */
> +
> +			/*
> +			 * Since we want to send the current message first,
> +			 * re-queue it into the high-prioritized queue.
> +			 */
> +			if (intf->curr_msg->flags & IPMI_MSG_RESEND_ON_PANIC)
> +				list_add(&intf->curr_msg->link,
> +					 &intf->hp_xmit_msgs);
> +
> +			intf->curr_msg = NULL;
> +		}
> +
> +		if (!list_empty(&intf->hp_xmit_msgs) ||
> +		    !list_empty(&intf->xmit_msgs)) {
> +			/*
> +			 * This can happen if the kernel panics while
> +			 * processing a response.  Kick the queue and restart.
> +			 */
> +			smi_recv_tasklet((unsigned long)intf);
> +			goto restart;
> +		}
>  	}
>  
>  #ifdef CONFIG_IPMI_PANIC_EVENT
> diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
> index 814b7b7..c5c7806 100644
> --- a/drivers/char/ipmi/ipmi_si_intf.c
> +++ b/drivers/char/ipmi/ipmi_si_intf.c
> @@ -383,7 +383,6 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
>  		int err;
>  
>  		smi_info->curr_msg = smi_info->waiting_msg;
> -		smi_info->waiting_msg = NULL;
>  		debug_timestamp("Start2");
>  		err = atomic_notifier_call_chain(&xaction_notifier_list,
>  				0, smi_info);
> @@ -401,6 +400,7 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
>  		rv = SI_SM_CALL_WITHOUT_DELAY;
>  	}
>   out:
> +	smi_info->waiting_msg = NULL;
>  	return rv;
>  }
>  
> @@ -804,6 +804,9 @@ static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
>  {
>  	enum si_sm_result si_sm_result;
>  
> +	if (smi_info->curr_msg)
> +		smi_info->curr_msg->flags &= ~(IPMI_MSG_RESEND_ON_PANIC);
> +
>   restart:
>  	/*
>  	 * There used to be a loop here that waited a little while
> diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
> index ba57fb1..1200872 100644
> --- a/include/linux/ipmi_smi.h
> +++ b/include/linux/ipmi_smi.h
> @@ -47,6 +47,9 @@
>  /* Structure for the low-level drivers. */
>  typedef struct ipmi_smi *ipmi_smi_t;
>  
> +/* Flags for flags member of struct ipmi_smi_msg */
> +#define IPMI_MSG_RESEND_ON_PANIC	1 /* If set, resend in panic_event() */
> +
>  /*
>   * Messages to/from the lower layer.  The smi interface will take one
>   * of these to send. After the send has occurred and a response has
> @@ -75,6 +78,8 @@ struct ipmi_smi_msg {
>  	/* Will be called when the system is done with the message
>  	   (presumably to free it). */
>  	void (*done)(struct ipmi_smi_msg *msg);
> +
> +	int flags;
>  };
>  
>  struct ipmi_smi_handlers {
>
>

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1209001
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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web