Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f13140b2 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Merge 4.19.288 into android-4.19-stable 



Changes in 4.19.288
	serial: lantiq: Change ltq_w32_mask to asc_update_bits
	serial: lantiq: Use readl/writel instead of ltq_r32/ltq_w32
	serial: lantiq: Do not swap register read/writes
	serial: lantiq: add missing interrupt ack
	nilfs2: reject devices with insufficient block count
	x86/purgatory: remove PGO flags
	ipmi: Make the smi watcher be disabled immediately when not needed
	ipmi: move message error checking to avoid deadlock
	nilfs2: fix buffer corruption due to concurrent device reads
	Drivers: hv: vmbus: Fix vmbus_wait_for_unload() to scan present CPUs
	PCI: hv: Fix a race condition bug in hv_pci_query_relations()
	cgroup: Do not corrupt task iteration when rebinding subsystem
	nilfs2: prevent general protection fault in nilfs_clear_dirty_page()
	rcu: Upgrade rcu_swap_protected() to rcu_replace_pointer()
	ieee802154: hwsim: Fix possible memory leaks
	xfrm: Linearize the skb after offloading if needed.
	net: qca_spi: Avoid high load if QCA7000 is not available
	mmc: mtk-sd: fix deferred probing
	mmc: mvsdio: convert to devm_platform_ioremap_resource
	mmc: mvsdio: fix deferred probing
	mmc: omap: fix deferred probing
	mmc: omap_hsmmc: fix deferred probing
	mmc: sdhci-acpi: fix deferred probing
	mmc: usdhi60rol0: fix deferred probing
	be2net: Extend xmit workaround to BE3 chip
	netfilter: nf_tables: disallow element updates of bound anonymous sets
	netfilter: nfnetlink_osf: fix module autoload
	sch_netem: acquire qdisc lock in netem_change()
	scsi: target: iscsi: Prevent login threads from racing between each other
	HID: wacom: Add error check to wacom_parse_and_register()
	arm64: Add missing Set/Way CMO encodings
	media: cec: core: don't set last_initiator if tx in progress
	nfcsim.c: Fix error checking for debugfs_create_dir
	usb: gadget: udc: fix NULL dereference in remove()
	s390/cio: unregister device when the only path is gone
	ASoC: nau8824: Add quirk to active-high jack-detect
	drm/exynos: vidi: fix a wrong error return
	drm/exynos: fix race condition UAF in exynos_g2d_exec_ioctl
	drm/radeon: fix race condition UAF in radeon_gem_set_domain_ioctl
	x86/apic: Fix kernel panic when booting with intremap=off and x2apic_phys
	i2c: imx-lpi2c: fix type char overflow issue when calculating the clock cycle
	Linux 4.19.288

Change-Id: I0ec8e3df85fb79855d508ea71b305c91eba49210
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parents 0e19062e 94bffc10

Makefile

+1 −1
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

VERSION = 4

PATCHLEVEL = 19

SUBLEVEL = 287

SUBLEVEL = 288

EXTRAVERSION =

NAME = "People's Front"

arch/arm64/include/asm/sysreg.h

+6 −0
Original line number Diff line number Diff line
@@ -108,8 +108,14 @@ 
#define SET_PSTATE_SSBS(x)		__emit_inst(0xd500401f | PSTATE_SSBS | ((!!x) << PSTATE_Imm_shift))



#define SYS_DC_ISW			sys_insn(1, 0, 7, 6, 2)

#define SYS_DC_IGSW			sys_insn(1, 0, 7, 6, 4)

#define SYS_DC_IGDSW			sys_insn(1, 0, 7, 6, 6)

#define SYS_DC_CSW			sys_insn(1, 0, 7, 10, 2)

#define SYS_DC_CGSW			sys_insn(1, 0, 7, 10, 4)

#define SYS_DC_CGDSW			sys_insn(1, 0, 7, 10, 6)

#define SYS_DC_CISW			sys_insn(1, 0, 7, 14, 2)

#define SYS_DC_CIGSW			sys_insn(1, 0, 7, 14, 4)

#define SYS_DC_CIGDSW			sys_insn(1, 0, 7, 14, 6)



#define SYS_OSDTRRX_EL1			sys_reg(2, 0, 0, 0, 2)

