1 files changed, 110 insertions, 59 deletions

diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 4f3f8c9ec262..58c0e6387cf7 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -36,6 +36,7 @@
 #include <asm/system.h>
 #include <linux/poll.h>
 #include <linux/sched.h>
+#include <linux/seq_file.h>
 #include <linux/spinlock.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
@@ -970,6 +971,33 @@ out_kfree:
 }
 EXPORT_SYMBOL(ipmi_create_user);
 
+int ipmi_get_smi_info(int if_num, struct ipmi_smi_info *data)
+{
+        int           rv = 0;
+        ipmi_smi_t    intf;
+        struct ipmi_smi_handlers *handlers;
+
+        mutex_lock(&ipmi_interfaces_mutex);
+        list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
+                if (intf->intf_num == if_num)
+                        goto found;
+        }
+        /* Not found, return an error */
+        rv = -EINVAL;
+        mutex_unlock(&ipmi_interfaces_mutex);
+        return rv;
+
+found:
+        handlers = intf->handlers;
+        rv = -ENOSYS;
+        if (handlers->get_smi_info)
+                rv = handlers->get_smi_info(intf->send_info, data);
+        mutex_unlock(&ipmi_interfaces_mutex);
+
+        return rv;
+}
+EXPORT_SYMBOL(ipmi_get_smi_info);
+
 static void free_user(struct kref *ref)
 {
         ipmi_user_t user = container_of(ref, struct ipmi_user, refcount);
@@ -1869,102 +1897,128 @@ int ipmi_request_supply_msgs(ipmi_user_t          user,
 EXPORT_SYMBOL(ipmi_request_supply_msgs);
 
 #ifdef CONFIG_PROC_FS
-static int ipmb_file_read_proc(char *page, char **start, off_t off,
-                               int count, int *eof, void *data)
+static int smi_ipmb_proc_show(struct seq_file *m, void *v)
 {
-        char       *out = (char *) page;
-        ipmi_smi_t intf = data;
+        ipmi_smi_t intf = m->private;
         int        i;
-        int        rv = 0;
 
-        for (i = 0; i < IPMI_MAX_CHANNELS; i++)
-                rv += sprintf(out+rv, "%x ", intf->channels[i].address);
-        out[rv-1] = '\n'; /* Replace the final space with a newline */
-        out[rv] = '\0';
-        rv++;
-        return rv;
+        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');
+}
+
+static int smi_ipmb_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, smi_ipmb_proc_show, PDE(inode)->data);
 }
 
-static int version_file_read_proc(char *page, char **start, off_t off,
-                                  int count, int *eof, void *data)
+static const struct file_operations smi_ipmb_proc_ops = {
+        .open           = smi_ipmb_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static int smi_version_proc_show(struct seq_file *m, void *v)
 {
-        char       *out = (char *) page;
-        ipmi_smi_t intf = data;
+        ipmi_smi_t intf = m->private;
 
-        return sprintf(out, "%u.%u\n",
+        return seq_printf(m, "%u.%u\n",
                        ipmi_version_major(&intf->bmc->id),
                        ipmi_version_minor(&intf->bmc->id));
 }
 
-static int stat_file_read_proc(char *page, char **start, off_t off,
-                               int count, int *eof, void *data)
+static int smi_version_proc_open(struct inode *inode, struct file *file)
 {
-        char       *out = (char *) page;
-        ipmi_smi_t intf = data;
+        return single_open(file, smi_version_proc_show, PDE(inode)->data);
+}
 
-        out += sprintf(out, "sent_invalid_commands:       %u\n",
+static const struct file_operations smi_version_proc_ops = {
+        .open           = smi_version_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static int smi_stats_proc_show(struct seq_file *m, void *v)
+{
+        ipmi_smi_t intf = m->private;
+
+        seq_printf(m, "sent_invalid_commands:       %u\n",
                        ipmi_get_stat(intf, sent_invalid_commands));
-        out += sprintf(out, "sent_local_commands:         %u\n",
+        seq_printf(m, "sent_local_commands:         %u\n",
                        ipmi_get_stat(intf, sent_local_commands));
-        out += sprintf(out, "handled_local_responses:     %u\n",
+        seq_printf(m, "handled_local_responses:     %u\n",
                        ipmi_get_stat(intf, handled_local_responses));
-        out += sprintf(out, "unhandled_local_responses:   %u\n",
+        seq_printf(m, "unhandled_local_responses:   %u\n",
                        ipmi_get_stat(intf, unhandled_local_responses));
-        out += sprintf(out, "sent_ipmb_commands:          %u\n",
+        seq_printf(m, "sent_ipmb_commands:          %u\n",
                        ipmi_get_stat(intf, sent_ipmb_commands));
-        out += sprintf(out, "sent_ipmb_command_errs:      %u\n",
+        seq_printf(m, "sent_ipmb_command_errs:      %u\n",
                        ipmi_get_stat(intf, sent_ipmb_command_errs));
-        out += sprintf(out, "retransmitted_ipmb_commands: %u\n",
+        seq_printf(m, "retransmitted_ipmb_commands: %u\n",
                        ipmi_get_stat(intf, retransmitted_ipmb_commands));
-        out += sprintf(out, "timed_out_ipmb_commands:     %u\n",
+        seq_printf(m, "timed_out_ipmb_commands:     %u\n",
                        ipmi_get_stat(intf, timed_out_ipmb_commands));
-        out += sprintf(out, "timed_out_ipmb_broadcasts:   %u\n",
+        seq_printf(m, "timed_out_ipmb_broadcasts:   %u\n",
                        ipmi_get_stat(intf, timed_out_ipmb_broadcasts));
-        out += sprintf(out, "sent_ipmb_responses:         %u\n",
+        seq_printf(m, "sent_ipmb_responses:         %u\n",
                        ipmi_get_stat(intf, sent_ipmb_responses));
-        out += sprintf(out, "handled_ipmb_responses:      %u\n",
+        seq_printf(m, "handled_ipmb_responses:      %u\n",
                        ipmi_get_stat(intf, handled_ipmb_responses));
-        out += sprintf(out, "invalid_ipmb_responses:      %u\n",
+        seq_printf(m, "invalid_ipmb_responses:      %u\n",
                        ipmi_get_stat(intf, invalid_ipmb_responses));
-        out += sprintf(out, "unhandled_ipmb_responses:    %u\n",
+        seq_printf(m, "unhandled_ipmb_responses:    %u\n",
                        ipmi_get_stat(intf, unhandled_ipmb_responses));
-        out += sprintf(out, "sent_lan_commands:           %u\n",
+        seq_printf(m, "sent_lan_commands:           %u\n",
                        ipmi_get_stat(intf, sent_lan_commands));
-        out += sprintf(out, "sent_lan_command_errs:       %u\n",
+        seq_printf(m, "sent_lan_command_errs:       %u\n",
                        ipmi_get_stat(intf, sent_lan_command_errs));
-        out += sprintf(out, "retransmitted_lan_commands:  %u\n",
+        seq_printf(m, "retransmitted_lan_commands:  %u\n",
                        ipmi_get_stat(intf, retransmitted_lan_commands));
-        out += sprintf(out, "timed_out_lan_commands:      %u\n",
+        seq_printf(m, "timed_out_lan_commands:      %u\n",
                        ipmi_get_stat(intf, timed_out_lan_commands));
-        out += sprintf(out, "sent_lan_responses:          %u\n",
+        seq_printf(m, "sent_lan_responses:          %u\n",
                        ipmi_get_stat(intf, sent_lan_responses));
-        out += sprintf(out, "handled_lan_responses:       %u\n",
+        seq_printf(m, "handled_lan_responses:       %u\n",
                        ipmi_get_stat(intf, handled_lan_responses));
-        out += sprintf(out, "invalid_lan_responses:       %u\n",
+        seq_printf(m, "invalid_lan_responses:       %u\n",
                        ipmi_get_stat(intf, invalid_lan_responses));
-        out += sprintf(out, "unhandled_lan_responses:     %u\n",
+        seq_printf(m, "unhandled_lan_responses:     %u\n",
                        ipmi_get_stat(intf, unhandled_lan_responses));
-        out += sprintf(out, "handled_commands:            %u\n",
+        seq_printf(m, "handled_commands:            %u\n",
                        ipmi_get_stat(intf, handled_commands));
-        out += sprintf(out, "invalid_commands:            %u\n",
+        seq_printf(m, "invalid_commands:            %u\n",
                        ipmi_get_stat(intf, invalid_commands));
-        out += sprintf(out, "unhandled_commands:          %u\n",
+        seq_printf(m, "unhandled_commands:          %u\n",
                        ipmi_get_stat(intf, unhandled_commands));
-        out += sprintf(out, "invalid_events:              %u\n",
+        seq_printf(m, "invalid_events:              %u\n",
                        ipmi_get_stat(intf, invalid_events));
-        out += sprintf(out, "events:                      %u\n",
+        seq_printf(m, "events:                      %u\n",
                        ipmi_get_stat(intf, events));
-        out += sprintf(out, "failed rexmit LAN msgs:      %u\n",
+        seq_printf(m, "failed rexmit LAN msgs:      %u\n",
                        ipmi_get_stat(intf, dropped_rexmit_lan_commands));
-        out += sprintf(out, "failed rexmit IPMB msgs:     %u\n",
+        seq_printf(m, "failed rexmit IPMB msgs:     %u\n",
                        ipmi_get_stat(intf, dropped_rexmit_ipmb_commands));
+        return 0;
+}
 
-        return (out - ((char *) page));
+static int smi_stats_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, smi_stats_proc_show, PDE(inode)->data);
 }
+
+static const struct file_operations smi_stats_proc_ops = {
+        .open           = smi_stats_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
 #endif /* CONFIG_PROC_FS */
 
 int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
-                            read_proc_t *read_proc,
+                            const struct file_operations *proc_ops,
                             void *data)
 {
         int                    rv = 0;
@@ -1983,15 +2037,12 @@ int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
         }
         strcpy(entry->name, name);
 
-        file = create_proc_entry(name, 0, smi->proc_dir);
+        file = proc_create_data(name, 0, smi->proc_dir, proc_ops, data);
         if (!file) {
                 kfree(entry->name);
                 kfree(entry);
                 rv = -ENOMEM;
         } else {
-                file->data = data;
-                file->read_proc = read_proc;
-
                 mutex_lock(&smi->proc_entry_lock);
                 /* Stick it on the list. */
                 entry->next = smi->proc_entries;
@@ -2016,17 +2067,17 @@ static int add_proc_entries(ipmi_smi_t smi, int num)
 
         if (rv == 0)
                 rv = ipmi_smi_add_proc_entry(smi, "stats",
-                                             stat_file_read_proc,
+                                             &smi_stats_proc_ops,
                                              smi);
 
         if (rv == 0)
                 rv = ipmi_smi_add_proc_entry(smi, "ipmb",
-                                             ipmb_file_read_proc,
+                                             &smi_ipmb_proc_ops,
                                              smi);
 
         if (rv == 0)
                 rv = ipmi_smi_add_proc_entry(smi, "version",
-                                             version_file_read_proc,
+                                             &smi_version_proc_ops,
                                              smi);
 #endif /* CONFIG_PROC_FS */
 
@@ -4442,13 +4493,13 @@ static int ipmi_init_msghandler(void)
         return 0;
 }
 
-static __init int ipmi_init_msghandler_mod(void)
+static int __init ipmi_init_msghandler_mod(void)
 {
         ipmi_init_msghandler();
         return 0;
 }
 
-static __exit void cleanup_ipmi(void)
+static void __exit cleanup_ipmi(void)
 {
         int count;