genirq/manage: Convert to lock guards

	bool inprogress;

	do {

		unsigned long flags;

		/*

		 * Wait until we're out of the critical section.  This might

		 * give the wrong answer due to the lack of memory barriers.

			cpu_relax();

		/* Ok, that indicated we're done: double-check carefully. */

		raw_spin_lock_irqsave(&desc->lock, flags);

		guard(raw_spinlock_irqsave)(&desc->lock);

		inprogress = irqd_irq_inprogress(&desc->irq_data);

		/*

			__irq_get_irqchip_state(irqd, IRQCHIP_STATE_ACTIVE,

						&inprogress);

		}

		raw_spin_unlock_irqrestore(&desc->lock, flags);

		/* Oops, that failed? */

	} while (inprogress);

}

			      bool force)

{

	struct irq_desc *desc = irq_to_desc(irq);

	unsigned long flags;

	int ret;

	if (!desc)

		return -EINVAL;

	raw_spin_lock_irqsave(&desc->lock, flags);

	ret = irq_set_affinity_locked(irq_desc_get_irq_data(desc), mask, force);

	raw_spin_unlock_irqrestore(&desc->lock, flags);

	return ret;

	guard(raw_spinlock_irqsave)(&desc->lock);

	return irq_set_affinity_locked(irq_desc_get_irq_data(desc), mask, force);

}