#define SYS_MDCCINT_EL1			sys_reg(2, 0, 0, 2, 0)

arch/x86/kernel/apic/x2apic_phys.c

+4 −1
Original line number Diff line number Diff line
@@ -102,7 +102,10 @@ static void init_x2apic_ldr(void) 


static int x2apic_phys_probe(void)

{

	if (x2apic_mode && (x2apic_phys || x2apic_fadt_phys()))

	if (!x2apic_mode)

		return 0;



	if (x2apic_phys || x2apic_fadt_phys())

		return 1;



	return apic == &apic_x2apic_phys;

arch/x86/purgatory/Makefile

+5 −0
Original line number Diff line number Diff line
@@ -12,6 +12,11 @@ $(obj)/string.o: $(srctree)/arch/x86/boot/compressed/string.c FORCE 
$(obj)/sha256.o: $(srctree)/lib/sha256.c FORCE

	$(call if_changed_rule,cc_o_c)



# When profile-guided optimization is enabled, llvm emits two different

# overlapping text sections, which is not supported by kexec. Remove profile

# optimization flags.

KBUILD_CFLAGS := $(filter-out -fprofile-sample-use=% -fprofile-use=%,$(KBUILD_CFLAGS))



LDFLAGS_purgatory.ro := -e purgatory_start -r --no-undefined -nostdlib -z nodefaultlib

targets += purgatory.ro

drivers/char/ipmi/ipmi_msghandler.c

+147 −131
Original line number Diff line number Diff line
@@ -541,15 +541,20 @@ struct ipmi_smi { 
	atomic_t         event_waiters;

	unsigned int     ticks_to_req_ev;



	spinlock_t       watch_lock; /* For dealing with watch stuff below. */



	/* How many users are waiting for commands? */

	atomic_t         command_waiters;

	unsigned int     command_waiters;



	/* How many users are waiting for watchdogs? */

	atomic_t         watchdog_waiters;

	unsigned int     watchdog_waiters;



	/* How many users are waiting for message responses? */

	unsigned int     response_waiters;



	/*

	 * Tells what the lower layer has last been asked to watch for,

	 * messages and/or watchdogs.  Protected by xmit_msgs_lock.

	 * messages and/or watchdogs.  Protected by watch_lock.

	 */

	unsigned int     last_watch_mask;
@@ -945,6 +950,64 @@ static void deliver_err_response(struct ipmi_smi *intf, 
	deliver_local_response(intf, msg);

}



static void smi_add_watch(struct ipmi_smi *intf, unsigned int flags)

{

	unsigned long iflags;



	if (!intf->handlers->set_need_watch)

		return;



	spin_lock_irqsave(&intf->watch_lock, iflags);

	if (flags & IPMI_WATCH_MASK_CHECK_MESSAGES)

		intf->response_waiters++;



	if (flags & IPMI_WATCH_MASK_CHECK_WATCHDOG)

		intf->watchdog_waiters++;



	if (flags & IPMI_WATCH_MASK_CHECK_COMMANDS)

		intf->command_waiters++;



	if ((intf->last_watch_mask & flags) != flags) {

		intf->last_watch_mask |= flags;

		intf->handlers->set_need_watch(intf->send_info,

					       intf->last_watch_mask);

	}

	spin_unlock_irqrestore(&intf->watch_lock, iflags);

}



static void smi_remove_watch(struct ipmi_smi *intf, unsigned int flags)

{

	unsigned long iflags;



	if (!intf->handlers->set_need_watch)

		return;



	spin_lock_irqsave(&intf->watch_lock, iflags);

	if (flags & IPMI_WATCH_MASK_CHECK_MESSAGES)

		intf->response_waiters--;



	if (flags & IPMI_WATCH_MASK_CHECK_WATCHDOG)

		intf->watchdog_waiters--;



	if (flags & IPMI_WATCH_MASK_CHECK_COMMANDS)

		intf->command_waiters--;



	flags = 0;

	if (intf->response_waiters)

		flags |= IPMI_WATCH_MASK_CHECK_MESSAGES;

	if (intf->watchdog_waiters)

		flags |= IPMI_WATCH_MASK_CHECK_WATCHDOG;

	if (intf->command_waiters)

		flags |= IPMI_WATCH_MASK_CHECK_COMMANDS;



	if (intf->last_watch_mask != flags) {

		intf->last_watch_mask = flags;

		intf->handlers->set_need_watch(intf->send_info,

					       intf->last_watch_mask);

	}

	spin_unlock_irqrestore(&intf->watch_lock, iflags);

}



/*

 * Find the next sequence number not being used and add the given

 * message with the given timeout to the sequence table.  This must be
@@ -988,6 +1051,7 @@ static int intf_next_seq(struct ipmi_smi *intf, 
		*seq = i;

		*seqid = intf->seq_table[i].seqid;

		intf->curr_seq = (i+1)%IPMI_IPMB_NUM_SEQ;

		smi_add_watch(intf, IPMI_WATCH_MASK_CHECK_MESSAGES);

		need_waiter(intf);

	} else {

		rv = -EAGAIN;
@@ -1026,6 +1090,7 @@ static int intf_find_seq(struct ipmi_smi *intf, 
				&& (ipmi_addr_equal(addr, &msg->addr))) {

			*recv_msg = msg;

			intf->seq_table[seq].inuse = 0;

			smi_remove_watch(intf, IPMI_WATCH_MASK_CHECK_MESSAGES);

			rv = 0;

		}

	}
@@ -1087,6 +1152,7 @@ static int intf_err_seq(struct ipmi_smi *intf, 
		struct seq_table *ent = &intf->seq_table[seq];



		ent->inuse = 0;

		smi_remove_watch(intf, IPMI_WATCH_MASK_CHECK_MESSAGES);

		msg = ent->recv_msg;

		rv = 0;

	}
@@ -1098,30 +1164,6 @@ static int intf_err_seq(struct ipmi_smi *intf, 
	return rv;

}



/* Must be called with xmit_msgs_lock held. */

static void smi_tell_to_watch(struct ipmi_smi *intf,

			      unsigned int flags,

			      struct ipmi_smi_msg *smi_msg)

{

	if (flags & IPMI_WATCH_MASK_CHECK_MESSAGES) {

		if (!smi_msg)

			return;



		if (!smi_msg->needs_response)

			return;

	}



	if (!intf->handlers->set_need_watch)

		return;



	if ((intf->last_watch_mask & flags) == flags)

		return;



	intf->last_watch_mask |= flags;

	intf->handlers->set_need_watch(intf->send_info,

				       intf->last_watch_mask);

}



static void free_user_work(struct work_struct *work)

{

	struct ipmi_user *user = container_of(work, struct ipmi_user,
@@ -1198,12 +1240,9 @@ int ipmi_create_user(unsigned int if_num, 
	spin_lock_irqsave(&intf->seq_lock, flags);

	list_add_rcu(&new_user->link, &intf->users);

	spin_unlock_irqrestore(&intf->seq_lock, flags);

	if (handler->ipmi_watchdog_pretimeout) {

	if (handler->ipmi_watchdog_pretimeout)

		/* User wants pretimeouts, so make sure to watch for them. */

		if (atomic_inc_return(&intf->watchdog_waiters) == 1)

			smi_tell_to_watch(intf, IPMI_WATCH_MASK_CHECK_WATCHDOG,

					  NULL);

	}

		smi_add_watch(intf, IPMI_WATCH_MASK_CHECK_WATCHDOG);

	srcu_read_unlock(&ipmi_interfaces_srcu, index);

	*user = new_user;

	return 0;
@@ -1276,7 +1315,7 @@ static void _ipmi_destroy_user(struct ipmi_user *user) 
		user->handler->shutdown(user->handler_data);



	if (user->handler->ipmi_watchdog_pretimeout)

		atomic_dec(&intf->watchdog_waiters);

		smi_remove_watch(intf, IPMI_WATCH_MASK_CHECK_WATCHDOG);



	if (user->gets_events)

		atomic_dec(&intf->event_waiters);
@@ -1289,6 +1328,7 @@ static void _ipmi_destroy_user(struct ipmi_user *user) 
		if (intf->seq_table[i].inuse

		    && (intf->seq_table[i].recv_msg->user == user)) {

			intf->seq_table[i].inuse = 0;

			smi_remove_watch(intf, IPMI_WATCH_MASK_CHECK_MESSAGES);

			ipmi_free_recv_msg(intf->seq_table[i].recv_msg);

		}

	}
@@ -1634,8 +1674,7 @@ int ipmi_register_for_cmd(struct ipmi_user *user, 
		goto out_unlock;

	}



	if (atomic_inc_return(&intf->command_waiters) == 1)

		smi_tell_to_watch(intf, IPMI_WATCH_MASK_CHECK_COMMANDS, NULL);

	smi_add_watch(intf, IPMI_WATCH_MASK_CHECK_COMMANDS);



	list_add_rcu(&rcvr->link, &intf->cmd_rcvrs);
@@ -1685,7 +1724,7 @@ int ipmi_unregister_for_cmd(struct ipmi_user *user, 
	synchronize_rcu();

	release_ipmi_user(user, index);

	while (rcvrs) {

		atomic_dec(&intf->command_waiters);

		smi_remove_watch(intf, IPMI_WATCH_MASK_CHECK_COMMANDS);

		rcvr = rcvrs;

		rcvrs = rcvr->next;

		kfree(rcvr);
@@ -1813,8 +1852,6 @@ static void smi_send(struct ipmi_smi *intf, 
		spin_lock_irqsave(&intf->xmit_msgs_lock, flags);

	smi_msg = smi_add_send_msg(intf, smi_msg, priority);



	smi_tell_to_watch(intf, IPMI_WATCH_MASK_CHECK_MESSAGES, smi_msg);



	if (!run_to_completion)

		spin_unlock_irqrestore(&intf->xmit_msgs_lock, flags);
@@ -2014,9 +2051,6 @@ static int i_ipmi_req_ipmb(struct ipmi_smi *intf, 
				ipmb_seq, broadcast,

				source_address, source_lun);



		/* We will be getting a response in the BMC message queue. */

		smi_msg->needs_response = true;



		/*

		 * Copy the message into the recv message data, so we

		 * can retransmit it later if necessary.
@@ -2204,7 +2238,6 @@ static int i_ipmi_request(struct ipmi_user *user, 
			goto out;

		}

	}

	smi_msg->needs_response = false;



	rcu_read_lock();

	if (intf->in_shutdown) {
@@ -3425,9 +3458,8 @@ int ipmi_add_smi(struct module *owner, 
	INIT_LIST_HEAD(&intf->xmit_msgs);

	INIT_LIST_HEAD(&intf->hp_xmit_msgs);

	spin_lock_init(&intf->events_lock);

	spin_lock_init(&intf->watch_lock);

	atomic_set(&intf->event_waiters, 0);

	atomic_set(&intf->watchdog_waiters, 0);

	atomic_set(&intf->command_waiters, 0);

	intf->ticks_to_req_ev = IPMI_REQUEST_EV_TIME;

	INIT_LIST_HEAD(&intf->waiting_events);

	intf->waiting_events_count = 0;
@@ -4207,7 +4239,53 @@ static int handle_one_recv_msg(struct ipmi_smi *intf, 
	int chan;



	ipmi_debug_msg("Recv:", msg->rsp, msg->rsp_size);

	if (msg->rsp_size < 2) {



	if ((msg->data_size >= 2)

	    && (msg->data[0] == (IPMI_NETFN_APP_REQUEST << 2))

	    && (msg->data[1] == IPMI_SEND_MSG_CMD)

	    && (msg->user_data == NULL)) {



		if (intf->in_shutdown)

			goto free_msg;



		/*

		 * This is the local response to a command send, start

		 * the timer for these.  The user_data will not be

		 * NULL if this is a response send, and we will let

		 * response sends just go through.

		 */



		/*

		 * Check for errors, if we get certain errors (ones

		 * that mean basically we can try again later), we

		 * ignore them and start the timer.  Otherwise we

		 * report the error immediately.

		 */

		if ((msg->rsp_size >= 3) && (msg->rsp[2] != 0)

		    && (msg->rsp[2] != IPMI_NODE_BUSY_ERR)

		    && (msg->rsp[2] != IPMI_LOST_ARBITRATION_ERR)

		    && (msg->rsp[2] != IPMI_BUS_ERR)

		    && (msg->rsp[2] != IPMI_NAK_ON_WRITE_ERR)) {

			int ch = msg->rsp[3] & 0xf;

			struct ipmi_channel *chans;



			/* Got an error sending the message, handle it. */



			chans = READ_ONCE(intf->channel_list)->c;

			if ((chans[ch].medium == IPMI_CHANNEL_MEDIUM_8023LAN)

			    || (chans[ch].medium == IPMI_CHANNEL_MEDIUM_ASYNC))

				ipmi_inc_stat(intf, sent_lan_command_errs);

			else

				ipmi_inc_stat(intf, sent_ipmb_command_errs);

			intf_err_seq(intf, msg->msgid, msg->rsp[2]);

		} else

			/* The message was sent, start the timer. */

			intf_start_seq_timer(intf, msg->msgid);

free_msg:

		requeue = 0;

		goto out;



	} else if (msg->rsp_size < 2) {

		/* Message is too small to be correct. */

		dev_warn(intf->si_dev,

			 PFX "BMC returned to small a message for netfn %x cmd %x, got %d bytes\n",
@@ -4447,8 +4525,6 @@ static void smi_recv_tasklet(unsigned long val) 
		}

	}



	smi_tell_to_watch(intf, IPMI_WATCH_MASK_CHECK_MESSAGES, newmsg);



	if (!run_to_completion)

		spin_unlock_irqrestore(&intf->xmit_msgs_lock, flags);

	if (newmsg)
@@ -4466,51 +4542,6 @@ void ipmi_smi_msg_received(struct ipmi_smi *intf, 
	unsigned long flags = 0; /* keep us warning-free. */

	int run_to_completion = intf->run_to_completion;



	if ((msg->data_size >= 2)

	    && (msg->data[0] == (IPMI_NETFN_APP_REQUEST << 2))

	    && (msg->data[1] == IPMI_SEND_MSG_CMD)

	    && (msg->user_data == NULL)) {



		if (intf->in_shutdown)

			goto free_msg;



		/*

		 * This is the local response to a command send, start

		 * the timer for these.  The user_data will not be

		 * NULL if this is a response send, and we will let

		 * response sends just go through.

		 */



		/*

		 * Check for errors, if we get certain errors (ones

		 * that mean basically we can try again later), we

		 * ignore them and start the timer.  Otherwise we

		 * report the error immediately.

		 */

		if ((msg->rsp_size >= 3) && (msg->rsp[2] != 0)

		    && (msg->rsp[2] != IPMI_NODE_BUSY_ERR)

		    && (msg->rsp[2] != IPMI_LOST_ARBITRATION_ERR)

		    && (msg->rsp[2] != IPMI_BUS_ERR)

		    && (msg->rsp[2] != IPMI_NAK_ON_WRITE_ERR)) {

			int ch = msg->rsp[3] & 0xf;

			struct ipmi_channel *chans;



			/* Got an error sending the message, handle it. */



			chans = READ_ONCE(intf->channel_list)->c;

			if ((chans[ch].medium == IPMI_CHANNEL_MEDIUM_8023LAN)

			    || (chans[ch].medium == IPMI_CHANNEL_MEDIUM_ASYNC))

				ipmi_inc_stat(intf, sent_lan_command_errs);

			else

				ipmi_inc_stat(intf, sent_ipmb_command_errs);

			intf_err_seq(intf, msg->msgid, msg->rsp[2]);

		} else

			/* The message was sent, start the timer. */

			intf_start_seq_timer(intf, msg->msgid);



free_msg:

		ipmi_free_smi_msg(msg);

	} else {

	/*

	 * To preserve message order, we keep a queue and deliver from

	 * a tasklet.
@@ -4521,7 +4552,6 @@ void ipmi_smi_msg_received(struct ipmi_smi *intf, 
	if (!run_to_completion)

		spin_unlock_irqrestore(&intf->waiting_rcv_msgs_lock,

				       flags);

	}



	if (!run_to_completion)

		spin_lock_irqsave(&intf->xmit_msgs_lock, flags);
@@ -4576,7 +4606,7 @@ static void check_msg_timeout(struct ipmi_smi *intf, struct seq_table *ent, 
			      struct list_head *timeouts,

			      unsigned long timeout_period,

			      int slot, unsigned long *flags,

			      unsigned int *watch_mask)

			      bool *need_timer)

{

	struct ipmi_recv_msg *msg;
@@ -4588,13 +4618,14 @@ static void check_msg_timeout(struct ipmi_smi *intf, struct seq_table *ent, 


	if (timeout_period < ent->timeout) {

		ent->timeout -= timeout_period;

		*watch_mask |= IPMI_WATCH_MASK_CHECK_MESSAGES;

		*need_timer = true;

		return;

	}



	if (ent->retries_left == 0) {

		/* The message has used all its retries. */

		ent->inuse = 0;

		smi_remove_watch(intf, IPMI_WATCH_MASK_CHECK_MESSAGES);

		msg = ent->recv_msg;

		list_add_tail(&msg->link, timeouts);

		if (ent->broadcast)
@@ -4607,7 +4638,7 @@ static void check_msg_timeout(struct ipmi_smi *intf, struct seq_table *ent, 
		struct ipmi_smi_msg *smi_msg;

		/* More retries, send again. */



		*watch_mask |= IPMI_WATCH_MASK_CHECK_MESSAGES;

		*need_timer = true;



		/*

		 * Start with the max timer, set to normal timer after
@@ -4652,20 +4683,20 @@ static void check_msg_timeout(struct ipmi_smi *intf, struct seq_table *ent, 
	}

}



static unsigned int ipmi_timeout_handler(struct ipmi_smi *intf,

static bool ipmi_timeout_handler(struct ipmi_smi *intf,

				 unsigned long timeout_period)

{

	struct list_head     timeouts;

	struct ipmi_recv_msg *msg, *msg2;

	unsigned long        flags;

	int                  i;

	unsigned int         watch_mask = 0;

	bool                 need_timer = false;



	if (!intf->bmc_registered) {

		kref_get(&intf->refcount);

		if (!schedule_work(&intf->bmc_reg_work)) {

			kref_put(&intf->refcount, intf_free);

			watch_mask |= IPMI_WATCH_MASK_INTERNAL;

			need_timer = true;

		}

	}
@@ -4685,7 +4716,7 @@ static unsigned int ipmi_timeout_handler(struct ipmi_smi *intf, 
	for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++)

		check_msg_timeout(intf, &intf->seq_table[i],

				  &timeouts, timeout_period, i,

				  &flags, &watch_mask);

				  &flags, &need_timer);

	spin_unlock_irqrestore(&intf->seq_lock, flags);



	list_for_each_entry_safe(msg, msg2, &timeouts, link)
@@ -4716,7 +4747,7 @@ static unsigned int ipmi_timeout_handler(struct ipmi_smi *intf, 


	tasklet_schedule(&intf->recv_tasklet);



	return watch_mask;

	return need_timer;

}



static void ipmi_request_event(struct ipmi_smi *intf)
@@ -4736,9 +4767,8 @@ static atomic_t stop_operation; 
static void ipmi_timeout(struct timer_list *unused)

{

	struct ipmi_smi *intf;

	unsigned int watch_mask = 0;

	bool need_timer = false;

	int index;

	unsigned long flags;



	if (atomic_read(&stop_operation))

		return;
@@ -4751,28 +4781,14 @@ static void ipmi_timeout(struct timer_list *unused) 
				ipmi_request_event(intf);

				intf->ticks_to_req_ev = IPMI_REQUEST_EV_TIME;

			}

			watch_mask |= IPMI_WATCH_MASK_INTERNAL;

			need_timer = true;

		}



		if (atomic_read(&intf->watchdog_waiters))

			watch_mask |= IPMI_WATCH_MASK_CHECK_WATCHDOG;



		if (atomic_read(&intf->command_waiters))

			watch_mask |= IPMI_WATCH_MASK_CHECK_COMMANDS;



		watch_mask |= ipmi_timeout_handler(intf, IPMI_TIMEOUT_TIME);



		spin_lock_irqsave(&intf->xmit_msgs_lock, flags);

		if (watch_mask != intf->last_watch_mask &&

					intf->handlers->set_need_watch)

			intf->handlers->set_need_watch(intf->send_info,

						       watch_mask);

		intf->last_watch_mask = watch_mask;

		spin_unlock_irqrestore(&intf->xmit_msgs_lock, flags);

		need_timer |= ipmi_timeout_handler(intf, IPMI_TIMEOUT_TIME);

	}

	srcu_read_unlock(&ipmi_interfaces_srcu, index);



	if (watch_mask)

	if (need_timer)

		mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES);

}