[Intel-wired-lan] [PATCH] ice: Don't use GFP_KERNEL in atomic context

[Intel-wired-lan] [PATCH] ice: Don't use GFP_KERNEL in atomic context

[Christophe JAILLET]

ice_misc_intr() is an irq handler. It should not sleep.

Use GFP_ATOMIC instead of GFP_KERNEL when allocating some memory.

Fixes: 348048e724a0 ("ice: Implement iidc operations")
Signed-off-by: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
---
I've never played a lot with irq handler. My understanding is that they
should never sleep. So GFP_KERNEL must be avoided. So I guess that this
patch is correct.

However, I don't know if some special cases allow such allocation.
Any feedback/pointer to a good doc/explanation is welcome :)
---
 drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
index 30814435f779..65de01f3a504 100644
--- a/drivers/net/ethernet/intel/ice/ice_main.c
+++ b/drivers/net/ethernet/intel/ice/ice_main.c
@@ -3018,7 +3018,7 @@ static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
 		struct iidc_event *event;
 
 		ena_mask &= ~ICE_AUX_CRIT_ERR;
-		event = kzalloc(sizeof(*event), GFP_KERNEL);
+		event = kzalloc(sizeof(*event), GFP_ATOMIC);
 		if (event) {
 			set_bit(IIDC_EVENT_CRIT_ERR, event->type);
 			/* report the entire OICR value to AUX driver */
-- 
2.32.0

[PATCH] ice: Don't use GFP_KERNEL in atomic context

[Christophe JAILLET]

ice_misc_intr() is an irq handler. It should not sleep.

Use GFP_ATOMIC instead of GFP_KERNEL when allocating some memory.

Fixes: 348048e724a0 ("ice: Implement iidc operations")
Signed-off-by: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
---
I've never played a lot with irq handler. My understanding is that they
should never sleep. So GFP_KERNEL must be avoided. So I guess that this
patch is correct.

However, I don't know if some special cases allow such allocation.
Any feedback/pointer to a good doc/explanation is welcome :)
---
 drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
index 30814435f779..65de01f3a504 100644
--- a/drivers/net/ethernet/intel/ice/ice_main.c
+++ b/drivers/net/ethernet/intel/ice/ice_main.c
@@ -3018,7 +3018,7 @@ static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
 		struct iidc_event *event;
 
 		ena_mask &= ~ICE_AUX_CRIT_ERR;
-		event = kzalloc(sizeof(*event), GFP_KERNEL);
+		event = kzalloc(sizeof(*event), GFP_ATOMIC);
 		if (event) {
 			set_bit(IIDC_EVENT_CRIT_ERR, event->type);
 			/* report the entire OICR value to AUX driver */
-- 
2.32.0

[Intel-wired-lan] [PATCH] ice: Don't use GFP_KERNEL in atomic context

[Andrew Lunn]

On Sun, Jan 16, 2022 at 07:46:20PM +0100, Christophe JAILLET wrote:
> ice_misc_intr() is an irq handler. It should not sleep.
> 
> Use GFP_ATOMIC instead of GFP_KERNEL when allocating some memory.
> 
> Fixes: 348048e724a0 ("ice: Implement iidc operations")
> Signed-off-by: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
> ---
> I've never played a lot with irq handler. My understanding is that they
> should never sleep.

Hi Christophe

Threaded interrupt handlers are allowed to sleep. However, this
handler is not being used in such a way. So your are probably correct
about GFP_KERNEL vs GFP_ATOMIC. 

> ---
>  drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
> index 30814435f779..65de01f3a504 100644
> --- a/drivers/net/ethernet/intel/ice/ice_main.c
> +++ b/drivers/net/ethernet/intel/ice/ice_main.c
> @@ -3018,7 +3018,7 @@ static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
>  		struct iidc_event *event;
>  
>  		ena_mask &= ~ICE_AUX_CRIT_ERR;
> -		event = kzalloc(sizeof(*event), GFP_KERNEL);
> +		event = kzalloc(sizeof(*event), GFP_ATOMIC);
>  		if (event) {
>  			set_bit(IIDC_EVENT_CRIT_ERR, event->type);
>  			/* report the entire OICR value to AUX driver */

What happens next is interesting...


                        event->reg = oicr;
                        ice_send_event_to_aux(pf, event);

where:

void ice_send_event_to_aux(struct ice_pf *pf, struct iidc_event *event)
{
        struct iidc_auxiliary_drv *iadrv;

        if (!pf->adev)
                return;

        device_lock(&pf->adev->dev);
        iadrv = ice_get_auxiliary_drv(pf);
        if (iadrv && iadrv->event_handler)
                iadrv->event_handler(pf, event);
        device_unlock(&pf->adev->dev);
}

device_lock() takes a mutex, not something you should be doing in
atomic context.

So it looks to me, this handler really should be running in thread
context...

	Andrew

Re: [PATCH] ice: Don't use GFP_KERNEL in atomic context

[Andrew Lunn]

On Sun, Jan 16, 2022 at 07:46:20PM +0100, Christophe JAILLET wrote:
> ice_misc_intr() is an irq handler. It should not sleep.
> 
> Use GFP_ATOMIC instead of GFP_KERNEL when allocating some memory.
> 
> Fixes: 348048e724a0 ("ice: Implement iidc operations")
> Signed-off-by: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
> ---
> I've never played a lot with irq handler. My understanding is that they
> should never sleep.

Hi Christophe

Threaded interrupt handlers are allowed to sleep. However, this
handler is not being used in such a way. So your are probably correct
about GFP_KERNEL vs GFP_ATOMIC. 

> ---
>  drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
> index 30814435f779..65de01f3a504 100644
> --- a/drivers/net/ethernet/intel/ice/ice_main.c
> +++ b/drivers/net/ethernet/intel/ice/ice_main.c
> @@ -3018,7 +3018,7 @@ static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
>  		struct iidc_event *event;
>  
>  		ena_mask &= ~ICE_AUX_CRIT_ERR;
> -		event = kzalloc(sizeof(*event), GFP_KERNEL);
> +		event = kzalloc(sizeof(*event), GFP_ATOMIC);
>  		if (event) {
>  			set_bit(IIDC_EVENT_CRIT_ERR, event->type);
>  			/* report the entire OICR value to AUX driver */

What happens next is interesting...


                        event->reg = oicr;
                        ice_send_event_to_aux(pf, event);

where:

void ice_send_event_to_aux(struct ice_pf *pf, struct iidc_event *event)
{
        struct iidc_auxiliary_drv *iadrv;

        if (!pf->adev)
                return;

        device_lock(&pf->adev->dev);
        iadrv = ice_get_auxiliary_drv(pf);
        if (iadrv && iadrv->event_handler)
                iadrv->event_handler(pf, event);
        device_unlock(&pf->adev->dev);
}

device_lock() takes a mutex, not something you should be doing in
atomic context.

So it looks to me, this handler really should be running in thread
context...

	Andrew

[Intel-wired-lan] [PATCH] ice: Don't use GFP_KERNEL in atomic context

[Christophe JAILLET]

Le 16/01/2022 ? 22:42, Andrew Lunn a ?crit?:
> On Sun, Jan 16, 2022 at 07:46:20PM +0100, Christophe JAILLET wrote:
>> ice_misc_intr() is an irq handler. It should not sleep.
>>
>> Use GFP_ATOMIC instead of GFP_KERNEL when allocating some memory.
>>
>> Fixes: 348048e724a0 ("ice: Implement iidc operations")
>> Signed-off-by: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
>> ---
>> I've never played a lot with irq handler. My understanding is that they
>> should never sleep.
> 
> Hi Christophe
> 
> Threaded interrupt handlers are allowed to sleep. However, this
> handler is not being used in such a way. So your are probably correct
> about GFP_KERNEL vs GFP_ATOMIC.
> 
>> ---
>>   drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
>>   1 file changed, 1 insertion(+), 1 deletion(-)
>>
>> diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
>> index 30814435f779..65de01f3a504 100644
>> --- a/drivers/net/ethernet/intel/ice/ice_main.c
>> +++ b/drivers/net/ethernet/intel/ice/ice_main.c
>> @@ -3018,7 +3018,7 @@ static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
>>   		struct iidc_event *event;
>>   
>>   		ena_mask &= ~ICE_AUX_CRIT_ERR;
>> -		event = kzalloc(sizeof(*event), GFP_KERNEL);
>> +		event = kzalloc(sizeof(*event), GFP_ATOMIC);
>>   		if (event) {
>>   			set_bit(IIDC_EVENT_CRIT_ERR, event->type);
>>   			/* report the entire OICR value to AUX driver */
> 
> What happens next is interesting...
> 
> 
>                          event->reg = oicr;
>                          ice_send_event_to_aux(pf, event);
> 
> where:
> 
> void ice_send_event_to_aux(struct ice_pf *pf, struct iidc_event *event)
> {
>          struct iidc_auxiliary_drv *iadrv;
> 
>          if (!pf->adev)
>                  return;
> 
>          device_lock(&pf->adev->dev);
>          iadrv = ice_get_auxiliary_drv(pf);
>          if (iadrv && iadrv->event_handler)
>                  iadrv->event_handler(pf, event);
>          device_unlock(&pf->adev->dev);
> }
> 
> device_lock() takes a mutex, not something you should be doing in
> atomic context.
> 
> So it looks to me, this handler really should be running in thread
> context...
> 
> 	Andrew
> 

Ok, thanks for the explanation.

ice_misc_intr() is registered with devm_request_irq(), so it is a 
handler that can't sleep.

I guess that more consideration should be taken into account than only:
   s/devm_request_irq(handler)/devm_request_threaded_irq(NULL, handler)/

So I'll leave this one to people with the expected know-how.

If my s/GFP_KERNEL/GFP_ATOMIC/ makes enough sense as-is, that's fine for 
me, but it looks that another solution is needed to fix the 2nd issue.


CJ

Re: [PATCH] ice: Don't use GFP_KERNEL in atomic context

[Christophe JAILLET]

Le 16/01/2022 à 22:42, Andrew Lunn a écrit :
> On Sun, Jan 16, 2022 at 07:46:20PM +0100, Christophe JAILLET wrote:
>> ice_misc_intr() is an irq handler. It should not sleep.
>>
>> Use GFP_ATOMIC instead of GFP_KERNEL when allocating some memory.
>>
>> Fixes: 348048e724a0 ("ice: Implement iidc operations")
>> Signed-off-by: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
>> ---
>> I've never played a lot with irq handler. My understanding is that they
>> should never sleep.
> 
> Hi Christophe
> 
> Threaded interrupt handlers are allowed to sleep. However, this
> handler is not being used in such a way. So your are probably correct
> about GFP_KERNEL vs GFP_ATOMIC.
> 
>> ---
>>   drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
>>   1 file changed, 1 insertion(+), 1 deletion(-)
>>
>> diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
>> index 30814435f779..65de01f3a504 100644
>> --- a/drivers/net/ethernet/intel/ice/ice_main.c
>> +++ b/drivers/net/ethernet/intel/ice/ice_main.c
>> @@ -3018,7 +3018,7 @@ static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
>>   		struct iidc_event *event;
>>   
>>   		ena_mask &= ~ICE_AUX_CRIT_ERR;
>> -		event = kzalloc(sizeof(*event), GFP_KERNEL);
>> +		event = kzalloc(sizeof(*event), GFP_ATOMIC);
>>   		if (event) {
>>   			set_bit(IIDC_EVENT_CRIT_ERR, event->type);
>>   			/* report the entire OICR value to AUX driver */
> 
> What happens next is interesting...
> 
> 
>                          event->reg = oicr;
>                          ice_send_event_to_aux(pf, event);
> 
> where:
> 
> void ice_send_event_to_aux(struct ice_pf *pf, struct iidc_event *event)
> {
>          struct iidc_auxiliary_drv *iadrv;
> 
>          if (!pf->adev)
>                  return;
> 
>          device_lock(&pf->adev->dev);
>          iadrv = ice_get_auxiliary_drv(pf);
>          if (iadrv && iadrv->event_handler)
>                  iadrv->event_handler(pf, event);
>          device_unlock(&pf->adev->dev);
> }
> 
> device_lock() takes a mutex, not something you should be doing in
> atomic context.
> 
> So it looks to me, this handler really should be running in thread
> context...
> 
> 	Andrew
> 

Ok, thanks for the explanation.

ice_misc_intr() is registered with devm_request_irq(), so it is a 
handler that can't sleep.

I guess that more consideration should be taken into account than only:
   s/devm_request_irq(handler)/devm_request_threaded_irq(NULL, handler)/

So I'll leave this one to people with the expected know-how.

If my s/GFP_KERNEL/GFP_ATOMIC/ makes enough sense as-is, that's fine for 
me, but it looks that another solution is needed to fix the 2nd issue.


CJ

RE: [PATCH] ice: Don't use GFP_KERNEL in atomic context

[Kaliszczuk, Leszek]

> -----Original Message-----
> From: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
> Sent: Sunday, January 16, 2022 7:46 PM
> To: Brandeburg, Jesse <jesse.brandeburg@intel.com>; Nguyen, Anthony L
> <anthony.l.nguyen@intel.com>; David S. Miller <davem@davemloft.net>; Jakub
> Kicinski <kuba@kernel.org>; Saleem, Shiraz <shiraz.saleem@intel.com>; Ertman,
> David M <david.m.ertman@intel.com>
> Cc: linux-kernel@vger.kernel.org; kernel-janitors@vger.kernel.org; Christophe
> JAILLET <christophe.jaillet@wanadoo.fr>; intel-wired-lan@lists.osuosl.org;
> netdev@vger.kernel.org
> Subject: [PATCH] ice: Don't use GFP_KERNEL in atomic context
> 
> ice_misc_intr() is an irq handler. It should not sleep.
> 
> Use GFP_ATOMIC instead of GFP_KERNEL when allocating some memory.
> 
> Fixes: 348048e724a0 ("ice: Implement iidc operations")
> Signed-off-by: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
> ---
> I've never played a lot with irq handler. My understanding is that they should never
> sleep. So GFP_KERNEL must be avoided. So I guess that this patch is correct.
> 
> However, I don't know if some special cases allow such allocation.
> Any feedback/pointer to a good doc/explanation is welcome :)
> ---
>  drivers/net/ethernet/intel/ice/ice_main.c | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)

Tested-by: Leszek Kaliszczuk <leszek.kaliszczuk@intel.com>