/**

		container_of(work, struct irq_affinity_notify, work);

	struct irq_desc *desc = irq_to_desc(notify->irq);

	cpumask_var_t cpumask;

	unsigned long flags;

	if (!desc || !alloc_cpumask_var(&cpumask, GFP_KERNEL))

		goto out;

	raw_spin_lock_irqsave(&desc->lock, flags);

	scoped_guard(raw_spinlock_irqsave, &desc->lock) {

		if (irq_move_pending(&desc->irq_data))

			irq_get_pending(cpumask, desc);

		else

			cpumask_copy(cpumask, desc->irq_common_data.affinity);

	raw_spin_unlock_irqrestore(&desc->lock, flags);

	}

	notify->notify(notify, cpumask);

{

	struct irq_desc *desc = irq_to_desc(irq);

	struct irq_affinity_notify *old_notify;

	unsigned long flags;

	/* The release function is promised process context */

	might_sleep();

		INIT_WORK(&notify->work, irq_affinity_notify);

	}

	raw_spin_lock_irqsave(&desc->lock, flags);

	scoped_guard(raw_spinlock_irqsave, &desc->lock) {

		old_notify = desc->affinity_notify;

		desc->affinity_notify = notify;

	raw_spin_unlock_irqrestore(&desc->lock, flags);

	}

	if (old_notify) {

		if (cancel_work_sync(&old_notify->work)) {

int irq_setup_affinity(struct irq_desc *desc)

{

	struct cpumask *set = irq_default_affinity;

	int ret, node = irq_desc_get_node(desc);

	int node = irq_desc_get_node(desc);

	static DEFINE_RAW_SPINLOCK(mask_lock);

	static struct cpumask mask;

	if (!__irq_can_set_affinity(desc))

		return 0;

	raw_spin_lock(&mask_lock);

	guard(raw_spinlock)(&mask_lock);

	/*

	 * Preserve the managed affinity setting and a userspace affinity

	 * setup, but make sure that one of the targets is online.

		if (cpumask_intersects(&mask, nodemask))

			cpumask_and(&mask, &mask, nodemask);

	}

	ret = irq_do_set_affinity(&desc->irq_data, &mask, false);

	raw_spin_unlock(&mask_lock);

	return ret;

	return irq_do_set_affinity(&desc->irq_data, &mask, false);

}

#else

/* Wrapper for ALPHA specific affinity selector magic */

		return;

	}

	raw_spin_lock_irq(&desc->lock);

	scoped_guard(raw_spinlock_irq, &desc->lock) {

		/*

		 * This code is triggered unconditionally. Check the affinity

		 * mask pointer. For CPU_MASK_OFFSTACK=n this is optimized out.

			cpumask_copy(mask, m);

			valid = true;

		}

	raw_spin_unlock_irq(&desc->lock);

	}

	if (valid)

		set_cpus_allowed_ptr(current, mask);

	if (WARN_ON_ONCE(!secondary))

		return;

	raw_spin_lock_irq(&desc->lock);

	guard(raw_spinlock_irq)(&desc->lock);

	__irq_wake_thread(desc, secondary);

	raw_spin_unlock_irq(&desc->lock);

}

/*

{

	struct irq_desc *desc = irq_to_desc(irq);

	struct irqaction *action;

	unsigned long flags;

	if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))

		return;

	raw_spin_lock_irqsave(&desc->lock, flags);

	guard(raw_spinlock_irqsave)(&desc->lock);

	for_each_action_of_desc(desc, action) {

		if (action->dev_id == dev_id) {

			if (action->thread)

			break;

		}

	}

	raw_spin_unlock_irqrestore(&desc->lock, flags);

}

EXPORT_SYMBOL_GPL(irq_wake_thread);

		 * There is no interrupt on the fly anymore. Deactivate it

		 * completely.

		 */

		raw_spin_lock_irqsave(&desc->lock, flags);

		scoped_guard(raw_spinlock_irqsave, &desc->lock)

			irq_domain_deactivate_irq(&desc->irq_data);

		raw_spin_unlock_irqrestore(&desc->lock, flags);

		irq_release_resources(desc);

		chip_bus_sync_unlock(desc);

const void *free_nmi(unsigned int irq, void *dev_id)

{

	struct irq_desc *desc = irq_to_desc(irq);

	unsigned long flags;

	const void *devname;

	if (!desc || WARN_ON(!irq_is_nmi(desc)))

		return NULL;

	if (WARN_ON(desc->depth == 0))

		disable_nmi_nosync(irq);

	raw_spin_lock_irqsave(&desc->lock, flags);

	guard(raw_spinlock_irqsave)(&desc->lock);

	irq_nmi_teardown(desc);

	devname = __cleanup_nmi(irq, desc);

	raw_spin_unlock_irqrestore(&desc->lock, flags);

	return devname;

	return __cleanup_nmi(irq, desc);

}

/**

{

	struct irqaction *action;

	struct irq_desc *desc;

	unsigned long flags;

	int retval;

	if (irq == IRQ_NOTCONNECTED)

	if (retval)

		goto err_irq_setup;

	raw_spin_lock_irqsave(&desc->lock, flags);

	scoped_guard(raw_spinlock_irqsave, &desc->lock) {

		/* Setup NMI state */

		desc->istate |= IRQS_NMI;

		retval = irq_nmi_setup(desc);

		if (retval) {

			__cleanup_nmi(irq, desc);

		raw_spin_unlock_irqrestore(&desc->lock, flags);

			return -EINVAL;

		}

	raw_spin_unlock_irqrestore(&desc->lock, flags);

		return 0;

	}

err_irq_setup:

	irq_chip_pm_put(&desc->irq_data);

{

	struct irq_desc *desc = irq_to_desc(irq);

	struct irqaction *action;

	unsigned long flags;

	WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);

	if (!desc)

		return NULL;

	raw_spin_lock_irqsave(&desc->lock, flags);

	scoped_guard(raw_spinlock_irqsave, &desc->lock) {

		action = desc->action;

		if (!action || action->percpu_dev_id != dev_id) {

			WARN(1, "Trying to free already-free IRQ %d\n", irq);

		goto bad;

			return NULL;

		}

		if (!cpumask_empty(desc->percpu_enabled)) {

			WARN(1, "percpu IRQ %d still enabled on CPU%d!\n",

			     irq, cpumask_first(desc->percpu_enabled));

		goto bad;

			return NULL;

		}

		/* Found it - now remove it from the list of entries: */

		desc->action = NULL;

		desc->istate &= ~IRQS_NMI;

	raw_spin_unlock_irqrestore(&desc->lock, flags);

	}

	unregister_handler_proc(irq, action);

	irq_chip_pm_put(&desc->irq_data);

	module_put(desc->owner);

	return action;

bad:

	raw_spin_unlock_irqrestore(&desc->lock, flags);

	return NULL;

}

/**

{

	struct irqaction *action;

	struct irq_desc *desc;

	unsigned long flags;

	int retval;

	if (!handler)

	if (retval)

		goto err_irq_setup;

	raw_spin_lock_irqsave(&desc->lock, flags);

	guard(raw_spinlock_irqsave)(&desc->lock);

	desc->istate |= IRQS_NMI;

	raw_spin_unlock_irqrestore(&desc->lock, flags);

	return 0;

err_irq_setup: