Merge tag 'for-linus-3.20-1' of git://git.code.sf.net/p/openipmi/linux-ipmi (7bad2227) · Commits · 戴 / test

drivers/char/ipmi/ipmi_devintf.c

+5 −1

Original line number	Diff line number	Diff line
		@@ -157,12 +157,16 @@ static int ipmi_release(struct inode inode, struct file file)
		{
		struct ipmi_file_private *priv = file->private_data;
		int rv;
		struct ipmi_recv_msg msg, next;

		rv = ipmi_destroy_user(priv->user);
		if (rv)
		return rv;

		/* FIXME - free the messages in the list. */
		list_for_each_entry_safe(msg, next, &priv->recv_msgs, link)
		ipmi_free_recv_msg(msg);


		kfree(priv);

		return 0;

drivers/char/ipmi/ipmi_msghandler.c

+46 −56

Original line number	Diff line number	Diff line
		@@ -1483,14 +1483,10 @@ static inline void format_lan_msg(struct ipmi_smi_msg *smi_msg,
		smi_msg->msgid = msgid;
		}

		static void smi_send(ipmi_smi_t intf, struct ipmi_smi_handlers *handlers,
		struct ipmi_smi_msg *smi_msg, int priority)
		static struct ipmi_smi_msg *smi_add_send_msg(ipmi_smi_t intf,
		struct ipmi_smi_msg *smi_msg,
		int priority)
		{
		int run_to_completion = intf->run_to_completion;
		unsigned long flags;

		if (!run_to_completion)
		spin_lock_irqsave(&intf->xmit_msgs_lock, flags);
		if (intf->curr_msg) {
		if (priority > 0)
		list_add_tail(&smi_msg->link, &intf->hp_xmit_msgs);
		@@ -1500,8 +1496,25 @@ static void smi_send(ipmi_smi_t intf, struct ipmi_smi_handlers *handlers,
		} else {
		intf->curr_msg = smi_msg;
		}
		if (!run_to_completion)

		return smi_msg;
		}


		static void smi_send(ipmi_smi_t intf, struct ipmi_smi_handlers *handlers,
		struct ipmi_smi_msg *smi_msg, int priority)
		{
		int run_to_completion = intf->run_to_completion;

		if (run_to_completion) {
		smi_msg = smi_add_send_msg(intf, smi_msg, priority);
		} else {
		unsigned long flags;

		spin_lock_irqsave(&intf->xmit_msgs_lock, flags);
		smi_msg = smi_add_send_msg(intf, smi_msg, priority);
		spin_unlock_irqrestore(&intf->xmit_msgs_lock, flags);
		}

		if (smi_msg)
		handlers->sender(intf->send_info, smi_msg);
		@@ -1985,7 +1998,9 @@ static int smi_ipmb_proc_show(struct seq_file m, void v)
		seq_printf(m, "%x", intf->channels[0].address);
		for (i = 1; i < IPMI_MAX_CHANNELS; i++)
		seq_printf(m, " %x", intf->channels[i].address);
		return seq_putc(m, '\n');
		seq_putc(m, '\n');

		return seq_has_overflowed(m);
		}

		static int smi_ipmb_proc_open(struct inode inode, struct file file)
		@@ -2004,9 +2019,11 @@ static int smi_version_proc_show(struct seq_file m, void v)
		{
		ipmi_smi_t intf = m->private;

		return seq_printf(m, "%u.%u\n",
		seq_printf(m, "%u.%u\n",
		ipmi_version_major(&intf->bmc->id),
		ipmi_version_minor(&intf->bmc->id));

		return seq_has_overflowed(m);
		}

		static int smi_version_proc_open(struct inode inode, struct file file)
		@@ -2353,11 +2370,28 @@ static struct attribute *bmc_dev_attrs[] = {
		&dev_attr_additional_device_support.attr,
		&dev_attr_manufacturer_id.attr,
		&dev_attr_product_id.attr,
		&dev_attr_aux_firmware_revision.attr,
		&dev_attr_guid.attr,
		NULL
		};

		static umode_t bmc_dev_attr_is_visible(struct kobject *kobj,
		struct attribute *attr, int idx)
		{
		struct device *dev = kobj_to_dev(kobj);
		struct bmc_device *bmc = to_bmc_device(dev);
		umode_t mode = attr->mode;

		if (attr == &dev_attr_aux_firmware_revision.attr)
		return bmc->id.aux_firmware_revision_set ? mode : 0;
		if (attr == &dev_attr_guid.attr)
		return bmc->guid_set ? mode : 0;
		return mode;
		}

		static struct attribute_group bmc_dev_attr_group = {
		.attrs = bmc_dev_attrs,
		.is_visible = bmc_dev_attr_is_visible,
		};

		static const struct attribute_group *bmc_dev_attr_groups[] = {
		@@ -2380,13 +2414,6 @@ cleanup_bmc_device(struct kref *ref)
		{
		struct bmc_device *bmc = container_of(ref, struct bmc_device, usecount);

		if (bmc->id.aux_firmware_revision_set)
		device_remove_file(&bmc->pdev.dev,
		&dev_attr_aux_firmware_revision);
		if (bmc->guid_set)
		device_remove_file(&bmc->pdev.dev,
		&dev_attr_guid);

		platform_device_unregister(&bmc->pdev);
		}

		@@ -2407,33 +2434,6 @@ static void ipmi_bmc_unregister(ipmi_smi_t intf)
		mutex_unlock(&ipmidriver_mutex);
		}

		static int create_bmc_files(struct bmc_device *bmc)
		{
		int err;

		if (bmc->id.aux_firmware_revision_set) {
		err = device_create_file(&bmc->pdev.dev,
		&dev_attr_aux_firmware_revision);
		if (err)
		goto out;
		}
		if (bmc->guid_set) {
		err = device_create_file(&bmc->pdev.dev,
		&dev_attr_guid);
		if (err)
		goto out_aux_firm;
		}

		return 0;

		out_aux_firm:
		if (bmc->id.aux_firmware_revision_set)
		device_remove_file(&bmc->pdev.dev,
		&dev_attr_aux_firmware_revision);
		out:
		return err;
		}

		static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
		{
		int rv;
		@@ -2522,15 +2522,6 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
		return rv;
		}

		rv = create_bmc_files(bmc);
		if (rv) {
		mutex_lock(&ipmidriver_mutex);
		platform_device_unregister(&bmc->pdev);
		mutex_unlock(&ipmidriver_mutex);

		return rv;
		}

		dev_info(intf->si_dev, "Found new BMC (man_id: 0x%6.6x, "
		"prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
		bmc->id.manufacturer_id,
		@@ -4212,7 +4203,6 @@ static void need_waiter(ipmi_smi_t intf)
		static atomic_t smi_msg_inuse_count = ATOMIC_INIT(0);
		static atomic_t recv_msg_inuse_count = ATOMIC_INIT(0);

		/* FIXME - convert these to slabs. */
		static void free_smi_msg(struct ipmi_smi_msg *msg)
		{
		atomic_dec(&smi_msg_inuse_count);

drivers/char/ipmi/ipmi_si_intf.c

+56 −65

Original line number	Diff line number	Diff line
		@@ -321,6 +321,18 @@ static int try_smi_init(struct smi_info *smi);
		static void cleanup_one_si(struct smi_info *to_clean);
		static void cleanup_ipmi_si(void);

		#ifdef DEBUG_TIMING
		void debug_timestamp(char *msg)
		{
		struct timespec64 t;

		getnstimeofday64(&t);
		pr_debug("**%s: %lld.%9.9ld\n", msg, (long long) t.tv_sec, t.tv_nsec);
		}
		#else
		#define debug_timestamp(x)
		#endif

		static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
		static int register_xaction_notifier(struct notifier_block *nb)
		{
		@@ -358,9 +370,6 @@ static void return_hosed_msg(struct smi_info *smi_info, int cCode)
		static enum si_sm_result start_next_msg(struct smi_info *smi_info)
		{
		int rv;
		#ifdef DEBUG_TIMING
		struct timeval t;
		#endif

		if (!smi_info->waiting_msg) {
		smi_info->curr_msg = NULL;
		@@ -370,10 +379,7 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)

		smi_info->curr_msg = smi_info->waiting_msg;
		smi_info->waiting_msg = NULL;
		#ifdef DEBUG_TIMING
		do_gettimeofday(&t);
		printk(KERN_DEBUG "**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
		#endif
		debug_timestamp("Start2");
		err = atomic_notifier_call_chain(&xaction_notifier_list,
		0, smi_info);
		if (err & NOTIFY_STOP_MASK) {
		@@ -582,12 +588,8 @@ static void check_bt_irq(struct smi_info *smi_info, bool irq_on)
		static void handle_transaction_done(struct smi_info *smi_info)
		{
		struct ipmi_smi_msg *msg;
		#ifdef DEBUG_TIMING
		struct timeval t;

		do_gettimeofday(&t);
		printk(KERN_DEBUG "**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
		#endif
		debug_timestamp("Done");
		switch (smi_info->si_state) {
		case SI_NORMAL:
		if (!smi_info->curr_msg)
		@@ -929,24 +931,15 @@ static void sender(void *send_info,
		struct smi_info *smi_info = send_info;
		enum si_sm_result result;
		unsigned long flags;
		#ifdef DEBUG_TIMING
		struct timeval t;
		#endif

		BUG_ON(smi_info->waiting_msg);
		smi_info->waiting_msg = msg;

		#ifdef DEBUG_TIMING
		do_gettimeofday(&t);
		printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
		#endif
		debug_timestamp("Enqueue");

		if (smi_info->run_to_completion) {
		/*
		* If we are running to completion, start it and run
		* transactions until everything is clear.
		*/
		smi_info->curr_msg = smi_info->waiting_msg;
		smi_info->curr_msg = msg;
		smi_info->waiting_msg = NULL;

		/*
		@@ -964,6 +957,15 @@ static void sender(void *send_info,
		}

		spin_lock_irqsave(&smi_info->si_lock, flags);
		/*
		* The following two lines don't need to be under the lock for
		* the lock's sake, but they do need SMP memory barriers to
		* avoid getting things out of order. We are already claiming
		* the lock, anyway, so just do it under the lock to avoid the
		* ordering problem.
		*/
		BUG_ON(smi_info->waiting_msg);
		smi_info->waiting_msg = msg;
		check_start_timer_thread(smi_info);
		spin_unlock_irqrestore(&smi_info->si_lock, flags);
		}
		@@ -989,18 +991,18 @@ static void set_run_to_completion(void *send_info, bool i_run_to_completion)
		* we are spinning in kipmid looking for something and not delaying
		* between checks
		*/
		static inline void ipmi_si_set_not_busy(struct timespec *ts)
		static inline void ipmi_si_set_not_busy(struct timespec64 *ts)
		{
		ts->tv_nsec = -1;
		}
		static inline int ipmi_si_is_busy(struct timespec *ts)
		static inline int ipmi_si_is_busy(struct timespec64 *ts)
		{
		return ts->tv_nsec != -1;
		}

		static inline int ipmi_thread_busy_wait(enum si_sm_result smi_result,
		const struct smi_info *smi_info,
		struct timespec *busy_until)
		struct timespec64 *busy_until)
		{
		unsigned int max_busy_us = 0;

		@@ -1009,12 +1011,13 @@ static inline int ipmi_thread_busy_wait(enum si_sm_result smi_result,
		if (max_busy_us == 0 \|\| smi_result != SI_SM_CALL_WITH_DELAY)
		ipmi_si_set_not_busy(busy_until);
		else if (!ipmi_si_is_busy(busy_until)) {
		getnstimeofday(busy_until);
		timespec_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
		getnstimeofday64(busy_until);
		timespec64_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
		} else {
		struct timespec now;
		getnstimeofday(&now);
		if (unlikely(timespec_compare(&now, busy_until) > 0)) {
		struct timespec64 now;

		getnstimeofday64(&now);
		if (unlikely(timespec64_compare(&now, busy_until) > 0)) {
		ipmi_si_set_not_busy(busy_until);
		return 0;
		}
		@@ -1037,7 +1040,7 @@ static int ipmi_thread(void *data)
		struct smi_info *smi_info = data;
		unsigned long flags;
		enum si_sm_result smi_result;
		struct timespec busy_until;
		struct timespec64 busy_until;

		ipmi_si_set_not_busy(&busy_until);
		set_user_nice(current, MAX_NICE);
		@@ -1128,15 +1131,10 @@ static void smi_timeout(unsigned long data)
		unsigned long jiffies_now;
		long time_diff;
		long timeout;
		#ifdef DEBUG_TIMING
		struct timeval t;
		#endif

		spin_lock_irqsave(&(smi_info->si_lock), flags);
		#ifdef DEBUG_TIMING
		do_gettimeofday(&t);
		printk(KERN_DEBUG "**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
		#endif
		debug_timestamp("Timer");

		jiffies_now = jiffies;
		time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
		* SI_USEC_PER_JIFFY);
		@@ -1173,18 +1171,13 @@ static irqreturn_t si_irq_handler(int irq, void *data)
		{
		struct smi_info *smi_info = data;
		unsigned long flags;
		#ifdef DEBUG_TIMING
		struct timeval t;
		#endif

		spin_lock_irqsave(&(smi_info->si_lock), flags);

		smi_inc_stat(smi_info, interrupts);

		#ifdef DEBUG_TIMING
		do_gettimeofday(&t);
		printk(KERN_DEBUG "**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
		#endif
		debug_timestamp("Interrupt");

		smi_event_handler(smi_info, 0);
		spin_unlock_irqrestore(&(smi_info->si_lock), flags);
		return IRQ_HANDLED;
		@@ -2038,18 +2031,13 @@ static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
		{
		struct smi_info *smi_info = context;
		unsigned long flags;
		#ifdef DEBUG_TIMING
		struct timeval t;
		#endif

		spin_lock_irqsave(&(smi_info->si_lock), flags);

		smi_inc_stat(smi_info, interrupts);

		#ifdef DEBUG_TIMING
		do_gettimeofday(&t);
		printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
		#endif
		debug_timestamp("ACPI_GPE");

		smi_event_handler(smi_info, 0);
		spin_unlock_irqrestore(&(smi_info->si_lock), flags);

		@@ -2071,7 +2059,6 @@ static int acpi_gpe_irq_setup(struct smi_info *info)
		if (!info->irq)
		return 0;

		/* FIXME - is level triggered right? */
		status = acpi_install_gpe_handler(NULL,
		info->irq,
		ACPI_GPE_LEVEL_TRIGGERED,
		@@ -2998,7 +2985,9 @@ static int smi_type_proc_show(struct seq_file m, void v)
		{
		struct smi_info *smi = m->private;

		return seq_printf(m, "%s\n", si_to_str[smi->si_type]);
		seq_printf(m, "%s\n", si_to_str[smi->si_type]);

		return seq_has_overflowed(m);
		}

		static int smi_type_proc_open(struct inode inode, struct file file)
		@@ -3060,7 +3049,7 @@ static int smi_params_proc_show(struct seq_file m, void v)
		{
		struct smi_info *smi = m->private;

		return seq_printf(m,
		seq_printf(m,
		"%s,%s,0x%lx,rsp=%d,rsi=%d,rsh=%d,irq=%d,ipmb=%d\n",
		si_to_str[smi->si_type],
		addr_space_to_str[smi->io.addr_type],
		@@ -3070,6 +3059,8 @@ static int smi_params_proc_show(struct seq_file m, void v)
		smi->io.regshift,
		smi->irq,
		smi->slave_addr);

		return seq_has_overflowed(m);
		}

		static int smi_params_proc_open(struct inode inode, struct file file)

drivers/char/ipmi/ipmi_ssif.c

+3 −3

Original line number	Diff line number	Diff line
		@@ -1097,8 +1097,6 @@ static int ssif_remove(struct i2c_client *client)
		if (!ssif_info)
		return 0;

		i2c_set_clientdata(client, NULL);

		/*
		* After this point, we won't deliver anything asychronously
		* to the message handler. We can unregister ourself.
		@@ -1198,7 +1196,9 @@ static int ssif_detect(struct i2c_client client, struct i2c_board_info info)

		static int smi_type_proc_show(struct seq_file m, void v)
		{
		return seq_puts(m, "ssif\n");
		seq_puts(m, "ssif\n");

		return seq_has_overflowed(m);
		}

		static int smi_type_proc_open(struct inode inode, struct file file)

Admin message