URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [ipmi/] [ipmi_msghandler.c] - Rev 1765
Compare with Previous | Blame | View Log
/* * ipmi_msghandler.c * * Incoming and outgoing message routing for an IPMI interface. * * Author: MontaVista Software, Inc. * Corey Minyard <minyard@mvista.com> * source@mvista.com * * Copyright 2002 MontaVista Software Inc. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. * * * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <linux/config.h> #include <linux/module.h> #include <linux/errno.h> #include <asm/system.h> #include <linux/sched.h> #include <linux/poll.h> #include <linux/spinlock.h> #include <linux/rwsem.h> #include <linux/slab.h> #include <linux/ipmi.h> #include <linux/ipmi_smi.h> #include <linux/notifier.h> #include <linux/init.h> struct ipmi_recv_msg *ipmi_alloc_recv_msg(void); static int ipmi_init_msghandler(void); static int initialized = 0; #define MAX_EVENTS_IN_QUEUE 25 /* Don't let a message sit in a queue forever, always time it with at lest the max message timer. */ #define MAX_MSG_TIMEOUT 60000 struct ipmi_user { struct list_head link; /* The upper layer that handles receive messages. */ struct ipmi_user_hndl *handler; void *handler_data; /* The interface this user is bound to. */ ipmi_smi_t intf; /* Does this interface receive IPMI events? */ int gets_events; }; struct cmd_rcvr { struct list_head link; ipmi_user_t user; unsigned char netfn; unsigned char cmd; }; struct seq_table { int inuse : 1; unsigned long timeout; unsigned long orig_timeout; unsigned int retries_left; /* To verify on an incoming send message response that this is the message that the response is for, we keep a sequence id and increment it every time we send a message. */ long seqid; /* This is held so we can properly respond to the message on a timeout, and it is used to hold the temporary data for retransmission, too. */ struct ipmi_recv_msg *recv_msg; }; /* Store the information in a msgid (long) to allow us to find a sequence table entry from the msgid. */ #define STORE_SEQ_IN_MSGID(seq, seqid) (((seq&0xff)<<26) | (seqid&0x3ffffff)) #define GET_SEQ_FROM_MSGID(msgid, seq, seqid) \ do { \ seq = ((msgid >> 26) & 0x3f); \ seqid = (msgid & 0x3fffff); \ } while(0) #define NEXT_SEQID(seqid) (((seqid) + 1) & 0x3fffff) #define IPMI_IPMB_NUM_SEQ 64 struct ipmi_smi { /* The list of upper layers that are using me. We read-lock this when delivering messages to the upper layer to keep the user from going away while we are processing the message. This means that you cannot add or delete a user from the receive callback. */ rwlock_t users_lock; struct list_head users; /* The IPMI version of the BMC on the other end. */ unsigned char version_major; unsigned char version_minor; /* This is the lower-layer's sender routine. */ struct ipmi_smi_handlers *handlers; void *send_info; /* A table of sequence numbers for this interface. We use the sequence numbers for IPMB messages that go out of the interface to match them up with their responses. A routine is called periodically to time the items in this list. */ spinlock_t seq_lock; struct seq_table seq_table[IPMI_IPMB_NUM_SEQ]; int curr_seq; /* Messages that were delayed for some reason (out of memory, for instance), will go in here to be processed later in a periodic timer interrupt. */ spinlock_t waiting_msgs_lock; struct list_head waiting_msgs; /* The list of command receivers that are registered for commands on this interface. */ rwlock_t cmd_rcvr_lock; struct list_head cmd_rcvrs; /* Events that were queues because no one was there to receive them. */ spinlock_t events_lock; /* For dealing with event stuff. */ struct list_head waiting_events; unsigned int waiting_events_count; /* How many events in queue? */ /* This will be non-null if someone registers to receive all IPMI commands (this is for interface emulation). There may not be any things in the cmd_rcvrs list above when this is registered. */ ipmi_user_t all_cmd_rcvr; /* My slave address. This is initialized to IPMI_BMC_SLAVE_ADDR, but may be changed by the user. */ unsigned char my_address; /* My LUN. This should generally stay the SMS LUN, but just in case... */ unsigned char my_lun; }; int ipmi_register_all_cmd_rcvr(ipmi_user_t user) { unsigned long flags; int rv = -EBUSY; write_lock_irqsave(&(user->intf->users_lock), flags); write_lock(&(user->intf->cmd_rcvr_lock)); if ((user->intf->all_cmd_rcvr == NULL) && (list_empty(&(user->intf->cmd_rcvrs)))) { user->intf->all_cmd_rcvr = user; rv = 0; } write_unlock(&(user->intf->cmd_rcvr_lock)); write_unlock_irqrestore(&(user->intf->users_lock), flags); return rv; } int ipmi_unregister_all_cmd_rcvr(ipmi_user_t user) { unsigned long flags; int rv = -EINVAL; write_lock_irqsave(&(user->intf->users_lock), flags); write_lock(&(user->intf->cmd_rcvr_lock)); if (user->intf->all_cmd_rcvr == user) { user->intf->all_cmd_rcvr = NULL; rv = 0; } write_unlock(&(user->intf->cmd_rcvr_lock)); write_unlock_irqrestore(&(user->intf->users_lock), flags); return rv; } #define MAX_IPMI_INTERFACES 4 static ipmi_smi_t ipmi_interfaces[MAX_IPMI_INTERFACES]; /* Used to keep interfaces from going away while operations are operating on interfaces. Grab read if you are not modifying the interfaces, write if you are. */ static DECLARE_RWSEM(interfaces_sem); /* Directly protects the ipmi_interfaces data structure. This is claimed in the timer interrupt. */ static spinlock_t interfaces_lock = SPIN_LOCK_UNLOCKED; /* List of watchers that want to know when smi's are added and deleted. */ static struct list_head smi_watchers = LIST_HEAD_INIT(smi_watchers); static DECLARE_RWSEM(smi_watchers_sem); int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher) { int i; down_read(&interfaces_sem); down_write(&smi_watchers_sem); list_add(&(watcher->link), &smi_watchers); for (i=0; i<MAX_IPMI_INTERFACES; i++) { if (ipmi_interfaces[i] != NULL) { watcher->new_smi(i); } } up_write(&smi_watchers_sem); up_read(&interfaces_sem); return 0; } int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher) { down_write(&smi_watchers_sem); list_del(&(watcher->link)); up_write(&smi_watchers_sem); return 0; } int ipmi_addr_equal(struct ipmi_addr *addr1, struct ipmi_addr *addr2) { if (addr1->addr_type != addr2->addr_type) return 0; if (addr1->channel != addr2->channel) return 0; if (addr1->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) { struct ipmi_system_interface_addr *smi_addr1 = (struct ipmi_system_interface_addr *) addr1; struct ipmi_system_interface_addr *smi_addr2 = (struct ipmi_system_interface_addr *) addr2; return (smi_addr1->lun == smi_addr2->lun); } if ((addr1->addr_type == IPMI_IPMB_ADDR_TYPE) || (addr1->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) { struct ipmi_ipmb_addr *ipmb_addr1 = (struct ipmi_ipmb_addr *) addr1; struct ipmi_ipmb_addr *ipmb_addr2 = (struct ipmi_ipmb_addr *) addr2; return ((ipmb_addr1->slave_addr == ipmb_addr2->slave_addr) && (ipmb_addr1->lun == ipmb_addr2->lun)); } return 1; } int ipmi_validate_addr(struct ipmi_addr *addr, int len) { if (len < sizeof(struct ipmi_system_interface_addr)) { return -EINVAL; } if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) { if (addr->channel != IPMI_BMC_CHANNEL) return -EINVAL; return 0; } if ((addr->channel == IPMI_BMC_CHANNEL) || (addr->channel >= IPMI_NUM_CHANNELS) || (addr->channel < 0)) return -EINVAL; if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE) || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) { if (len < sizeof(struct ipmi_ipmb_addr)) { return -EINVAL; } return 0; } return -EINVAL; } unsigned int ipmi_addr_length(int addr_type) { if (addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) return sizeof(struct ipmi_system_interface_addr); if ((addr_type == IPMI_IPMB_ADDR_TYPE) || (addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) { return sizeof(struct ipmi_ipmb_addr); } return 0; } static void deliver_response(struct ipmi_recv_msg *msg) { msg->user->handler->ipmi_recv_hndl(msg, msg->user->handler_data); } /* Find the next sequence number not being used and add the given message with the given timeout to the sequence table. This must be called with the interface's seq_lock held. */ static int intf_next_seq(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg, unsigned long timeout, int retries, unsigned char *seq, long *seqid) { int rv = 0; unsigned int i; for (i=intf->curr_seq; (i+1)%IPMI_IPMB_NUM_SEQ != intf->curr_seq; i=(i+1)%IPMI_IPMB_NUM_SEQ) { if (! intf->seq_table[i].inuse) break; } if (! intf->seq_table[i].inuse) { intf->seq_table[i].recv_msg = recv_msg; /* Start with the maximum timeout, when the send response comes in we will start the real timer. */ intf->seq_table[i].timeout = MAX_MSG_TIMEOUT; intf->seq_table[i].orig_timeout = timeout; intf->seq_table[i].retries_left = retries; intf->seq_table[i].inuse = 1; intf->seq_table[i].seqid = NEXT_SEQID(intf->seq_table[i].seqid); *seq = i; *seqid = intf->seq_table[i].seqid; intf->curr_seq = (i+1)%IPMI_IPMB_NUM_SEQ; } else { rv = -EAGAIN; } return rv; } /* Return the receive message for the given sequence number and release the sequence number so it can be reused. Some other data is passed in to be sure the message matches up correctly (to help guard against message coming in after their timeout and the sequence number being reused). */ static int intf_find_seq(ipmi_smi_t intf, unsigned char seq, short channel, unsigned char cmd, unsigned char netfn, struct ipmi_addr *addr, struct ipmi_recv_msg **recv_msg) { int rv = -ENODEV; unsigned long flags; if (seq >= IPMI_IPMB_NUM_SEQ) return -EINVAL; spin_lock_irqsave(&(intf->seq_lock), flags); if (intf->seq_table[seq].inuse) { struct ipmi_recv_msg *msg = intf->seq_table[seq].recv_msg; if ((msg->addr.channel == channel) && (msg->msg.cmd == cmd) && (msg->msg.netfn == netfn) && (ipmi_addr_equal(addr, &(msg->addr)))) { *recv_msg = msg; intf->seq_table[seq].inuse = 0; rv = 0; } } spin_unlock_irqrestore(&(intf->seq_lock), flags); return rv; } /* Start the timer for a specific sequence table entry. */ static int intf_start_seq_timer(ipmi_smi_t intf, long msgid) { int rv = -ENODEV; unsigned long flags; unsigned char seq; unsigned long seqid; GET_SEQ_FROM_MSGID(msgid, seq, seqid); spin_lock_irqsave(&(intf->seq_lock), flags); /* We do this verification because the user can be deleted while a message is outstanding. */ if ((intf->seq_table[seq].inuse) && (intf->seq_table[seq].seqid == seqid)) { struct seq_table *ent = &(intf->seq_table[seq]); ent->timeout = ent->orig_timeout; } spin_unlock_irqrestore(&(intf->seq_lock), flags); return rv; } int ipmi_create_user(unsigned int if_num, struct ipmi_user_hndl *handler, void *handler_data, ipmi_user_t *user) { unsigned long flags; ipmi_user_t new_user; int rv = 0; /* There is no module usecount here, because it's not required. Since this can only be used by and called from other modules, they will implicitly use this module, and thus this can't be removed unless the other modules are removed. */ if (handler == NULL) return -EINVAL; /* Make sure the driver is actually initialized, this handles problems with initialization order. */ if (!initialized) { rv = ipmi_init_msghandler(); if (rv) return rv; /* The init code doesn't return an error if it was turned off, but it won't initialize. Check that. */ if (!initialized) return -ENODEV; } new_user = kmalloc(sizeof(*new_user), GFP_KERNEL); if (! new_user) return -ENOMEM; down_read(&interfaces_sem); if ((if_num > MAX_IPMI_INTERFACES) || ipmi_interfaces[if_num] == NULL) { rv = -EINVAL; goto out_unlock; } new_user->handler = handler; new_user->handler_data = handler_data; new_user->intf = ipmi_interfaces[if_num]; new_user->gets_events = 0; rv = new_user->intf->handlers->new_user(new_user->intf->send_info); if (rv) goto out_unlock; write_lock_irqsave(&(new_user->intf->users_lock), flags); list_add_tail(&(new_user->link), &(new_user->intf->users)); write_unlock_irqrestore(&(new_user->intf->users_lock), flags); out_unlock: if (rv) { kfree(new_user); } else { *user = new_user; } up_read(&interfaces_sem); return rv; } static int ipmi_destroy_user_nolock(ipmi_user_t user) { int rv = -ENODEV; ipmi_user_t t_user; struct list_head *entry, *entry2; int i; unsigned long flags; /* Find the user and delete them from the list. */ list_for_each(entry, &(user->intf->users)) { t_user = list_entry(entry, struct ipmi_user, link); if (t_user == user) { list_del(entry); rv = 0; break; } } if (rv) { goto out_unlock; } /* Remove the user from the interfaces sequence table. */ spin_lock_irqsave(&(user->intf->seq_lock), flags); for (i=0; i<IPMI_IPMB_NUM_SEQ; i++) { if (user->intf->seq_table[i].inuse && (user->intf->seq_table[i].recv_msg->user == user)) { user->intf->seq_table[i].inuse = 0; } } spin_unlock_irqrestore(&(user->intf->seq_lock), flags); /* Remove the user from the command receiver's table. */ write_lock_irqsave(&(user->intf->cmd_rcvr_lock), flags); list_for_each_safe(entry, entry2, &(user->intf->cmd_rcvrs)) { struct cmd_rcvr *rcvr; rcvr = list_entry(entry, struct cmd_rcvr, link); if (rcvr->user == user) { list_del(entry); kfree(rcvr); } } write_unlock_irqrestore(&(user->intf->cmd_rcvr_lock), flags); kfree(user); out_unlock: return rv; } int ipmi_destroy_user(ipmi_user_t user) { int rv; ipmi_smi_t intf = user->intf; unsigned long flags; down_read(&interfaces_sem); write_lock_irqsave(&(intf->users_lock), flags); rv = ipmi_destroy_user_nolock(user); if (!rv) intf->handlers->user_left(intf->send_info); write_unlock_irqrestore(&(intf->users_lock), flags); up_read(&interfaces_sem); return rv; } void ipmi_get_version(ipmi_user_t user, unsigned char *major, unsigned char *minor) { *major = user->intf->version_major; *minor = user->intf->version_minor; } void ipmi_set_my_address(ipmi_user_t user, unsigned char address) { user->intf->my_address = address; } unsigned char ipmi_get_my_address(ipmi_user_t user) { return user->intf->my_address; } void ipmi_set_my_LUN(ipmi_user_t user, unsigned char LUN) { user->intf->my_lun = LUN & 0x3; } unsigned char ipmi_get_my_LUN(ipmi_user_t user) { return user->intf->my_lun; } int ipmi_set_gets_events(ipmi_user_t user, int val) { unsigned long flags; struct list_head *e, *e2; struct ipmi_recv_msg *msg; read_lock(&(user->intf->users_lock)); spin_lock_irqsave(&(user->intf->events_lock), flags); user->gets_events = val; if (val) { /* Deliver any queued events. */ list_for_each_safe(e, e2, &(user->intf->waiting_events)) { msg = list_entry(e, struct ipmi_recv_msg, link); list_del(e); msg->user = user; deliver_response(msg); } } spin_unlock_irqrestore(&(user->intf->events_lock), flags); read_unlock(&(user->intf->users_lock)); return 0; } int ipmi_register_for_cmd(ipmi_user_t user, unsigned char netfn, unsigned char cmd) { struct list_head *entry; unsigned long flags; struct cmd_rcvr *rcvr; int rv = 0; rcvr = kmalloc(sizeof(*rcvr), GFP_KERNEL); if (! rcvr) return -ENOMEM; read_lock(&(user->intf->users_lock)); write_lock_irqsave(&(user->intf->cmd_rcvr_lock), flags); if (user->intf->all_cmd_rcvr != NULL) { rv = -EBUSY; goto out_unlock; } /* Make sure the command/netfn is not already registered. */ list_for_each(entry, &(user->intf->cmd_rcvrs)) { struct cmd_rcvr *cmp; cmp = list_entry(entry, struct cmd_rcvr, link); if ((cmp->netfn == netfn) && (cmp->cmd == cmd)) { rv = -EBUSY; break; } } if (! rv) { rcvr->cmd = cmd; rcvr->netfn = netfn; rcvr->user = user; list_add_tail(&(rcvr->link), &(user->intf->cmd_rcvrs)); } out_unlock: write_unlock_irqrestore(&(user->intf->cmd_rcvr_lock), flags); read_unlock(&(user->intf->users_lock)); if (rv) kfree(rcvr); return rv; } int ipmi_unregister_for_cmd(ipmi_user_t user, unsigned char netfn, unsigned char cmd) { struct list_head *entry; unsigned long flags; struct cmd_rcvr *rcvr; int rv = -ENOENT; read_lock(&(user->intf->users_lock)); write_lock_irqsave(&(user->intf->cmd_rcvr_lock), flags); /* Make sure the command/netfn is not already registered. */ list_for_each(entry, &(user->intf->cmd_rcvrs)) { rcvr = list_entry(entry, struct cmd_rcvr, link); if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) { rv = 0; list_del(entry); kfree(rcvr); break; } } write_unlock_irqrestore(&(user->intf->cmd_rcvr_lock), flags); read_unlock(&(user->intf->users_lock)); return rv; } static unsigned char ipmb_checksum(unsigned char *data, int size) { unsigned char csum = 0; for (; size > 0; size--, data++) csum += *data; return -csum; } static inline void format_ipmb_msg(struct ipmi_smi_msg *smi_msg, struct ipmi_msg *msg, struct ipmi_ipmb_addr *ipmb_addr, long msgid, unsigned char ipmb_seq, int broadcast, unsigned char source_address, unsigned char source_lun) { int i = broadcast; /* Format the IPMB header data. */ smi_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); smi_msg->data[1] = IPMI_SEND_MSG_CMD; smi_msg->data[2] = ipmb_addr->channel; if (broadcast) smi_msg->data[3] = 0; smi_msg->data[i+3] = ipmb_addr->slave_addr; smi_msg->data[i+4] = (msg->netfn << 2) | (ipmb_addr->lun & 0x3); smi_msg->data[i+5] = ipmb_checksum(&(smi_msg->data[i+3]), 2); smi_msg->data[i+6] = source_address; smi_msg->data[i+7] = (ipmb_seq << 2) | source_lun; smi_msg->data[i+8] = msg->cmd; /* Now tack on the data to the message. */ if (msg->data_len > 0) memcpy(&(smi_msg->data[i+9]), msg->data, msg->data_len); smi_msg->data_size = msg->data_len + 9; /* Now calculate the checksum and tack it on. */ smi_msg->data[i+smi_msg->data_size] = ipmb_checksum(&(smi_msg->data[i+6]), smi_msg->data_size-6); /* Add on the checksum size and the offset from the broadcast. */ smi_msg->data_size += 1 + i; smi_msg->msgid = msgid; } /* Separate from ipmi_request so that the user does not have to be supplied in certain circumstances (mainly at panic time). If messages are supplied, they will be freed, even if an error occurs. */ static inline int i_ipmi_request(ipmi_user_t user, ipmi_smi_t intf, struct ipmi_addr *addr, long msgid, struct ipmi_msg *msg, void *supplied_smi, struct ipmi_recv_msg *supplied_recv, int priority, unsigned char source_address, unsigned char source_lun) { int rv = 0; struct ipmi_smi_msg *smi_msg; struct ipmi_recv_msg *recv_msg; unsigned long flags; if (supplied_recv) { recv_msg = supplied_recv; } else { recv_msg = ipmi_alloc_recv_msg(); if (recv_msg == NULL) { return -ENOMEM; } } if (supplied_smi) { smi_msg = (struct ipmi_smi_msg *) supplied_smi; } else { smi_msg = ipmi_alloc_smi_msg(); if (smi_msg == NULL) { ipmi_free_recv_msg(recv_msg); return -ENOMEM; } } if (addr->channel > IPMI_NUM_CHANNELS) { rv = -EINVAL; goto out_err; } recv_msg->user = user; recv_msg->msgid = msgid; /* Store the message to send in the receive message so timeout responses can get the proper response data. */ recv_msg->msg = *msg; if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) { struct ipmi_system_interface_addr *smi_addr; smi_addr = (struct ipmi_system_interface_addr *) addr; if (smi_addr->lun > 3) return -EINVAL; memcpy(&recv_msg->addr, smi_addr, sizeof(*smi_addr)); if ((msg->netfn == IPMI_NETFN_APP_REQUEST) && ((msg->cmd == IPMI_SEND_MSG_CMD) || (msg->cmd == IPMI_GET_MSG_CMD) || (msg->cmd == IPMI_READ_EVENT_MSG_BUFFER_CMD))) { /* We don't let the user do these, since we manage the sequence numbers. */ rv = -EINVAL; goto out_err; } if ((msg->data_len + 2) > IPMI_MAX_MSG_LENGTH) { rv = -EMSGSIZE; goto out_err; } smi_msg->data[0] = (msg->netfn << 2) | (smi_addr->lun & 0x3); smi_msg->data[1] = msg->cmd; smi_msg->msgid = msgid; smi_msg->user_data = recv_msg; if (msg->data_len > 0) memcpy(&(smi_msg->data[2]), msg->data, msg->data_len); smi_msg->data_size = msg->data_len + 2; } else if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE) || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) { struct ipmi_ipmb_addr *ipmb_addr; unsigned char ipmb_seq; long seqid; int broadcast; int retries; if (addr == NULL) { rv = -EINVAL; goto out_err; } if (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE) { /* Broadcasts add a zero at the beginning of the message, but otherwise is the same as an IPMB address. */ addr->addr_type = IPMI_IPMB_ADDR_TYPE; broadcast = 1; retries = 0; /* Don't retry broadcasts. */ } else { broadcast = 0; retries = 4; } /* 9 for the header and 1 for the checksum, plus possibly one for the broadcast. */ if ((msg->data_len + 10 + broadcast) > IPMI_MAX_MSG_LENGTH) { rv = -EMSGSIZE; goto out_err; } ipmb_addr = (struct ipmi_ipmb_addr *) addr; if (ipmb_addr->lun > 3) { rv = -EINVAL; goto out_err; } memcpy(&recv_msg->addr, ipmb_addr, sizeof(*ipmb_addr)); if (recv_msg->msg.netfn & 0x1) { /* It's a response, so use the user's sequence from msgid. */ format_ipmb_msg(smi_msg, msg, ipmb_addr, msgid, msgid, broadcast, source_address, source_lun); } else { /* It's a command, so get a sequence for it. */ spin_lock_irqsave(&(intf->seq_lock), flags); /* Create a sequence number with a 1 second timeout and 4 retries. */ /* FIXME - magic number for the timeout. */ rv = intf_next_seq(intf, recv_msg, 1000, retries, &ipmb_seq, &seqid); if (rv) { /* We have used up all the sequence numbers, probably, so abort. */ spin_unlock_irqrestore(&(intf->seq_lock), flags); goto out_err; } /* Store the sequence number in the message, so that when the send message response comes back we can start the timer. */ format_ipmb_msg(smi_msg, msg, ipmb_addr, STORE_SEQ_IN_MSGID(ipmb_seq, seqid), ipmb_seq, broadcast, source_address, source_lun); /* Copy the message into the recv message data, so we can retransmit it later if necessary. */ memcpy(recv_msg->msg_data, smi_msg->data, smi_msg->data_size); recv_msg->msg.data = recv_msg->msg_data; recv_msg->msg.data_len = smi_msg->data_size; /* We don't unlock until here, because we need to copy the completed message into the recv_msg before we release the lock. Otherwise, race conditions may bite us. I know that's pretty paranoid, but I prefer to be correct. */ spin_unlock_irqrestore(&(intf->seq_lock), flags); } } else { /* Unknown address type. */ rv = -EINVAL; goto out_err; } #if DEBUG_MSGING { int m; for (m=0; m<smi_msg->data_size; m++) printk(" %2.2x", smi_msg->data[m]); printk("\n"); } #endif intf->handlers->sender(intf->send_info, smi_msg, priority); return 0; out_err: ipmi_free_smi_msg(smi_msg); ipmi_free_recv_msg(recv_msg); return rv; } int ipmi_request(ipmi_user_t user, struct ipmi_addr *addr, long msgid, struct ipmi_msg *msg, int priority) { return i_ipmi_request(user, user->intf, addr, msgid, msg, NULL, NULL, priority, user->intf->my_address, user->intf->my_lun); } int ipmi_request_supply_msgs(ipmi_user_t user, struct ipmi_addr *addr, long msgid, struct ipmi_msg *msg, void *supplied_smi, struct ipmi_recv_msg *supplied_recv, int priority) { return i_ipmi_request(user, user->intf, addr, msgid, msg, supplied_smi, supplied_recv, priority, user->intf->my_address, user->intf->my_lun); } int ipmi_request_with_source(ipmi_user_t user, struct ipmi_addr *addr, long msgid, struct ipmi_msg *msg, int priority, unsigned char source_address, unsigned char source_lun) { return i_ipmi_request(user, user->intf, addr, msgid, msg, NULL, NULL, priority, source_address, source_lun); } int ipmi_register_smi(struct ipmi_smi_handlers *handlers, void *send_info, unsigned char version_major, unsigned char version_minor, ipmi_smi_t *intf) { int i, j; int rv; ipmi_smi_t new_intf; struct list_head *entry; unsigned long flags; /* Make sure the driver is actually initialized, this handles problems with initialization order. */ if (!initialized) { rv = ipmi_init_msghandler(); if (rv) return rv; /* The init code doesn't return an error if it was turned off, but it won't initialize. Check that. */ if (!initialized) return -ENODEV; } new_intf = kmalloc(sizeof(*new_intf), GFP_KERNEL); if (!new_intf) return -ENOMEM; rv = -ENOMEM; down_write(&interfaces_sem); for (i=0; i<MAX_IPMI_INTERFACES; i++) { if (ipmi_interfaces[i] == NULL) { new_intf->version_major = version_major; new_intf->version_minor = version_minor; new_intf->my_address = IPMI_BMC_SLAVE_ADDR; new_intf->my_lun = 2; /* the SMS LUN. */ rwlock_init(&(new_intf->users_lock)); INIT_LIST_HEAD(&(new_intf->users)); new_intf->handlers = handlers; new_intf->send_info = send_info; spin_lock_init(&(new_intf->seq_lock)); for (j=0; j<IPMI_IPMB_NUM_SEQ; j++) { new_intf->seq_table[j].inuse = 0; new_intf->seq_table[j].seqid = 0; } new_intf->curr_seq = 0; spin_lock_init(&(new_intf->waiting_msgs_lock)); INIT_LIST_HEAD(&(new_intf->waiting_msgs)); spin_lock_init(&(new_intf->events_lock)); INIT_LIST_HEAD(&(new_intf->waiting_events)); new_intf->waiting_events_count = 0; rwlock_init(&(new_intf->cmd_rcvr_lock)); INIT_LIST_HEAD(&(new_intf->cmd_rcvrs)); new_intf->all_cmd_rcvr = NULL; spin_lock_irqsave(&interfaces_lock, flags); ipmi_interfaces[i] = new_intf; spin_unlock_irqrestore(&interfaces_lock, flags); rv = 0; *intf = new_intf; break; } } /* We convert to a read semaphore here. It's possible the interface was removed between the calls, we have to recheck afterwards. */ up_write(&interfaces_sem); down_read(&interfaces_sem); if (ipmi_interfaces[i] != new_intf) /* Well, it went away. Just return. */ goto out; if (rv == 0) { /* Call all the watcher interfaces to tell them that a new interface is available. */ down_read(&smi_watchers_sem); list_for_each(entry, &smi_watchers) { struct ipmi_smi_watcher *w; w = list_entry(entry, struct ipmi_smi_watcher, link); w->new_smi(i); } up_read(&smi_watchers_sem); } out: up_read(&interfaces_sem); if (rv) kfree(new_intf); return rv; } static void free_recv_msg_list(struct list_head *q) { struct list_head *entry, *entry2; struct ipmi_recv_msg *msg; list_for_each_safe(entry, entry2, q) { msg = list_entry(entry, struct ipmi_recv_msg, link); list_del(entry); ipmi_free_recv_msg(msg); } } static void free_cmd_rcvr_list(struct list_head *q) { struct list_head *entry, *entry2; struct cmd_rcvr *rcvr; list_for_each_safe(entry, entry2, q) { rcvr = list_entry(entry, struct cmd_rcvr, link); list_del(entry); kfree(rcvr); } } static void clean_up_interface_data(ipmi_smi_t intf) { int i; free_recv_msg_list(&(intf->waiting_msgs)); free_recv_msg_list(&(intf->waiting_events)); free_cmd_rcvr_list(&(intf->cmd_rcvrs)); for (i=0; i<IPMI_IPMB_NUM_SEQ; i++) { if ((intf->seq_table[i].inuse) && (intf->seq_table[i].recv_msg)) { ipmi_free_recv_msg(intf->seq_table[i].recv_msg); } } } int ipmi_unregister_smi(ipmi_smi_t intf) { int rv = -ENODEV; int i; struct list_head *entry; unsigned long flags; down_write(&interfaces_sem); if (list_empty(&(intf->users))) { for (i=0; i<MAX_IPMI_INTERFACES; i++) { if (ipmi_interfaces[i] == intf) { spin_lock_irqsave(&interfaces_lock, flags); ipmi_interfaces[i] = NULL; clean_up_interface_data(intf); spin_unlock_irqrestore(&interfaces_lock,flags); kfree(intf); rv = 0; goto out_call_watcher; } } } else { rv = -EBUSY; } up_write(&interfaces_sem); return rv; out_call_watcher: /* Convert to a read semaphore so callbacks don't bite us. */ up_write(&interfaces_sem); down_read(&interfaces_sem); /* Call all the watcher interfaces to tell them that an interface is gone. */ down_read(&smi_watchers_sem); list_for_each(entry, &smi_watchers) { struct ipmi_smi_watcher *w; w = list_entry(entry, struct ipmi_smi_watcher, link); w->smi_gone(i); } up_read(&smi_watchers_sem); up_read(&interfaces_sem); return 0; } static int handle_get_msg_rsp(ipmi_smi_t intf, struct ipmi_smi_msg *msg) { struct ipmi_ipmb_addr ipmb_addr; struct ipmi_recv_msg *recv_msg; if (msg->rsp_size < 11) /* Message not big enough, just ignore it. */ return 0; if (msg->rsp[2] != 0) /* An error getting the response, just ignore it. */ return 0; ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE; ipmb_addr.slave_addr = msg->rsp[6]; ipmb_addr.channel = msg->rsp[3] & 0x0f; ipmb_addr.lun = msg->rsp[7] & 3; /* It's a response from a remote entity. Look up the sequence number and handle the response. */ if (intf_find_seq(intf, msg->rsp[7] >> 2, msg->rsp[3] & 0x0f, msg->rsp[8], (msg->rsp[4] >> 2) & (~1), (struct ipmi_addr *) &(ipmb_addr), &recv_msg)) { /* We were unable to find the sequence number, so just nuke the message. */ return 0; } memcpy(recv_msg->msg_data, &(msg->rsp[9]), msg->rsp_size - 9); /* THe other fields matched, so no need to set them, except for netfn, which needs to be the response that was returned, not the request value. */ recv_msg->msg.netfn = msg->rsp[4] >> 2; recv_msg->msg.data = recv_msg->msg_data; recv_msg->msg.data_len = msg->rsp_size - 10; recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE; deliver_response(recv_msg); return 0; } static int handle_get_msg_cmd(ipmi_smi_t intf, struct ipmi_smi_msg *msg) { struct list_head *entry; struct cmd_rcvr *rcvr; int rv = 0; unsigned char netfn; unsigned char cmd; ipmi_user_t user = NULL; struct ipmi_ipmb_addr *ipmb_addr; struct ipmi_recv_msg *recv_msg; if (msg->rsp_size < 10) /* Message not big enough, just ignore it. */ return 0; if (msg->rsp[2] != 0) { /* An error getting the response, just ignore it. */ return 0; } netfn = msg->rsp[4] >> 2; cmd = msg->rsp[8]; read_lock(&(intf->cmd_rcvr_lock)); if (intf->all_cmd_rcvr) { user = intf->all_cmd_rcvr; } else { /* Find the command/netfn. */ list_for_each(entry, &(intf->cmd_rcvrs)) { rcvr = list_entry(entry, struct cmd_rcvr, link); if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)) { user = rcvr->user; break; } } } read_unlock(&(intf->cmd_rcvr_lock)); if (user == NULL) { /* We didn't find a user, deliver an error response. */ msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); msg->data[1] = IPMI_SEND_MSG_CMD; msg->data[2] = msg->rsp[3]; msg->data[3] = msg->rsp[6]; msg->data[4] = ((netfn + 1) << 2) | (msg->rsp[7] & 0x3); msg->data[5] = ipmb_checksum(&(msg->data[3]), 2); msg->data[6] = intf->my_address; /* rqseq/lun */ msg->data[7] = (msg->rsp[7] & 0xfc) | (msg->rsp[4] & 0x3); msg->data[8] = msg->rsp[8]; /* cmd */ msg->data[9] = IPMI_INVALID_CMD_COMPLETION_CODE; msg->data[10] = ipmb_checksum(&(msg->data[6]), 4); msg->data_size = 11; intf->handlers->sender(intf->send_info, msg, 0); rv = -1; /* We used the message, so return the value that causes it to not be freed or queued. */ } else { /* Deliver the message to the user. */ recv_msg = ipmi_alloc_recv_msg(); if (! recv_msg) { /* We couldn't allocate memory for the message, so requeue it for handling later. */ rv = 1; } else { ipmb_addr = (struct ipmi_ipmb_addr *) &recv_msg->addr; ipmb_addr->addr_type = IPMI_IPMB_ADDR_TYPE; ipmb_addr->slave_addr = msg->rsp[6]; ipmb_addr->lun = msg->rsp[7] & 3; ipmb_addr->channel = msg->rsp[3]; recv_msg->user = user; recv_msg->recv_type = IPMI_CMD_RECV_TYPE; recv_msg->msgid = msg->rsp[7] >> 2; recv_msg->msg.netfn = msg->rsp[4] >> 2; recv_msg->msg.cmd = msg->rsp[8]; recv_msg->msg.data = recv_msg->msg_data; recv_msg->msg.data_len = msg->rsp_size - 10; memcpy(recv_msg->msg_data, &(msg->rsp[9]), msg->rsp_size - 10); deliver_response(recv_msg); } } return rv; } static void copy_event_into_recv_msg(struct ipmi_recv_msg *recv_msg, struct ipmi_smi_msg *msg) { struct ipmi_system_interface_addr *smi_addr; recv_msg->msgid = 0; smi_addr = (struct ipmi_system_interface_addr *) &(recv_msg->addr); smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; smi_addr->channel = IPMI_BMC_CHANNEL; smi_addr->lun = msg->rsp[0] & 3; recv_msg->recv_type = IPMI_ASYNC_EVENT_RECV_TYPE; recv_msg->msg.netfn = msg->rsp[0] >> 2; recv_msg->msg.cmd = msg->rsp[1]; memcpy(recv_msg->msg_data, &(msg->rsp[3]), msg->rsp_size - 3); recv_msg->msg.data = recv_msg->msg_data; recv_msg->msg.data_len = msg->rsp_size - 3; } /* This will be called with the intf->users_lock read-locked, so no need to do that here. */ static int handle_read_event_rsp(ipmi_smi_t intf, struct ipmi_smi_msg *msg) { struct ipmi_recv_msg *recv_msg; struct list_head msgs; struct list_head *entry, *entry2; ipmi_user_t user; int rv = 0; int deliver_count = 0; unsigned long flags; if (msg->rsp_size < 19) { /* Message is too small to be an IPMB event. */ return 0; } if (msg->rsp[2] != 0) { /* An error getting the event, just ignore it. */ return 0; } INIT_LIST_HEAD(&msgs); spin_lock_irqsave(&(intf->events_lock), flags); /* Allocate and fill in one message for every user that is getting events. */ list_for_each(entry, &(intf->users)) { user = list_entry(entry, struct ipmi_user, link); if (! user->gets_events) continue; recv_msg = ipmi_alloc_recv_msg(); if (! recv_msg) { list_for_each_safe(entry, entry2, &msgs) { recv_msg = list_entry(entry, struct ipmi_recv_msg, link); list_del(entry); ipmi_free_recv_msg(recv_msg); } /* We couldn't allocate memory for the message, so requeue it for handling later. */ rv = 1; goto out; } deliver_count++; copy_event_into_recv_msg(recv_msg, msg); recv_msg->user = user; list_add_tail(&(recv_msg->link), &msgs); } if (deliver_count) { /* Now deliver all the messages. */ list_for_each_safe(entry, entry2, &msgs) { recv_msg = list_entry(entry, struct ipmi_recv_msg, link); list_del(entry); deliver_response(recv_msg); } } else if (intf->waiting_events_count < MAX_EVENTS_IN_QUEUE) { /* No one to receive the message, put it in queue if there's not already too many things in the queue. */ recv_msg = ipmi_alloc_recv_msg(); if (! recv_msg) { /* We couldn't allocate memory for the message, so requeue it for handling later. */ rv = 1; goto out; } copy_event_into_recv_msg(recv_msg, msg); list_add_tail(&(recv_msg->link), &(intf->waiting_events)); } else { /* There's too many things in the queue, discard this message. */ printk(KERN_WARNING "ipmi: Event queue full, discarding an" " incoming event\n"); } out: spin_unlock_irqrestore(&(intf->events_lock), flags); return rv; } static int handle_bmc_rsp(ipmi_smi_t intf, struct ipmi_smi_msg *msg) { struct ipmi_recv_msg *recv_msg; int found = 0; struct list_head *entry; recv_msg = (struct ipmi_recv_msg *) msg->user_data; /* Make sure the user still exists. */ list_for_each(entry, &(intf->users)) { if (list_entry(entry, struct ipmi_user, link) == recv_msg->user) { /* Found it, so we can deliver it */ found = 1; break; } } if (!found) { /* The user for the message went away, so give up. */ ipmi_free_recv_msg(recv_msg); } else { struct ipmi_system_interface_addr *smi_addr; recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE; recv_msg->msgid = msg->msgid; smi_addr = ((struct ipmi_system_interface_addr *) &(recv_msg->addr)); smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; smi_addr->channel = IPMI_BMC_CHANNEL; smi_addr->lun = msg->rsp[0] & 3; recv_msg->msg.netfn = msg->rsp[0] >> 2; recv_msg->msg.cmd = msg->rsp[1]; memcpy(recv_msg->msg_data, &(msg->rsp[2]), msg->rsp_size - 2); recv_msg->msg.data = recv_msg->msg_data; recv_msg->msg.data_len = msg->rsp_size - 2; deliver_response(recv_msg); } return 0; } /* Handle a new message. Return 1 if the message should be requeued, 0 if the message should be freed, or -1 if the message should not be freed or requeued. */ static int handle_new_recv_msg(ipmi_smi_t intf, struct ipmi_smi_msg *msg) { int requeue; if (msg->rsp_size < 2) { /* Message is too small to be correct. */ requeue = 0; } else if (msg->rsp[1] == IPMI_GET_MSG_CMD) { #if DEBUG_MSGING int m; printk("Response:"); for (m=0; m<msg->rsp_size; m++) printk(" %2.2x", msg->rsp[m]); printk("\n"); #endif /* It's from the receive queue. */ if (msg->rsp[4] & 0x04) { /* It's a response, so find the requesting message and send it up. */ requeue = handle_get_msg_rsp(intf, msg); } else { /* It's a command to the SMS from some other entity. Handle that. */ requeue = handle_get_msg_cmd(intf, msg); } } else if (msg->rsp[1] == IPMI_READ_EVENT_MSG_BUFFER_CMD) { /* It's an asyncronous event. */ requeue = handle_read_event_rsp(intf, msg); } else { /* It's a response from the local BMC. */ requeue = handle_bmc_rsp(intf, msg); } return requeue; } /* Handle a new message from the lower layer. */ void ipmi_smi_msg_received(ipmi_smi_t intf, struct ipmi_smi_msg *msg) { unsigned long flags; int rv; /* Lock the user lock so the user can't go away while we are working on it. */ read_lock(&(intf->users_lock)); if ((msg->data_size >= 2) && (msg->data[1] == IPMI_SEND_MSG_CMD)) { /* This is the local response to a send, start the timer for these. */ intf_start_seq_timer(intf, msg->msgid); ipmi_free_smi_msg(msg); goto out_unlock; } /* To preserve message order, if the list is not empty, we tack this message onto the end of the list. */ spin_lock_irqsave(&(intf->waiting_msgs_lock), flags); if (!list_empty(&(intf->waiting_msgs))) { list_add_tail(&(msg->link), &(intf->waiting_msgs)); spin_unlock(&(intf->waiting_msgs_lock)); goto out_unlock; } spin_unlock_irqrestore(&(intf->waiting_msgs_lock), flags); rv = handle_new_recv_msg(intf, msg); if (rv > 0) { /* Could not handle the message now, just add it to a list to handle later. */ spin_lock(&(intf->waiting_msgs_lock)); list_add_tail(&(msg->link), &(intf->waiting_msgs)); spin_unlock(&(intf->waiting_msgs_lock)); } else if (rv == 0) { ipmi_free_smi_msg(msg); } out_unlock: read_unlock(&(intf->users_lock)); } void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf) { struct list_head *entry; ipmi_user_t user; read_lock(&(intf->users_lock)); list_for_each(entry, &(intf->users)) { user = list_entry(entry, struct ipmi_user, link); if (! user->handler->ipmi_watchdog_pretimeout) continue; user->handler->ipmi_watchdog_pretimeout(user->handler_data); } read_unlock(&(intf->users_lock)); } static void handle_msg_timeout(struct ipmi_recv_msg *msg) { msg->recv_type = IPMI_RESPONSE_RECV_TYPE; msg->msg_data[0] = IPMI_TIMEOUT_COMPLETION_CODE; msg->msg.netfn |= 1; /* Convert to a response. */ msg->msg.data_len = 1; msg->msg.data = msg->msg_data; deliver_response(msg); } static void send_from_recv_msg(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg, struct ipmi_smi_msg *smi_msg, unsigned char seq, long seqid) { if (!smi_msg) smi_msg = ipmi_alloc_smi_msg(); if (!smi_msg) /* If we can't allocate the message, then just return, we get 4 retries, so this should be ok. */ return; memcpy(smi_msg->data, recv_msg->msg.data, recv_msg->msg.data_len); smi_msg->data_size = recv_msg->msg.data_len; smi_msg->msgid = STORE_SEQ_IN_MSGID(seq, seqid); /* Send the new message. We send with a zero priority. It timed out, I doubt time is that critical now, and high priority messages are really only for messages to the local MC, which don't get resent. */ intf->handlers->sender(intf->send_info, smi_msg, 0); #if DEBUG_MSGING { int m; printk("Resend: "); for (m=0; m<smi_msg->data_size; m++) printk(" %2.2x", smi_msg->data[m]); printk("\n"); } #endif } static void ipmi_timeout_handler(long timeout_period) { ipmi_smi_t intf; struct list_head timeouts; struct ipmi_recv_msg *msg; struct ipmi_smi_msg *smi_msg; unsigned long flags; struct list_head *entry, *entry2; int i, j; INIT_LIST_HEAD(&timeouts); spin_lock(&interfaces_lock); for (i=0; i<MAX_IPMI_INTERFACES; i++) { intf = ipmi_interfaces[i]; if (intf == NULL) continue; read_lock(&(intf->users_lock)); /* See if any waiting messages need to be processed. */ spin_lock_irqsave(&(intf->waiting_msgs_lock), flags); list_for_each_safe(entry, entry2, &(intf->waiting_msgs)) { smi_msg = list_entry(entry, struct ipmi_smi_msg, link); if (! handle_new_recv_msg(intf, smi_msg)) { list_del(entry); ipmi_free_smi_msg(smi_msg); } else { /* To preserve message order, quit if we can't handle a message. */ break; } } spin_unlock_irqrestore(&(intf->waiting_msgs_lock), flags); /* Go through the seq table and find any messages that have timed out, putting them in the timeouts list. */ spin_lock_irqsave(&(intf->seq_lock), flags); for (j=0; j<IPMI_IPMB_NUM_SEQ; j++) { struct seq_table *ent = &(intf->seq_table[j]); if (!ent->inuse) continue; ent->timeout -= timeout_period; if (ent->timeout > 0) continue; if (ent->retries_left == 0) { /* The message has used all its retries. */ ent->inuse = 0; msg = ent->recv_msg; list_add_tail(&(msg->link), &timeouts); } else { /* More retries, send again. */ /* Start with the max timer, set to normal timer after the message is sent. */ ent->timeout = MAX_MSG_TIMEOUT; ent->retries_left--; send_from_recv_msg(intf, ent->recv_msg, NULL, j, ent->seqid); } } spin_unlock_irqrestore(&(intf->seq_lock), flags); list_for_each_safe(entry, entry2, &timeouts) { msg = list_entry(entry, struct ipmi_recv_msg, link); handle_msg_timeout(msg); } read_unlock(&(intf->users_lock)); } spin_unlock(&interfaces_lock); } static void ipmi_request_event(void) { ipmi_smi_t intf; int i; spin_lock(&interfaces_lock); for (i=0; i<MAX_IPMI_INTERFACES; i++) { intf = ipmi_interfaces[i]; if (intf == NULL) continue; intf->handlers->request_events(intf->send_info); } spin_unlock(&interfaces_lock); } static struct timer_list ipmi_timer; /* Call every 100 ms. */ #define IPMI_TIMEOUT_TIME 100 #define IPMI_TIMEOUT_JIFFIES (IPMI_TIMEOUT_TIME/(1000/HZ)) /* Request events from the queue every second. Hopefully, in the future, IPMI will add a way to know immediately if an event is in the queue. */ #define IPMI_REQUEST_EV_TIME (1000 / (IPMI_TIMEOUT_TIME)) static volatile int stop_operation = 0; static volatile int timer_stopped = 0; static unsigned int ticks_to_req_ev = IPMI_REQUEST_EV_TIME; static void ipmi_timeout(unsigned long data) { if (stop_operation) { timer_stopped = 1; return; } ticks_to_req_ev--; if (ticks_to_req_ev == 0) { ipmi_request_event(); ticks_to_req_ev = IPMI_REQUEST_EV_TIME; } ipmi_timeout_handler(IPMI_TIMEOUT_TIME); ipmi_timer.expires += IPMI_TIMEOUT_JIFFIES; add_timer(&ipmi_timer); } 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); kfree(msg); } struct ipmi_smi_msg *ipmi_alloc_smi_msg(void) { struct ipmi_smi_msg *rv; rv = kmalloc(sizeof(struct ipmi_smi_msg), GFP_ATOMIC); if (rv) { rv->done = free_smi_msg; atomic_inc(&smi_msg_inuse_count); } return rv; } static void free_recv_msg(struct ipmi_recv_msg *msg) { atomic_dec(&recv_msg_inuse_count); kfree(msg); } struct ipmi_recv_msg *ipmi_alloc_recv_msg(void) { struct ipmi_recv_msg *rv; rv = kmalloc(sizeof(struct ipmi_recv_msg), GFP_ATOMIC); if (rv) { rv->done = free_recv_msg; atomic_inc(&recv_msg_inuse_count); } return rv; } #ifdef CONFIG_IPMI_PANIC_EVENT static void dummy_smi_done_handler(struct ipmi_smi_msg *msg) { } static void dummy_recv_done_handler(struct ipmi_recv_msg *msg) { } static void send_panic_events(void) { struct ipmi_msg msg; ipmi_smi_t intf; unsigned char data[8]; int i; struct ipmi_system_interface_addr addr; struct ipmi_smi_msg smi_msg; struct ipmi_recv_msg recv_msg; addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; addr.channel = IPMI_BMC_CHANNEL; /* Fill in an event telling that we have failed. */ msg.netfn = 0x04; /* Sensor or Event. */ msg.cmd = 2; /* Platform event command. */ msg.data = data; msg.data_len = 8; data[0] = 0x21; /* Kernel generator ID, IPMI table 5-4 */ data[1] = 0x03; /* This is for IPMI 1.0. */ data[2] = 0x20; /* OS Critical Stop, IPMI table 36-3 */ data[4] = 0x6f; /* Sensor specific, IPMI table 36-1 */ data[5] = 0xa1; /* Runtime stop OEM bytes 2 & 3. */ /* These used to have the first three bytes of the panic string, but not only is that not terribly useful, it's not available any more. */ data[3] = 0; data[6] = 0; data[7] = 0; smi_msg.done = dummy_smi_done_handler; recv_msg.done = dummy_recv_done_handler; /* For every registered interface, send the event. */ for (i=0; i<MAX_IPMI_INTERFACES; i++) { intf = ipmi_interfaces[i]; if (intf == NULL) continue; intf->handlers->set_run_to_completion(intf->send_info, 1); i_ipmi_request(NULL, intf, (struct ipmi_addr *) &addr, 0, &msg, &smi_msg, &recv_msg, 0, intf->my_address, intf->my_lun); } } #endif /* CONFIG_IPMI_PANIC_EVENT */ static int has_paniced = 0; static int panic_event(struct notifier_block *this, unsigned long event, void *ptr) { int i; ipmi_smi_t intf; if (has_paniced) return NOTIFY_DONE; has_paniced = 1; /* For every registered interface, set it to run to completion. */ for (i=0; i<MAX_IPMI_INTERFACES; i++) { intf = ipmi_interfaces[i]; if (intf == NULL) continue; intf->handlers->set_run_to_completion(intf->send_info, 1); } #ifdef CONFIG_IPMI_PANIC_EVENT send_panic_events(); #endif return NOTIFY_DONE; } static struct notifier_block panic_block = { panic_event, NULL, 200 /* priority: INT_MAX >= x >= 0 */ }; static __init int ipmi_init_msghandler(void) { int i; if (initialized) return 0; for (i=0; i<MAX_IPMI_INTERFACES; i++) { ipmi_interfaces[i] = NULL; } init_timer(&ipmi_timer); ipmi_timer.data = 0; ipmi_timer.function = ipmi_timeout; ipmi_timer.expires = jiffies + IPMI_TIMEOUT_JIFFIES; add_timer(&ipmi_timer); notifier_chain_register(&panic_notifier_list, &panic_block); initialized = 1; printk(KERN_INFO "ipmi: message handler initialized\n"); return 0; } static __exit void cleanup_ipmi(void) { int count; if (!initialized) return; notifier_chain_unregister(&panic_notifier_list, &panic_block); /* This can't be called if any interfaces exist, so no worry about shutting down the interfaces. */ /* Tell the timer to stop, then wait for it to stop. This avoids problems with race conditions removing the timer here. */ stop_operation = 1; while (!timer_stopped) { schedule_timeout(1); } initialized = 0; /* Check for buffer leaks. */ count = atomic_read(&smi_msg_inuse_count); if (count != 0) printk("ipmi_msghandler: SMI message count %d at exit\n", count); count = atomic_read(&recv_msg_inuse_count); if (count != 0) printk("ipmi_msghandler: recv message count %d at exit\n", count); } module_exit(cleanup_ipmi); module_init(ipmi_init_msghandler); MODULE_LICENSE("GPL"); EXPORT_SYMBOL(ipmi_alloc_recv_msg); EXPORT_SYMBOL(ipmi_create_user); EXPORT_SYMBOL(ipmi_destroy_user); EXPORT_SYMBOL(ipmi_get_version); EXPORT_SYMBOL(ipmi_request); EXPORT_SYMBOL(ipmi_request_supply_msgs); EXPORT_SYMBOL(ipmi_request_with_source); EXPORT_SYMBOL(ipmi_register_smi); EXPORT_SYMBOL(ipmi_unregister_smi); EXPORT_SYMBOL(ipmi_register_for_cmd); EXPORT_SYMBOL(ipmi_unregister_for_cmd); EXPORT_SYMBOL(ipmi_smi_msg_received); EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout); EXPORT_SYMBOL(ipmi_alloc_smi_msg); EXPORT_SYMBOL(ipmi_register_all_cmd_rcvr); EXPORT_SYMBOL(ipmi_unregister_all_cmd_rcvr); EXPORT_SYMBOL(ipmi_addr_length); EXPORT_SYMBOL(ipmi_validate_addr); EXPORT_SYMBOL(ipmi_set_gets_events); EXPORT_SYMBOL(ipmi_addr_equal); EXPORT_SYMBOL(ipmi_smi_watcher_register); EXPORT_SYMBOL(ipmi_smi_watcher_unregister); EXPORT_SYMBOL(ipmi_set_my_address); EXPORT_SYMBOL(ipmi_get_my_address); EXPORT_SYMBOL(ipmi_set_my_LUN); EXPORT_SYMBOL(ipmi_get_my_LUN);