1 /* 2 * ipmi_msghandler.c 3 * 4 * Incoming and outgoing message routing for an IPMI interface. 5 * 6 * Author: MontaVista Software, Inc. 7 * Corey Minyard <minyard@mvista.com> 8 * source@mvista.com 9 * 10 * Copyright 2002 MontaVista Software Inc. 11 * 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License as published by the 14 * Free Software Foundation; either version 2 of the License, or (at your 15 * option) any later version. 16 * 17 * 18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 26 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 27 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 * 29 * You should have received a copy of the GNU General Public License along 30 * with this program; if not, write to the Free Software Foundation, Inc., 31 * 675 Mass Ave, Cambridge, MA 02139, USA. 32 */ 33 34 #include <linux/module.h> 35 #include <linux/errno.h> 36 #include <asm/system.h> 37 #include <linux/poll.h> 38 #include <linux/sched.h> 39 #include <linux/spinlock.h> 40 #include <linux/mutex.h> 41 #include <linux/slab.h> 42 #include <linux/ipmi.h> 43 #include <linux/ipmi_smi.h> 44 #include <linux/notifier.h> 45 #include <linux/init.h> 46 #include <linux/proc_fs.h> 47 #include <linux/rcupdate.h> 48 49 #define PFX "IPMI message handler: " 50 51 #define IPMI_DRIVER_VERSION "39.2" 52 53 static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void); 54 static int ipmi_init_msghandler(void); 55 56 static int initialized; 57 58 #ifdef CONFIG_PROC_FS 59 static struct proc_dir_entry *proc_ipmi_root; 60 #endif /* CONFIG_PROC_FS */ 61 62 /* Remain in auto-maintenance mode for this amount of time (in ms). */ 63 #define IPMI_MAINTENANCE_MODE_TIMEOUT 30000 64 65 #define MAX_EVENTS_IN_QUEUE 25 66 67 /* 68 * Don't let a message sit in a queue forever, always time it with at lest 69 * the max message timer. This is in milliseconds. 70 */ 71 #define MAX_MSG_TIMEOUT 60000 72 73 /* 74 * The main "user" data structure. 75 */ 76 struct ipmi_user { 77 struct list_head link; 78 79 /* Set to "0" when the user is destroyed. */ 80 int valid; 81 82 struct kref refcount; 83 84 /* The upper layer that handles receive messages. */ 85 struct ipmi_user_hndl *handler; 86 void *handler_data; 87 88 /* The interface this user is bound to. */ 89 ipmi_smi_t intf; 90 91 /* Does this interface receive IPMI events? */ 92 int gets_events; 93 }; 94 95 struct cmd_rcvr { 96 struct list_head link; 97 98 ipmi_user_t user; 99 unsigned char netfn; 100 unsigned char cmd; 101 unsigned int chans; 102 103 /* 104 * This is used to form a linked lised during mass deletion. 105 * Since this is in an RCU list, we cannot use the link above 106 * or change any data until the RCU period completes. So we 107 * use this next variable during mass deletion so we can have 108 * a list and don't have to wait and restart the search on 109 * every individual deletion of a command. 110 */ 111 struct cmd_rcvr *next; 112 }; 113 114 struct seq_table { 115 unsigned int inuse : 1; 116 unsigned int broadcast : 1; 117 118 unsigned long timeout; 119 unsigned long orig_timeout; 120 unsigned int retries_left; 121 122 /* 123 * To verify on an incoming send message response that this is 124 * the message that the response is for, we keep a sequence id 125 * and increment it every time we send a message. 126 */ 127 long seqid; 128 129 /* 130 * This is held so we can properly respond to the message on a 131 * timeout, and it is used to hold the temporary data for 132 * retransmission, too. 133 */ 134 struct ipmi_recv_msg *recv_msg; 135 }; 136 137 /* 138 * Store the information in a msgid (long) to allow us to find a 139 * sequence table entry from the msgid. 140 */ 141 #define STORE_SEQ_IN_MSGID(seq, seqid) (((seq&0xff)<<26) | (seqid&0x3ffffff)) 142 143 #define GET_SEQ_FROM_MSGID(msgid, seq, seqid) \ 144 do { \ 145 seq = ((msgid >> 26) & 0x3f); \ 146 seqid = (msgid & 0x3fffff); \ 147 } while (0) 148 149 #define NEXT_SEQID(seqid) (((seqid) + 1) & 0x3fffff) 150 151 struct ipmi_channel { 152 unsigned char medium; 153 unsigned char protocol; 154 155 /* 156 * My slave address. This is initialized to IPMI_BMC_SLAVE_ADDR, 157 * but may be changed by the user. 158 */ 159 unsigned char address; 160 161 /* 162 * My LUN. This should generally stay the SMS LUN, but just in 163 * case... 164 */ 165 unsigned char lun; 166 }; 167 168 #ifdef CONFIG_PROC_FS 169 struct ipmi_proc_entry { 170 char *name; 171 struct ipmi_proc_entry *next; 172 }; 173 #endif 174 175 struct bmc_device { 176 struct platform_device *dev; 177 struct ipmi_device_id id; 178 unsigned char guid[16]; 179 int guid_set; 180 181 struct kref refcount; 182 183 /* bmc device attributes */ 184 struct device_attribute device_id_attr; 185 struct device_attribute provides_dev_sdrs_attr; 186 struct device_attribute revision_attr; 187 struct device_attribute firmware_rev_attr; 188 struct device_attribute version_attr; 189 struct device_attribute add_dev_support_attr; 190 struct device_attribute manufacturer_id_attr; 191 struct device_attribute product_id_attr; 192 struct device_attribute guid_attr; 193 struct device_attribute aux_firmware_rev_attr; 194 }; 195 196 /* 197 * Various statistics for IPMI, these index stats[] in the ipmi_smi 198 * structure. 199 */ 200 enum ipmi_stat_indexes { 201 /* Commands we got from the user that were invalid. */ 202 IPMI_STAT_sent_invalid_commands = 0, 203 204 /* Commands we sent to the MC. */ 205 IPMI_STAT_sent_local_commands, 206 207 /* Responses from the MC that were delivered to a user. */ 208 IPMI_STAT_handled_local_responses, 209 210 /* Responses from the MC that were not delivered to a user. */ 211 IPMI_STAT_unhandled_local_responses, 212 213 /* Commands we sent out to the IPMB bus. */ 214 IPMI_STAT_sent_ipmb_commands, 215 216 /* Commands sent on the IPMB that had errors on the SEND CMD */ 217 IPMI_STAT_sent_ipmb_command_errs, 218 219 /* Each retransmit increments this count. */ 220 IPMI_STAT_retransmitted_ipmb_commands, 221 222 /* 223 * When a message times out (runs out of retransmits) this is 224 * incremented. 225 */ 226 IPMI_STAT_timed_out_ipmb_commands, 227 228 /* 229 * This is like above, but for broadcasts. Broadcasts are 230 * *not* included in the above count (they are expected to 231 * time out). 232 */ 233 IPMI_STAT_timed_out_ipmb_broadcasts, 234 235 /* Responses I have sent to the IPMB bus. */ 236 IPMI_STAT_sent_ipmb_responses, 237 238 /* The response was delivered to the user. */ 239 IPMI_STAT_handled_ipmb_responses, 240 241 /* The response had invalid data in it. */ 242 IPMI_STAT_invalid_ipmb_responses, 243 244 /* The response didn't have anyone waiting for it. */ 245 IPMI_STAT_unhandled_ipmb_responses, 246 247 /* Commands we sent out to the IPMB bus. */ 248 IPMI_STAT_sent_lan_commands, 249 250 /* Commands sent on the IPMB that had errors on the SEND CMD */ 251 IPMI_STAT_sent_lan_command_errs, 252 253 /* Each retransmit increments this count. */ 254 IPMI_STAT_retransmitted_lan_commands, 255 256 /* 257 * When a message times out (runs out of retransmits) this is 258 * incremented. 259 */ 260 IPMI_STAT_timed_out_lan_commands, 261 262 /* Responses I have sent to the IPMB bus. */ 263 IPMI_STAT_sent_lan_responses, 264 265 /* The response was delivered to the user. */ 266 IPMI_STAT_handled_lan_responses, 267 268 /* The response had invalid data in it. */ 269 IPMI_STAT_invalid_lan_responses, 270 271 /* The response didn't have anyone waiting for it. */ 272 IPMI_STAT_unhandled_lan_responses, 273 274 /* The command was delivered to the user. */ 275 IPMI_STAT_handled_commands, 276 277 /* The command had invalid data in it. */ 278 IPMI_STAT_invalid_commands, 279 280 /* The command didn't have anyone waiting for it. */ 281 IPMI_STAT_unhandled_commands, 282 283 /* Invalid data in an event. */ 284 IPMI_STAT_invalid_events, 285 286 /* Events that were received with the proper format. */ 287 IPMI_STAT_events, 288 289 /* Retransmissions on IPMB that failed. */ 290 IPMI_STAT_dropped_rexmit_ipmb_commands, 291 292 /* Retransmissions on LAN that failed. */ 293 IPMI_STAT_dropped_rexmit_lan_commands, 294 295 /* This *must* remain last, add new values above this. */ 296 IPMI_NUM_STATS 297 }; 298 299 300 #define IPMI_IPMB_NUM_SEQ 64 301 #define IPMI_MAX_CHANNELS 16 302 struct ipmi_smi { 303 /* What interface number are we? */ 304 int intf_num; 305 306 struct kref refcount; 307 308 /* Used for a list of interfaces. */ 309 struct list_head link; 310 311 /* 312 * The list of upper layers that are using me. seq_lock 313 * protects this. 314 */ 315 struct list_head users; 316 317 /* Information to supply to users. */ 318 unsigned char ipmi_version_major; 319 unsigned char ipmi_version_minor; 320 321 /* Used for wake ups at startup. */ 322 wait_queue_head_t waitq; 323 324 struct bmc_device *bmc; 325 char *my_dev_name; 326 char *sysfs_name; 327 328 /* 329 * This is the lower-layer's sender routine. Note that you 330 * must either be holding the ipmi_interfaces_mutex or be in 331 * an umpreemptible region to use this. You must fetch the 332 * value into a local variable and make sure it is not NULL. 333 */ 334 struct ipmi_smi_handlers *handlers; 335 void *send_info; 336 337 #ifdef CONFIG_PROC_FS 338 /* A list of proc entries for this interface. */ 339 struct mutex proc_entry_lock; 340 struct ipmi_proc_entry *proc_entries; 341 #endif 342 343 /* Driver-model device for the system interface. */ 344 struct device *si_dev; 345 346 /* 347 * A table of sequence numbers for this interface. We use the 348 * sequence numbers for IPMB messages that go out of the 349 * interface to match them up with their responses. A routine 350 * is called periodically to time the items in this list. 351 */ 352 spinlock_t seq_lock; 353 struct seq_table seq_table[IPMI_IPMB_NUM_SEQ]; 354 int curr_seq; 355 356 /* 357 * Messages that were delayed for some reason (out of memory, 358 * for instance), will go in here to be processed later in a 359 * periodic timer interrupt. 360 */ 361 spinlock_t waiting_msgs_lock; 362 struct list_head waiting_msgs; 363 364 /* 365 * The list of command receivers that are registered for commands 366 * on this interface. 367 */ 368 struct mutex cmd_rcvrs_mutex; 369 struct list_head cmd_rcvrs; 370 371 /* 372 * Events that were queues because no one was there to receive 373 * them. 374 */ 375 spinlock_t events_lock; /* For dealing with event stuff. */ 376 struct list_head waiting_events; 377 unsigned int waiting_events_count; /* How many events in queue? */ 378 char delivering_events; 379 char event_msg_printed; 380 381 /* 382 * The event receiver for my BMC, only really used at panic 383 * shutdown as a place to store this. 384 */ 385 unsigned char event_receiver; 386 unsigned char event_receiver_lun; 387 unsigned char local_sel_device; 388 unsigned char local_event_generator; 389 390 /* For handling of maintenance mode. */ 391 int maintenance_mode; 392 int maintenance_mode_enable; 393 int auto_maintenance_timeout; 394 spinlock_t maintenance_mode_lock; /* Used in a timer... */ 395 396 /* 397 * A cheap hack, if this is non-null and a message to an 398 * interface comes in with a NULL user, call this routine with 399 * it. Note that the message will still be freed by the 400 * caller. This only works on the system interface. 401 */ 402 void (*null_user_handler)(ipmi_smi_t intf, struct ipmi_recv_msg *msg); 403 404 /* 405 * When we are scanning the channels for an SMI, this will 406 * tell which channel we are scanning. 407 */ 408 int curr_channel; 409 410 /* Channel information */ 411 struct ipmi_channel channels[IPMI_MAX_CHANNELS]; 412 413 /* Proc FS stuff. */ 414 struct proc_dir_entry *proc_dir; 415 char proc_dir_name[10]; 416 417 atomic_t stats[IPMI_NUM_STATS]; 418 419 /* 420 * run_to_completion duplicate of smb_info, smi_info 421 * and ipmi_serial_info structures. Used to decrease numbers of 422 * parameters passed by "low" level IPMI code. 423 */ 424 int run_to_completion; 425 }; 426 #define to_si_intf_from_dev(device) container_of(device, struct ipmi_smi, dev) 427 428 /** 429 * The driver model view of the IPMI messaging driver. 430 */ 431 static struct platform_driver ipmidriver = { 432 .driver = { 433 .name = "ipmi", 434 .bus = &platform_bus_type 435 } 436 }; 437 static DEFINE_MUTEX(ipmidriver_mutex); 438 439 static LIST_HEAD(ipmi_interfaces); 440 static DEFINE_MUTEX(ipmi_interfaces_mutex); 441 442 /* 443 * List of watchers that want to know when smi's are added and deleted. 444 */ 445 static LIST_HEAD(smi_watchers); 446 static DEFINE_MUTEX(smi_watchers_mutex); 447 448 449 #define ipmi_inc_stat(intf, stat) \ 450 atomic_inc(&(intf)->stats[IPMI_STAT_ ## stat]) 451 #define ipmi_get_stat(intf, stat) \ 452 ((unsigned int) atomic_read(&(intf)->stats[IPMI_STAT_ ## stat])) 453 454 static int is_lan_addr(struct ipmi_addr *addr) 455 { 456 return addr->addr_type == IPMI_LAN_ADDR_TYPE; 457 } 458 459 static int is_ipmb_addr(struct ipmi_addr *addr) 460 { 461 return addr->addr_type == IPMI_IPMB_ADDR_TYPE; 462 } 463 464 static int is_ipmb_bcast_addr(struct ipmi_addr *addr) 465 { 466 return addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE; 467 } 468 469 static void free_recv_msg_list(struct list_head *q) 470 { 471 struct ipmi_recv_msg *msg, *msg2; 472 473 list_for_each_entry_safe(msg, msg2, q, link) { 474 list_del(&msg->link); 475 ipmi_free_recv_msg(msg); 476 } 477 } 478 479 static void free_smi_msg_list(struct list_head *q) 480 { 481 struct ipmi_smi_msg *msg, *msg2; 482 483 list_for_each_entry_safe(msg, msg2, q, link) { 484 list_del(&msg->link); 485 ipmi_free_smi_msg(msg); 486 } 487 } 488 489 static void clean_up_interface_data(ipmi_smi_t intf) 490 { 491 int i; 492 struct cmd_rcvr *rcvr, *rcvr2; 493 struct list_head list; 494 495 free_smi_msg_list(&intf->waiting_msgs); 496 free_recv_msg_list(&intf->waiting_events); 497 498 /* 499 * Wholesale remove all the entries from the list in the 500 * interface and wait for RCU to know that none are in use. 501 */ 502 mutex_lock(&intf->cmd_rcvrs_mutex); 503 INIT_LIST_HEAD(&list); 504 list_splice_init_rcu(&intf->cmd_rcvrs, &list, synchronize_rcu); 505 mutex_unlock(&intf->cmd_rcvrs_mutex); 506 507 list_for_each_entry_safe(rcvr, rcvr2, &list, link) 508 kfree(rcvr); 509 510 for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) { 511 if ((intf->seq_table[i].inuse) 512 && (intf->seq_table[i].recv_msg)) 513 ipmi_free_recv_msg(intf->seq_table[i].recv_msg); 514 } 515 } 516 517 static void intf_free(struct kref *ref) 518 { 519 ipmi_smi_t intf = container_of(ref, struct ipmi_smi, refcount); 520 521 clean_up_interface_data(intf); 522 kfree(intf); 523 } 524 525 struct watcher_entry { 526 int intf_num; 527 ipmi_smi_t intf; 528 struct list_head link; 529 }; 530 531 int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher) 532 { 533 ipmi_smi_t intf; 534 LIST_HEAD(to_deliver); 535 struct watcher_entry *e, *e2; 536 537 mutex_lock(&smi_watchers_mutex); 538 539 mutex_lock(&ipmi_interfaces_mutex); 540 541 /* Build a list of things to deliver. */ 542 list_for_each_entry(intf, &ipmi_interfaces, link) { 543 if (intf->intf_num == -1) 544 continue; 545 e = kmalloc(sizeof(*e), GFP_KERNEL); 546 if (!e) 547 goto out_err; 548 kref_get(&intf->refcount); 549 e->intf = intf; 550 e->intf_num = intf->intf_num; 551 list_add_tail(&e->link, &to_deliver); 552 } 553 554 /* We will succeed, so add it to the list. */ 555 list_add(&watcher->link, &smi_watchers); 556 557 mutex_unlock(&ipmi_interfaces_mutex); 558 559 list_for_each_entry_safe(e, e2, &to_deliver, link) { 560 list_del(&e->link); 561 watcher->new_smi(e->intf_num, e->intf->si_dev); 562 kref_put(&e->intf->refcount, intf_free); 563 kfree(e); 564 } 565 566 mutex_unlock(&smi_watchers_mutex); 567 568 return 0; 569 570 out_err: 571 mutex_unlock(&ipmi_interfaces_mutex); 572 mutex_unlock(&smi_watchers_mutex); 573 list_for_each_entry_safe(e, e2, &to_deliver, link) { 574 list_del(&e->link); 575 kref_put(&e->intf->refcount, intf_free); 576 kfree(e); 577 } 578 return -ENOMEM; 579 } 580 EXPORT_SYMBOL(ipmi_smi_watcher_register); 581 582 int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher) 583 { 584 mutex_lock(&smi_watchers_mutex); 585 list_del(&(watcher->link)); 586 mutex_unlock(&smi_watchers_mutex); 587 return 0; 588 } 589 EXPORT_SYMBOL(ipmi_smi_watcher_unregister); 590 591 /* 592 * Must be called with smi_watchers_mutex held. 593 */ 594 static void 595 call_smi_watchers(int i, struct device *dev) 596 { 597 struct ipmi_smi_watcher *w; 598 599 list_for_each_entry(w, &smi_watchers, link) { 600 if (try_module_get(w->owner)) { 601 w->new_smi(i, dev); 602 module_put(w->owner); 603 } 604 } 605 } 606 607 static int 608 ipmi_addr_equal(struct ipmi_addr *addr1, struct ipmi_addr *addr2) 609 { 610 if (addr1->addr_type != addr2->addr_type) 611 return 0; 612 613 if (addr1->channel != addr2->channel) 614 return 0; 615 616 if (addr1->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) { 617 struct ipmi_system_interface_addr *smi_addr1 618 = (struct ipmi_system_interface_addr *) addr1; 619 struct ipmi_system_interface_addr *smi_addr2 620 = (struct ipmi_system_interface_addr *) addr2; 621 return (smi_addr1->lun == smi_addr2->lun); 622 } 623 624 if (is_ipmb_addr(addr1) || is_ipmb_bcast_addr(addr1)) { 625 struct ipmi_ipmb_addr *ipmb_addr1 626 = (struct ipmi_ipmb_addr *) addr1; 627 struct ipmi_ipmb_addr *ipmb_addr2 628 = (struct ipmi_ipmb_addr *) addr2; 629 630 return ((ipmb_addr1->slave_addr == ipmb_addr2->slave_addr) 631 && (ipmb_addr1->lun == ipmb_addr2->lun)); 632 } 633 634 if (is_lan_addr(addr1)) { 635 struct ipmi_lan_addr *lan_addr1 636 = (struct ipmi_lan_addr *) addr1; 637 struct ipmi_lan_addr *lan_addr2 638 = (struct ipmi_lan_addr *) addr2; 639 640 return ((lan_addr1->remote_SWID == lan_addr2->remote_SWID) 641 && (lan_addr1->local_SWID == lan_addr2->local_SWID) 642 && (lan_addr1->session_handle 643 == lan_addr2->session_handle) 644 && (lan_addr1->lun == lan_addr2->lun)); 645 } 646 647 return 1; 648 } 649 650 int ipmi_validate_addr(struct ipmi_addr *addr, int len) 651 { 652 if (len < sizeof(struct ipmi_system_interface_addr)) 653 return -EINVAL; 654 655 if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) { 656 if (addr->channel != IPMI_BMC_CHANNEL) 657 return -EINVAL; 658 return 0; 659 } 660 661 if ((addr->channel == IPMI_BMC_CHANNEL) 662 || (addr->channel >= IPMI_MAX_CHANNELS) 663 || (addr->channel < 0)) 664 return -EINVAL; 665 666 if (is_ipmb_addr(addr) || is_ipmb_bcast_addr(addr)) { 667 if (len < sizeof(struct ipmi_ipmb_addr)) 668 return -EINVAL; 669 return 0; 670 } 671 672 if (is_lan_addr(addr)) { 673 if (len < sizeof(struct ipmi_lan_addr)) 674 return -EINVAL; 675 return 0; 676 } 677 678 return -EINVAL; 679 } 680 EXPORT_SYMBOL(ipmi_validate_addr); 681 682 unsigned int ipmi_addr_length(int addr_type) 683 { 684 if (addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) 685 return sizeof(struct ipmi_system_interface_addr); 686 687 if ((addr_type == IPMI_IPMB_ADDR_TYPE) 688 || (addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) 689 return sizeof(struct ipmi_ipmb_addr); 690 691 if (addr_type == IPMI_LAN_ADDR_TYPE) 692 return sizeof(struct ipmi_lan_addr); 693 694 return 0; 695 } 696 EXPORT_SYMBOL(ipmi_addr_length); 697 698 static void deliver_response(struct ipmi_recv_msg *msg) 699 { 700 if (!msg->user) { 701 ipmi_smi_t intf = msg->user_msg_data; 702 703 /* Special handling for NULL users. */ 704 if (intf->null_user_handler) { 705 intf->null_user_handler(intf, msg); 706 ipmi_inc_stat(intf, handled_local_responses); 707 } else { 708 /* No handler, so give up. */ 709 ipmi_inc_stat(intf, unhandled_local_responses); 710 } 711 ipmi_free_recv_msg(msg); 712 } else { 713 ipmi_user_t user = msg->user; 714 user->handler->ipmi_recv_hndl(msg, user->handler_data); 715 } 716 } 717 718 static void 719 deliver_err_response(struct ipmi_recv_msg *msg, int err) 720 { 721 msg->recv_type = IPMI_RESPONSE_RECV_TYPE; 722 msg->msg_data[0] = err; 723 msg->msg.netfn |= 1; /* Convert to a response. */ 724 msg->msg.data_len = 1; 725 msg->msg.data = msg->msg_data; 726 deliver_response(msg); 727 } 728 729 /* 730 * Find the next sequence number not being used and add the given 731 * message with the given timeout to the sequence table. This must be 732 * called with the interface's seq_lock held. 733 */ 734 static int intf_next_seq(ipmi_smi_t intf, 735 struct ipmi_recv_msg *recv_msg, 736 unsigned long timeout, 737 int retries, 738 int broadcast, 739 unsigned char *seq, 740 long *seqid) 741 { 742 int rv = 0; 743 unsigned int i; 744 745 for (i = intf->curr_seq; (i+1)%IPMI_IPMB_NUM_SEQ != intf->curr_seq; 746 i = (i+1)%IPMI_IPMB_NUM_SEQ) { 747 if (!intf->seq_table[i].inuse) 748 break; 749 } 750 751 if (!intf->seq_table[i].inuse) { 752 intf->seq_table[i].recv_msg = recv_msg; 753 754 /* 755 * Start with the maximum timeout, when the send response 756 * comes in we will start the real timer. 757 */ 758 intf->seq_table[i].timeout = MAX_MSG_TIMEOUT; 759 intf->seq_table[i].orig_timeout = timeout; 760 intf->seq_table[i].retries_left = retries; 761 intf->seq_table[i].broadcast = broadcast; 762 intf->seq_table[i].inuse = 1; 763 intf->seq_table[i].seqid = NEXT_SEQID(intf->seq_table[i].seqid); 764 *seq = i; 765 *seqid = intf->seq_table[i].seqid; 766 intf->curr_seq = (i+1)%IPMI_IPMB_NUM_SEQ; 767 } else { 768 rv = -EAGAIN; 769 } 770 771 return rv; 772 } 773 774 /* 775 * Return the receive message for the given sequence number and 776 * release the sequence number so it can be reused. Some other data 777 * is passed in to be sure the message matches up correctly (to help 778 * guard against message coming in after their timeout and the 779 * sequence number being reused). 780 */ 781 static int intf_find_seq(ipmi_smi_t intf, 782 unsigned char seq, 783 short channel, 784 unsigned char cmd, 785 unsigned char netfn, 786 struct ipmi_addr *addr, 787 struct ipmi_recv_msg **recv_msg) 788 { 789 int rv = -ENODEV; 790 unsigned long flags; 791 792 if (seq >= IPMI_IPMB_NUM_SEQ) 793 return -EINVAL; 794 795 spin_lock_irqsave(&(intf->seq_lock), flags); 796 if (intf->seq_table[seq].inuse) { 797 struct ipmi_recv_msg *msg = intf->seq_table[seq].recv_msg; 798 799 if ((msg->addr.channel == channel) && (msg->msg.cmd == cmd) 800 && (msg->msg.netfn == netfn) 801 && (ipmi_addr_equal(addr, &(msg->addr)))) { 802 *recv_msg = msg; 803 intf->seq_table[seq].inuse = 0; 804 rv = 0; 805 } 806 } 807 spin_unlock_irqrestore(&(intf->seq_lock), flags); 808 809 return rv; 810 } 811 812 813 /* Start the timer for a specific sequence table entry. */ 814 static int intf_start_seq_timer(ipmi_smi_t intf, 815 long msgid) 816 { 817 int rv = -ENODEV; 818 unsigned long flags; 819 unsigned char seq; 820 unsigned long seqid; 821 822 823 GET_SEQ_FROM_MSGID(msgid, seq, seqid); 824 825 spin_lock_irqsave(&(intf->seq_lock), flags); 826 /* 827 * We do this verification because the user can be deleted 828 * while a message is outstanding. 829 */ 830 if ((intf->seq_table[seq].inuse) 831 && (intf->seq_table[seq].seqid == seqid)) { 832 struct seq_table *ent = &(intf->seq_table[seq]); 833 ent->timeout = ent->orig_timeout; 834 rv = 0; 835 } 836 spin_unlock_irqrestore(&(intf->seq_lock), flags); 837 838 return rv; 839 } 840 841 /* Got an error for the send message for a specific sequence number. */ 842 static int intf_err_seq(ipmi_smi_t intf, 843 long msgid, 844 unsigned int err) 845 { 846 int rv = -ENODEV; 847 unsigned long flags; 848 unsigned char seq; 849 unsigned long seqid; 850 struct ipmi_recv_msg *msg = NULL; 851 852 853 GET_SEQ_FROM_MSGID(msgid, seq, seqid); 854 855 spin_lock_irqsave(&(intf->seq_lock), flags); 856 /* 857 * We do this verification because the user can be deleted 858 * while a message is outstanding. 859 */ 860 if ((intf->seq_table[seq].inuse) 861 && (intf->seq_table[seq].seqid == seqid)) { 862 struct seq_table *ent = &(intf->seq_table[seq]); 863 864 ent->inuse = 0; 865 msg = ent->recv_msg; 866 rv = 0; 867 } 868 spin_unlock_irqrestore(&(intf->seq_lock), flags); 869 870 if (msg) 871 deliver_err_response(msg, err); 872 873 return rv; 874 } 875 876 877 int ipmi_create_user(unsigned int if_num, 878 struct ipmi_user_hndl *handler, 879 void *handler_data, 880 ipmi_user_t *user) 881 { 882 unsigned long flags; 883 ipmi_user_t new_user; 884 int rv = 0; 885 ipmi_smi_t intf; 886 887 /* 888 * There is no module usecount here, because it's not 889 * required. Since this can only be used by and called from 890 * other modules, they will implicitly use this module, and 891 * thus this can't be removed unless the other modules are 892 * removed. 893 */ 894 895 if (handler == NULL) 896 return -EINVAL; 897 898 /* 899 * Make sure the driver is actually initialized, this handles 900 * problems with initialization order. 901 */ 902 if (!initialized) { 903 rv = ipmi_init_msghandler(); 904 if (rv) 905 return rv; 906 907 /* 908 * The init code doesn't return an error if it was turned 909 * off, but it won't initialize. Check that. 910 */ 911 if (!initialized) 912 return -ENODEV; 913 } 914 915 new_user = kmalloc(sizeof(*new_user), GFP_KERNEL); 916 if (!new_user) 917 return -ENOMEM; 918 919 mutex_lock(&ipmi_interfaces_mutex); 920 list_for_each_entry_rcu(intf, &ipmi_interfaces, link) { 921 if (intf->intf_num == if_num) 922 goto found; 923 } 924 /* Not found, return an error */ 925 rv = -EINVAL; 926 goto out_kfree; 927 928 found: 929 /* Note that each existing user holds a refcount to the interface. */ 930 kref_get(&intf->refcount); 931 932 kref_init(&new_user->refcount); 933 new_user->handler = handler; 934 new_user->handler_data = handler_data; 935 new_user->intf = intf; 936 new_user->gets_events = 0; 937 938 if (!try_module_get(intf->handlers->owner)) { 939 rv = -ENODEV; 940 goto out_kref; 941 } 942 943 if (intf->handlers->inc_usecount) { 944 rv = intf->handlers->inc_usecount(intf->send_info); 945 if (rv) { 946 module_put(intf->handlers->owner); 947 goto out_kref; 948 } 949 } 950 951 /* 952 * Hold the lock so intf->handlers is guaranteed to be good 953 * until now 954 */ 955 mutex_unlock(&ipmi_interfaces_mutex); 956 957 new_user->valid = 1; 958 spin_lock_irqsave(&intf->seq_lock, flags); 959 list_add_rcu(&new_user->link, &intf->users); 960 spin_unlock_irqrestore(&intf->seq_lock, flags); 961 *user = new_user; 962 return 0; 963 964 out_kref: 965 kref_put(&intf->refcount, intf_free); 966 out_kfree: 967 mutex_unlock(&ipmi_interfaces_mutex); 968 kfree(new_user); 969 return rv; 970 } 971 EXPORT_SYMBOL(ipmi_create_user); 972 973 static void free_user(struct kref *ref) 974 { 975 ipmi_user_t user = container_of(ref, struct ipmi_user, refcount); 976 kfree(user); 977 } 978 979 int ipmi_destroy_user(ipmi_user_t user) 980 { 981 ipmi_smi_t intf = user->intf; 982 int i; 983 unsigned long flags; 984 struct cmd_rcvr *rcvr; 985 struct cmd_rcvr *rcvrs = NULL; 986 987 user->valid = 0; 988 989 /* Remove the user from the interface's sequence table. */ 990 spin_lock_irqsave(&intf->seq_lock, flags); 991 list_del_rcu(&user->link); 992 993 for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) { 994 if (intf->seq_table[i].inuse 995 && (intf->seq_table[i].recv_msg->user == user)) { 996 intf->seq_table[i].inuse = 0; 997 ipmi_free_recv_msg(intf->seq_table[i].recv_msg); 998 } 999 } 1000 spin_unlock_irqrestore(&intf->seq_lock, flags); 1001 1002 /* 1003 * Remove the user from the command receiver's table. First 1004 * we build a list of everything (not using the standard link, 1005 * since other things may be using it till we do 1006 * synchronize_rcu()) then free everything in that list. 1007 */ 1008 mutex_lock(&intf->cmd_rcvrs_mutex); 1009 list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) { 1010 if (rcvr->user == user) { 1011 list_del_rcu(&rcvr->link); 1012 rcvr->next = rcvrs; 1013 rcvrs = rcvr; 1014 } 1015 } 1016 mutex_unlock(&intf->cmd_rcvrs_mutex); 1017 synchronize_rcu(); 1018 while (rcvrs) { 1019 rcvr = rcvrs; 1020 rcvrs = rcvr->next; 1021 kfree(rcvr); 1022 } 1023 1024 mutex_lock(&ipmi_interfaces_mutex); 1025 if (intf->handlers) { 1026 module_put(intf->handlers->owner); 1027 if (intf->handlers->dec_usecount) 1028 intf->handlers->dec_usecount(intf->send_info); 1029 } 1030 mutex_unlock(&ipmi_interfaces_mutex); 1031 1032 kref_put(&intf->refcount, intf_free); 1033 1034 kref_put(&user->refcount, free_user); 1035 1036 return 0; 1037 } 1038 EXPORT_SYMBOL(ipmi_destroy_user); 1039 1040 void ipmi_get_version(ipmi_user_t user, 1041 unsigned char *major, 1042 unsigned char *minor) 1043 { 1044 *major = user->intf->ipmi_version_major; 1045 *minor = user->intf->ipmi_version_minor; 1046 } 1047 EXPORT_SYMBOL(ipmi_get_version); 1048 1049 int ipmi_set_my_address(ipmi_user_t user, 1050 unsigned int channel, 1051 unsigned char address) 1052 { 1053 if (channel >= IPMI_MAX_CHANNELS) 1054 return -EINVAL; 1055 user->intf->channels[channel].address = address; 1056 return 0; 1057 } 1058 EXPORT_SYMBOL(ipmi_set_my_address); 1059 1060 int ipmi_get_my_address(ipmi_user_t user, 1061 unsigned int channel, 1062 unsigned char *address) 1063 { 1064 if (channel >= IPMI_MAX_CHANNELS) 1065 return -EINVAL; 1066 *address = user->intf->channels[channel].address; 1067 return 0; 1068 } 1069 EXPORT_SYMBOL(ipmi_get_my_address); 1070 1071 int ipmi_set_my_LUN(ipmi_user_t user, 1072 unsigned int channel, 1073 unsigned char LUN) 1074 { 1075 if (channel >= IPMI_MAX_CHANNELS) 1076 return -EINVAL; 1077 user->intf->channels[channel].lun = LUN & 0x3; 1078 return 0; 1079 } 1080 EXPORT_SYMBOL(ipmi_set_my_LUN); 1081 1082 int ipmi_get_my_LUN(ipmi_user_t user, 1083 unsigned int channel, 1084 unsigned char *address) 1085 { 1086 if (channel >= IPMI_MAX_CHANNELS) 1087 return -EINVAL; 1088 *address = user->intf->channels[channel].lun; 1089 return 0; 1090 } 1091 EXPORT_SYMBOL(ipmi_get_my_LUN); 1092 1093 int ipmi_get_maintenance_mode(ipmi_user_t user) 1094 { 1095 int mode; 1096 unsigned long flags; 1097 1098 spin_lock_irqsave(&user->intf->maintenance_mode_lock, flags); 1099 mode = user->intf->maintenance_mode; 1100 spin_unlock_irqrestore(&user->intf->maintenance_mode_lock, flags); 1101 1102 return mode; 1103 } 1104 EXPORT_SYMBOL(ipmi_get_maintenance_mode); 1105 1106 static void maintenance_mode_update(ipmi_smi_t intf) 1107 { 1108 if (intf->handlers->set_maintenance_mode) 1109 intf->handlers->set_maintenance_mode( 1110 intf->send_info, intf->maintenance_mode_enable); 1111 } 1112 1113 int ipmi_set_maintenance_mode(ipmi_user_t user, int mode) 1114 { 1115 int rv = 0; 1116 unsigned long flags; 1117 ipmi_smi_t intf = user->intf; 1118 1119 spin_lock_irqsave(&intf->maintenance_mode_lock, flags); 1120 if (intf->maintenance_mode != mode) { 1121 switch (mode) { 1122 case IPMI_MAINTENANCE_MODE_AUTO: 1123 intf->maintenance_mode = mode; 1124 intf->maintenance_mode_enable 1125 = (intf->auto_maintenance_timeout > 0); 1126 break; 1127 1128 case IPMI_MAINTENANCE_MODE_OFF: 1129 intf->maintenance_mode = mode; 1130 intf->maintenance_mode_enable = 0; 1131 break; 1132 1133 case IPMI_MAINTENANCE_MODE_ON: 1134 intf->maintenance_mode = mode; 1135 intf->maintenance_mode_enable = 1; 1136 break; 1137 1138 default: 1139 rv = -EINVAL; 1140 goto out_unlock; 1141 } 1142 1143 maintenance_mode_update(intf); 1144 } 1145 out_unlock: 1146 spin_unlock_irqrestore(&intf->maintenance_mode_lock, flags); 1147 1148 return rv; 1149 } 1150 EXPORT_SYMBOL(ipmi_set_maintenance_mode); 1151 1152 int ipmi_set_gets_events(ipmi_user_t user, int val) 1153 { 1154 unsigned long flags; 1155 ipmi_smi_t intf = user->intf; 1156 struct ipmi_recv_msg *msg, *msg2; 1157 struct list_head msgs; 1158 1159 INIT_LIST_HEAD(&msgs); 1160 1161 spin_lock_irqsave(&intf->events_lock, flags); 1162 user->gets_events = val; 1163 1164 if (intf->delivering_events) 1165 /* 1166 * Another thread is delivering events for this, so 1167 * let it handle any new events. 1168 */ 1169 goto out; 1170 1171 /* Deliver any queued events. */ 1172 while (user->gets_events && !list_empty(&intf->waiting_events)) { 1173 list_for_each_entry_safe(msg, msg2, &intf->waiting_events, link) 1174 list_move_tail(&msg->link, &msgs); 1175 intf->waiting_events_count = 0; 1176 if (intf->event_msg_printed) { 1177 printk(KERN_WARNING PFX "Event queue no longer" 1178 " full\n"); 1179 intf->event_msg_printed = 0; 1180 } 1181 1182 intf->delivering_events = 1; 1183 spin_unlock_irqrestore(&intf->events_lock, flags); 1184 1185 list_for_each_entry_safe(msg, msg2, &msgs, link) { 1186 msg->user = user; 1187 kref_get(&user->refcount); 1188 deliver_response(msg); 1189 } 1190 1191 spin_lock_irqsave(&intf->events_lock, flags); 1192 intf->delivering_events = 0; 1193 } 1194 1195 out: 1196 spin_unlock_irqrestore(&intf->events_lock, flags); 1197 1198 return 0; 1199 } 1200 EXPORT_SYMBOL(ipmi_set_gets_events); 1201 1202 static struct cmd_rcvr *find_cmd_rcvr(ipmi_smi_t intf, 1203 unsigned char netfn, 1204 unsigned char cmd, 1205 unsigned char chan) 1206 { 1207 struct cmd_rcvr *rcvr; 1208 1209 list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) { 1210 if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd) 1211 && (rcvr->chans & (1 << chan))) 1212 return rcvr; 1213 } 1214 return NULL; 1215 } 1216 1217 static int is_cmd_rcvr_exclusive(ipmi_smi_t intf, 1218 unsigned char netfn, 1219 unsigned char cmd, 1220 unsigned int chans) 1221 { 1222 struct cmd_rcvr *rcvr; 1223 1224 list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) { 1225 if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd) 1226 && (rcvr->chans & chans)) 1227 return 0; 1228 } 1229 return 1; 1230 } 1231 1232 int ipmi_register_for_cmd(ipmi_user_t user, 1233 unsigned char netfn, 1234 unsigned char cmd, 1235 unsigned int chans) 1236 { 1237 ipmi_smi_t intf = user->intf; 1238 struct cmd_rcvr *rcvr; 1239 int rv = 0; 1240 1241 1242 rcvr = kmalloc(sizeof(*rcvr), GFP_KERNEL); 1243 if (!rcvr) 1244 return -ENOMEM; 1245 rcvr->cmd = cmd; 1246 rcvr->netfn = netfn; 1247 rcvr->chans = chans; 1248 rcvr->user = user; 1249 1250 mutex_lock(&intf->cmd_rcvrs_mutex); 1251 /* Make sure the command/netfn is not already registered. */ 1252 if (!is_cmd_rcvr_exclusive(intf, netfn, cmd, chans)) { 1253 rv = -EBUSY; 1254 goto out_unlock; 1255 } 1256 1257 list_add_rcu(&rcvr->link, &intf->cmd_rcvrs); 1258 1259 out_unlock: 1260 mutex_unlock(&intf->cmd_rcvrs_mutex); 1261 if (rv) 1262 kfree(rcvr); 1263 1264 return rv; 1265 } 1266 EXPORT_SYMBOL(ipmi_register_for_cmd); 1267 1268 int ipmi_unregister_for_cmd(ipmi_user_t user, 1269 unsigned char netfn, 1270 unsigned char cmd, 1271 unsigned int chans) 1272 { 1273 ipmi_smi_t intf = user->intf; 1274 struct cmd_rcvr *rcvr; 1275 struct cmd_rcvr *rcvrs = NULL; 1276 int i, rv = -ENOENT; 1277 1278 mutex_lock(&intf->cmd_rcvrs_mutex); 1279 for (i = 0; i < IPMI_NUM_CHANNELS; i++) { 1280 if (((1 << i) & chans) == 0) 1281 continue; 1282 rcvr = find_cmd_rcvr(intf, netfn, cmd, i); 1283 if (rcvr == NULL) 1284 continue; 1285 if (rcvr->user == user) { 1286 rv = 0; 1287 rcvr->chans &= ~chans; 1288 if (rcvr->chans == 0) { 1289 list_del_rcu(&rcvr->link); 1290 rcvr->next = rcvrs; 1291 rcvrs = rcvr; 1292 } 1293 } 1294 } 1295 mutex_unlock(&intf->cmd_rcvrs_mutex); 1296 synchronize_rcu(); 1297 while (rcvrs) { 1298 rcvr = rcvrs; 1299 rcvrs = rcvr->next; 1300 kfree(rcvr); 1301 } 1302 return rv; 1303 } 1304 EXPORT_SYMBOL(ipmi_unregister_for_cmd); 1305 1306 static unsigned char 1307 ipmb_checksum(unsigned char *data, int size) 1308 { 1309 unsigned char csum = 0; 1310 1311 for (; size > 0; size--, data++) 1312 csum += *data; 1313 1314 return -csum; 1315 } 1316 1317 static inline void format_ipmb_msg(struct ipmi_smi_msg *smi_msg, 1318 struct kernel_ipmi_msg *msg, 1319 struct ipmi_ipmb_addr *ipmb_addr, 1320 long msgid, 1321 unsigned char ipmb_seq, 1322 int broadcast, 1323 unsigned char source_address, 1324 unsigned char source_lun) 1325 { 1326 int i = broadcast; 1327 1328 /* Format the IPMB header data. */ 1329 smi_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 1330 smi_msg->data[1] = IPMI_SEND_MSG_CMD; 1331 smi_msg->data[2] = ipmb_addr->channel; 1332 if (broadcast) 1333 smi_msg->data[3] = 0; 1334 smi_msg->data[i+3] = ipmb_addr->slave_addr; 1335 smi_msg->data[i+4] = (msg->netfn << 2) | (ipmb_addr->lun & 0x3); 1336 smi_msg->data[i+5] = ipmb_checksum(&(smi_msg->data[i+3]), 2); 1337 smi_msg->data[i+6] = source_address; 1338 smi_msg->data[i+7] = (ipmb_seq << 2) | source_lun; 1339 smi_msg->data[i+8] = msg->cmd; 1340 1341 /* Now tack on the data to the message. */ 1342 if (msg->data_len > 0) 1343 memcpy(&(smi_msg->data[i+9]), msg->data, 1344 msg->data_len); 1345 smi_msg->data_size = msg->data_len + 9; 1346 1347 /* Now calculate the checksum and tack it on. */ 1348 smi_msg->data[i+smi_msg->data_size] 1349 = ipmb_checksum(&(smi_msg->data[i+6]), 1350 smi_msg->data_size-6); 1351 1352 /* 1353 * Add on the checksum size and the offset from the 1354 * broadcast. 1355 */ 1356 smi_msg->data_size += 1 + i; 1357 1358 smi_msg->msgid = msgid; 1359 } 1360 1361 static inline void format_lan_msg(struct ipmi_smi_msg *smi_msg, 1362 struct kernel_ipmi_msg *msg, 1363 struct ipmi_lan_addr *lan_addr, 1364 long msgid, 1365 unsigned char ipmb_seq, 1366 unsigned char source_lun) 1367 { 1368 /* Format the IPMB header data. */ 1369 smi_msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 1370 smi_msg->data[1] = IPMI_SEND_MSG_CMD; 1371 smi_msg->data[2] = lan_addr->channel; 1372 smi_msg->data[3] = lan_addr->session_handle; 1373 smi_msg->data[4] = lan_addr->remote_SWID; 1374 smi_msg->data[5] = (msg->netfn << 2) | (lan_addr->lun & 0x3); 1375 smi_msg->data[6] = ipmb_checksum(&(smi_msg->data[4]), 2); 1376 smi_msg->data[7] = lan_addr->local_SWID; 1377 smi_msg->data[8] = (ipmb_seq << 2) | source_lun; 1378 smi_msg->data[9] = msg->cmd; 1379 1380 /* Now tack on the data to the message. */ 1381 if (msg->data_len > 0) 1382 memcpy(&(smi_msg->data[10]), msg->data, 1383 msg->data_len); 1384 smi_msg->data_size = msg->data_len + 10; 1385 1386 /* Now calculate the checksum and tack it on. */ 1387 smi_msg->data[smi_msg->data_size] 1388 = ipmb_checksum(&(smi_msg->data[7]), 1389 smi_msg->data_size-7); 1390 1391 /* 1392 * Add on the checksum size and the offset from the 1393 * broadcast. 1394 */ 1395 smi_msg->data_size += 1; 1396 1397 smi_msg->msgid = msgid; 1398 } 1399 1400 /* 1401 * Separate from ipmi_request so that the user does not have to be 1402 * supplied in certain circumstances (mainly at panic time). If 1403 * messages are supplied, they will be freed, even if an error 1404 * occurs. 1405 */ 1406 static int i_ipmi_request(ipmi_user_t user, 1407 ipmi_smi_t intf, 1408 struct ipmi_addr *addr, 1409 long msgid, 1410 struct kernel_ipmi_msg *msg, 1411 void *user_msg_data, 1412 void *supplied_smi, 1413 struct ipmi_recv_msg *supplied_recv, 1414 int priority, 1415 unsigned char source_address, 1416 unsigned char source_lun, 1417 int retries, 1418 unsigned int retry_time_ms) 1419 { 1420 int rv = 0; 1421 struct ipmi_smi_msg *smi_msg; 1422 struct ipmi_recv_msg *recv_msg; 1423 unsigned long flags; 1424 struct ipmi_smi_handlers *handlers; 1425 1426 1427 if (supplied_recv) 1428 recv_msg = supplied_recv; 1429 else { 1430 recv_msg = ipmi_alloc_recv_msg(); 1431 if (recv_msg == NULL) 1432 return -ENOMEM; 1433 } 1434 recv_msg->user_msg_data = user_msg_data; 1435 1436 if (supplied_smi) 1437 smi_msg = (struct ipmi_smi_msg *) supplied_smi; 1438 else { 1439 smi_msg = ipmi_alloc_smi_msg(); 1440 if (smi_msg == NULL) { 1441 ipmi_free_recv_msg(recv_msg); 1442 return -ENOMEM; 1443 } 1444 } 1445 1446 rcu_read_lock(); 1447 handlers = intf->handlers; 1448 if (!handlers) { 1449 rv = -ENODEV; 1450 goto out_err; 1451 } 1452 1453 recv_msg->user = user; 1454 if (user) 1455 kref_get(&user->refcount); 1456 recv_msg->msgid = msgid; 1457 /* 1458 * Store the message to send in the receive message so timeout 1459 * responses can get the proper response data. 1460 */ 1461 recv_msg->msg = *msg; 1462 1463 if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) { 1464 struct ipmi_system_interface_addr *smi_addr; 1465 1466 if (msg->netfn & 1) { 1467 /* Responses are not allowed to the SMI. */ 1468 rv = -EINVAL; 1469 goto out_err; 1470 } 1471 1472 smi_addr = (struct ipmi_system_interface_addr *) addr; 1473 if (smi_addr->lun > 3) { 1474 ipmi_inc_stat(intf, sent_invalid_commands); 1475 rv = -EINVAL; 1476 goto out_err; 1477 } 1478 1479 memcpy(&recv_msg->addr, smi_addr, sizeof(*smi_addr)); 1480 1481 if ((msg->netfn == IPMI_NETFN_APP_REQUEST) 1482 && ((msg->cmd == IPMI_SEND_MSG_CMD) 1483 || (msg->cmd == IPMI_GET_MSG_CMD) 1484 || (msg->cmd == IPMI_READ_EVENT_MSG_BUFFER_CMD))) { 1485 /* 1486 * We don't let the user do these, since we manage 1487 * the sequence numbers. 1488 */ 1489 ipmi_inc_stat(intf, sent_invalid_commands); 1490 rv = -EINVAL; 1491 goto out_err; 1492 } 1493 1494 if (((msg->netfn == IPMI_NETFN_APP_REQUEST) 1495 && ((msg->cmd == IPMI_COLD_RESET_CMD) 1496 || (msg->cmd == IPMI_WARM_RESET_CMD))) 1497 || (msg->netfn == IPMI_NETFN_FIRMWARE_REQUEST)) { 1498 spin_lock_irqsave(&intf->maintenance_mode_lock, flags); 1499 intf->auto_maintenance_timeout 1500 = IPMI_MAINTENANCE_MODE_TIMEOUT; 1501 if (!intf->maintenance_mode 1502 && !intf->maintenance_mode_enable) { 1503 intf->maintenance_mode_enable = 1; 1504 maintenance_mode_update(intf); 1505 } 1506 spin_unlock_irqrestore(&intf->maintenance_mode_lock, 1507 flags); 1508 } 1509 1510 if ((msg->data_len + 2) > IPMI_MAX_MSG_LENGTH) { 1511 ipmi_inc_stat(intf, sent_invalid_commands); 1512 rv = -EMSGSIZE; 1513 goto out_err; 1514 } 1515 1516 smi_msg->data[0] = (msg->netfn << 2) | (smi_addr->lun & 0x3); 1517 smi_msg->data[1] = msg->cmd; 1518 smi_msg->msgid = msgid; 1519 smi_msg->user_data = recv_msg; 1520 if (msg->data_len > 0) 1521 memcpy(&(smi_msg->data[2]), msg->data, msg->data_len); 1522 smi_msg->data_size = msg->data_len + 2; 1523 ipmi_inc_stat(intf, sent_local_commands); 1524 } else if (is_ipmb_addr(addr) || is_ipmb_bcast_addr(addr)) { 1525 struct ipmi_ipmb_addr *ipmb_addr; 1526 unsigned char ipmb_seq; 1527 long seqid; 1528 int broadcast = 0; 1529 1530 if (addr->channel >= IPMI_MAX_CHANNELS) { 1531 ipmi_inc_stat(intf, sent_invalid_commands); 1532 rv = -EINVAL; 1533 goto out_err; 1534 } 1535 1536 if (intf->channels[addr->channel].medium 1537 != IPMI_CHANNEL_MEDIUM_IPMB) { 1538 ipmi_inc_stat(intf, sent_invalid_commands); 1539 rv = -EINVAL; 1540 goto out_err; 1541 } 1542 1543 if (retries < 0) { 1544 if (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE) 1545 retries = 0; /* Don't retry broadcasts. */ 1546 else 1547 retries = 4; 1548 } 1549 if (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE) { 1550 /* 1551 * Broadcasts add a zero at the beginning of the 1552 * message, but otherwise is the same as an IPMB 1553 * address. 1554 */ 1555 addr->addr_type = IPMI_IPMB_ADDR_TYPE; 1556 broadcast = 1; 1557 } 1558 1559 1560 /* Default to 1 second retries. */ 1561 if (retry_time_ms == 0) 1562 retry_time_ms = 1000; 1563 1564 /* 1565 * 9 for the header and 1 for the checksum, plus 1566 * possibly one for the broadcast. 1567 */ 1568 if ((msg->data_len + 10 + broadcast) > IPMI_MAX_MSG_LENGTH) { 1569 ipmi_inc_stat(intf, sent_invalid_commands); 1570 rv = -EMSGSIZE; 1571 goto out_err; 1572 } 1573 1574 ipmb_addr = (struct ipmi_ipmb_addr *) addr; 1575 if (ipmb_addr->lun > 3) { 1576 ipmi_inc_stat(intf, sent_invalid_commands); 1577 rv = -EINVAL; 1578 goto out_err; 1579 } 1580 1581 memcpy(&recv_msg->addr, ipmb_addr, sizeof(*ipmb_addr)); 1582 1583 if (recv_msg->msg.netfn & 0x1) { 1584 /* 1585 * It's a response, so use the user's sequence 1586 * from msgid. 1587 */ 1588 ipmi_inc_stat(intf, sent_ipmb_responses); 1589 format_ipmb_msg(smi_msg, msg, ipmb_addr, msgid, 1590 msgid, broadcast, 1591 source_address, source_lun); 1592 1593 /* 1594 * Save the receive message so we can use it 1595 * to deliver the response. 1596 */ 1597 smi_msg->user_data = recv_msg; 1598 } else { 1599 /* It's a command, so get a sequence for it. */ 1600 1601 spin_lock_irqsave(&(intf->seq_lock), flags); 1602 1603 /* 1604 * Create a sequence number with a 1 second 1605 * timeout and 4 retries. 1606 */ 1607 rv = intf_next_seq(intf, 1608 recv_msg, 1609 retry_time_ms, 1610 retries, 1611 broadcast, 1612 &ipmb_seq, 1613 &seqid); 1614 if (rv) { 1615 /* 1616 * We have used up all the sequence numbers, 1617 * probably, so abort. 1618 */ 1619 spin_unlock_irqrestore(&(intf->seq_lock), 1620 flags); 1621 goto out_err; 1622 } 1623 1624 ipmi_inc_stat(intf, sent_ipmb_commands); 1625 1626 /* 1627 * Store the sequence number in the message, 1628 * so that when the send message response 1629 * comes back we can start the timer. 1630 */ 1631 format_ipmb_msg(smi_msg, msg, ipmb_addr, 1632 STORE_SEQ_IN_MSGID(ipmb_seq, seqid), 1633 ipmb_seq, broadcast, 1634 source_address, source_lun); 1635 1636 /* 1637 * Copy the message into the recv message data, so we 1638 * can retransmit it later if necessary. 1639 */ 1640 memcpy(recv_msg->msg_data, smi_msg->data, 1641 smi_msg->data_size); 1642 recv_msg->msg.data = recv_msg->msg_data; 1643 recv_msg->msg.data_len = smi_msg->data_size; 1644 1645 /* 1646 * We don't unlock until here, because we need 1647 * to copy the completed message into the 1648 * recv_msg before we release the lock. 1649 * Otherwise, race conditions may bite us. I 1650 * know that's pretty paranoid, but I prefer 1651 * to be correct. 1652 */ 1653 spin_unlock_irqrestore(&(intf->seq_lock), flags); 1654 } 1655 } else if (is_lan_addr(addr)) { 1656 struct ipmi_lan_addr *lan_addr; 1657 unsigned char ipmb_seq; 1658 long seqid; 1659 1660 if (addr->channel >= IPMI_MAX_CHANNELS) { 1661 ipmi_inc_stat(intf, sent_invalid_commands); 1662 rv = -EINVAL; 1663 goto out_err; 1664 } 1665 1666 if ((intf->channels[addr->channel].medium 1667 != IPMI_CHANNEL_MEDIUM_8023LAN) 1668 && (intf->channels[addr->channel].medium 1669 != IPMI_CHANNEL_MEDIUM_ASYNC)) { 1670 ipmi_inc_stat(intf, sent_invalid_commands); 1671 rv = -EINVAL; 1672 goto out_err; 1673 } 1674 1675 retries = 4; 1676 1677 /* Default to 1 second retries. */ 1678 if (retry_time_ms == 0) 1679 retry_time_ms = 1000; 1680 1681 /* 11 for the header and 1 for the checksum. */ 1682 if ((msg->data_len + 12) > IPMI_MAX_MSG_LENGTH) { 1683 ipmi_inc_stat(intf, sent_invalid_commands); 1684 rv = -EMSGSIZE; 1685 goto out_err; 1686 } 1687 1688 lan_addr = (struct ipmi_lan_addr *) addr; 1689 if (lan_addr->lun > 3) { 1690 ipmi_inc_stat(intf, sent_invalid_commands); 1691 rv = -EINVAL; 1692 goto out_err; 1693 } 1694 1695 memcpy(&recv_msg->addr, lan_addr, sizeof(*lan_addr)); 1696 1697 if (recv_msg->msg.netfn & 0x1) { 1698 /* 1699 * It's a response, so use the user's sequence 1700 * from msgid. 1701 */ 1702 ipmi_inc_stat(intf, sent_lan_responses); 1703 format_lan_msg(smi_msg, msg, lan_addr, msgid, 1704 msgid, source_lun); 1705 1706 /* 1707 * Save the receive message so we can use it 1708 * to deliver the response. 1709 */ 1710 smi_msg->user_data = recv_msg; 1711 } else { 1712 /* It's a command, so get a sequence for it. */ 1713 1714 spin_lock_irqsave(&(intf->seq_lock), flags); 1715 1716 /* 1717 * Create a sequence number with a 1 second 1718 * timeout and 4 retries. 1719 */ 1720 rv = intf_next_seq(intf, 1721 recv_msg, 1722 retry_time_ms, 1723 retries, 1724 0, 1725 &ipmb_seq, 1726 &seqid); 1727 if (rv) { 1728 /* 1729 * We have used up all the sequence numbers, 1730 * probably, so abort. 1731 */ 1732 spin_unlock_irqrestore(&(intf->seq_lock), 1733 flags); 1734 goto out_err; 1735 } 1736 1737 ipmi_inc_stat(intf, sent_lan_commands); 1738 1739 /* 1740 * Store the sequence number in the message, 1741 * so that when the send message response 1742 * comes back we can start the timer. 1743 */ 1744 format_lan_msg(smi_msg, msg, lan_addr, 1745 STORE_SEQ_IN_MSGID(ipmb_seq, seqid), 1746 ipmb_seq, source_lun); 1747 1748 /* 1749 * Copy the message into the recv message data, so we 1750 * can retransmit it later if necessary. 1751 */ 1752 memcpy(recv_msg->msg_data, smi_msg->data, 1753 smi_msg->data_size); 1754 recv_msg->msg.data = recv_msg->msg_data; 1755 recv_msg->msg.data_len = smi_msg->data_size; 1756 1757 /* 1758 * We don't unlock until here, because we need 1759 * to copy the completed message into the 1760 * recv_msg before we release the lock. 1761 * Otherwise, race conditions may bite us. I 1762 * know that's pretty paranoid, but I prefer 1763 * to be correct. 1764 */ 1765 spin_unlock_irqrestore(&(intf->seq_lock), flags); 1766 } 1767 } else { 1768 /* Unknown address type. */ 1769 ipmi_inc_stat(intf, sent_invalid_commands); 1770 rv = -EINVAL; 1771 goto out_err; 1772 } 1773 1774 #ifdef DEBUG_MSGING 1775 { 1776 int m; 1777 for (m = 0; m < smi_msg->data_size; m++) 1778 printk(" %2.2x", smi_msg->data[m]); 1779 printk("\n"); 1780 } 1781 #endif 1782 1783 handlers->sender(intf->send_info, smi_msg, priority); 1784 rcu_read_unlock(); 1785 1786 return 0; 1787 1788 out_err: 1789 rcu_read_unlock(); 1790 ipmi_free_smi_msg(smi_msg); 1791 ipmi_free_recv_msg(recv_msg); 1792 return rv; 1793 } 1794 1795 static int check_addr(ipmi_smi_t intf, 1796 struct ipmi_addr *addr, 1797 unsigned char *saddr, 1798 unsigned char *lun) 1799 { 1800 if (addr->channel >= IPMI_MAX_CHANNELS) 1801 return -EINVAL; 1802 *lun = intf->channels[addr->channel].lun; 1803 *saddr = intf->channels[addr->channel].address; 1804 return 0; 1805 } 1806 1807 int ipmi_request_settime(ipmi_user_t user, 1808 struct ipmi_addr *addr, 1809 long msgid, 1810 struct kernel_ipmi_msg *msg, 1811 void *user_msg_data, 1812 int priority, 1813 int retries, 1814 unsigned int retry_time_ms) 1815 { 1816 unsigned char saddr, lun; 1817 int rv; 1818 1819 if (!user) 1820 return -EINVAL; 1821 rv = check_addr(user->intf, addr, &saddr, &lun); 1822 if (rv) 1823 return rv; 1824 return i_ipmi_request(user, 1825 user->intf, 1826 addr, 1827 msgid, 1828 msg, 1829 user_msg_data, 1830 NULL, NULL, 1831 priority, 1832 saddr, 1833 lun, 1834 retries, 1835 retry_time_ms); 1836 } 1837 EXPORT_SYMBOL(ipmi_request_settime); 1838 1839 int ipmi_request_supply_msgs(ipmi_user_t user, 1840 struct ipmi_addr *addr, 1841 long msgid, 1842 struct kernel_ipmi_msg *msg, 1843 void *user_msg_data, 1844 void *supplied_smi, 1845 struct ipmi_recv_msg *supplied_recv, 1846 int priority) 1847 { 1848 unsigned char saddr, lun; 1849 int rv; 1850 1851 if (!user) 1852 return -EINVAL; 1853 rv = check_addr(user->intf, addr, &saddr, &lun); 1854 if (rv) 1855 return rv; 1856 return i_ipmi_request(user, 1857 user->intf, 1858 addr, 1859 msgid, 1860 msg, 1861 user_msg_data, 1862 supplied_smi, 1863 supplied_recv, 1864 priority, 1865 saddr, 1866 lun, 1867 -1, 0); 1868 } 1869 EXPORT_SYMBOL(ipmi_request_supply_msgs); 1870 1871 #ifdef CONFIG_PROC_FS 1872 static int ipmb_file_read_proc(char *page, char **start, off_t off, 1873 int count, int *eof, void *data) 1874 { 1875 char *out = (char *) page; 1876 ipmi_smi_t intf = data; 1877 int i; 1878 int rv = 0; 1879 1880 for (i = 0; i < IPMI_MAX_CHANNELS; i++) 1881 rv += sprintf(out+rv, "%x ", intf->channels[i].address); 1882 out[rv-1] = '\n'; /* Replace the final space with a newline */ 1883 out[rv] = '\0'; 1884 rv++; 1885 return rv; 1886 } 1887 1888 static int version_file_read_proc(char *page, char **start, off_t off, 1889 int count, int *eof, void *data) 1890 { 1891 char *out = (char *) page; 1892 ipmi_smi_t intf = data; 1893 1894 return sprintf(out, "%u.%u\n", 1895 ipmi_version_major(&intf->bmc->id), 1896 ipmi_version_minor(&intf->bmc->id)); 1897 } 1898 1899 static int stat_file_read_proc(char *page, char **start, off_t off, 1900 int count, int *eof, void *data) 1901 { 1902 char *out = (char *) page; 1903 ipmi_smi_t intf = data; 1904 1905 out += sprintf(out, "sent_invalid_commands: %u\n", 1906 ipmi_get_stat(intf, sent_invalid_commands)); 1907 out += sprintf(out, "sent_local_commands: %u\n", 1908 ipmi_get_stat(intf, sent_local_commands)); 1909 out += sprintf(out, "handled_local_responses: %u\n", 1910 ipmi_get_stat(intf, handled_local_responses)); 1911 out += sprintf(out, "unhandled_local_responses: %u\n", 1912 ipmi_get_stat(intf, unhandled_local_responses)); 1913 out += sprintf(out, "sent_ipmb_commands: %u\n", 1914 ipmi_get_stat(intf, sent_ipmb_commands)); 1915 out += sprintf(out, "sent_ipmb_command_errs: %u\n", 1916 ipmi_get_stat(intf, sent_ipmb_command_errs)); 1917 out += sprintf(out, "retransmitted_ipmb_commands: %u\n", 1918 ipmi_get_stat(intf, retransmitted_ipmb_commands)); 1919 out += sprintf(out, "timed_out_ipmb_commands: %u\n", 1920 ipmi_get_stat(intf, timed_out_ipmb_commands)); 1921 out += sprintf(out, "timed_out_ipmb_broadcasts: %u\n", 1922 ipmi_get_stat(intf, timed_out_ipmb_broadcasts)); 1923 out += sprintf(out, "sent_ipmb_responses: %u\n", 1924 ipmi_get_stat(intf, sent_ipmb_responses)); 1925 out += sprintf(out, "handled_ipmb_responses: %u\n", 1926 ipmi_get_stat(intf, handled_ipmb_responses)); 1927 out += sprintf(out, "invalid_ipmb_responses: %u\n", 1928 ipmi_get_stat(intf, invalid_ipmb_responses)); 1929 out += sprintf(out, "unhandled_ipmb_responses: %u\n", 1930 ipmi_get_stat(intf, unhandled_ipmb_responses)); 1931 out += sprintf(out, "sent_lan_commands: %u\n", 1932 ipmi_get_stat(intf, sent_lan_commands)); 1933 out += sprintf(out, "sent_lan_command_errs: %u\n", 1934 ipmi_get_stat(intf, sent_lan_command_errs)); 1935 out += sprintf(out, "retransmitted_lan_commands: %u\n", 1936 ipmi_get_stat(intf, retransmitted_lan_commands)); 1937 out += sprintf(out, "timed_out_lan_commands: %u\n", 1938 ipmi_get_stat(intf, timed_out_lan_commands)); 1939 out += sprintf(out, "sent_lan_responses: %u\n", 1940 ipmi_get_stat(intf, sent_lan_responses)); 1941 out += sprintf(out, "handled_lan_responses: %u\n", 1942 ipmi_get_stat(intf, handled_lan_responses)); 1943 out += sprintf(out, "invalid_lan_responses: %u\n", 1944 ipmi_get_stat(intf, invalid_lan_responses)); 1945 out += sprintf(out, "unhandled_lan_responses: %u\n", 1946 ipmi_get_stat(intf, unhandled_lan_responses)); 1947 out += sprintf(out, "handled_commands: %u\n", 1948 ipmi_get_stat(intf, handled_commands)); 1949 out += sprintf(out, "invalid_commands: %u\n", 1950 ipmi_get_stat(intf, invalid_commands)); 1951 out += sprintf(out, "unhandled_commands: %u\n", 1952 ipmi_get_stat(intf, unhandled_commands)); 1953 out += sprintf(out, "invalid_events: %u\n", 1954 ipmi_get_stat(intf, invalid_events)); 1955 out += sprintf(out, "events: %u\n", 1956 ipmi_get_stat(intf, events)); 1957 out += sprintf(out, "failed rexmit LAN msgs: %u\n", 1958 ipmi_get_stat(intf, dropped_rexmit_lan_commands)); 1959 out += sprintf(out, "failed rexmit IPMB msgs: %u\n", 1960 ipmi_get_stat(intf, dropped_rexmit_ipmb_commands)); 1961 1962 return (out - ((char *) page)); 1963 } 1964 #endif /* CONFIG_PROC_FS */ 1965 1966 int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name, 1967 read_proc_t *read_proc, 1968 void *data) 1969 { 1970 int rv = 0; 1971 #ifdef CONFIG_PROC_FS 1972 struct proc_dir_entry *file; 1973 struct ipmi_proc_entry *entry; 1974 1975 /* Create a list element. */ 1976 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 1977 if (!entry) 1978 return -ENOMEM; 1979 entry->name = kmalloc(strlen(name)+1, GFP_KERNEL); 1980 if (!entry->name) { 1981 kfree(entry); 1982 return -ENOMEM; 1983 } 1984 strcpy(entry->name, name); 1985 1986 file = create_proc_entry(name, 0, smi->proc_dir); 1987 if (!file) { 1988 kfree(entry->name); 1989 kfree(entry); 1990 rv = -ENOMEM; 1991 } else { 1992 file->data = data; 1993 file->read_proc = read_proc; 1994 1995 mutex_lock(&smi->proc_entry_lock); 1996 /* Stick it on the list. */ 1997 entry->next = smi->proc_entries; 1998 smi->proc_entries = entry; 1999 mutex_unlock(&smi->proc_entry_lock); 2000 } 2001 #endif /* CONFIG_PROC_FS */ 2002 2003 return rv; 2004 } 2005 EXPORT_SYMBOL(ipmi_smi_add_proc_entry); 2006 2007 static int add_proc_entries(ipmi_smi_t smi, int num) 2008 { 2009 int rv = 0; 2010 2011 #ifdef CONFIG_PROC_FS 2012 sprintf(smi->proc_dir_name, "%d", num); 2013 smi->proc_dir = proc_mkdir(smi->proc_dir_name, proc_ipmi_root); 2014 if (!smi->proc_dir) 2015 rv = -ENOMEM; 2016 2017 if (rv == 0) 2018 rv = ipmi_smi_add_proc_entry(smi, "stats", 2019 stat_file_read_proc, 2020 smi); 2021 2022 if (rv == 0) 2023 rv = ipmi_smi_add_proc_entry(smi, "ipmb", 2024 ipmb_file_read_proc, 2025 smi); 2026 2027 if (rv == 0) 2028 rv = ipmi_smi_add_proc_entry(smi, "version", 2029 version_file_read_proc, 2030 smi); 2031 #endif /* CONFIG_PROC_FS */ 2032 2033 return rv; 2034 } 2035 2036 static void remove_proc_entries(ipmi_smi_t smi) 2037 { 2038 #ifdef CONFIG_PROC_FS 2039 struct ipmi_proc_entry *entry; 2040 2041 mutex_lock(&smi->proc_entry_lock); 2042 while (smi->proc_entries) { 2043 entry = smi->proc_entries; 2044 smi->proc_entries = entry->next; 2045 2046 remove_proc_entry(entry->name, smi->proc_dir); 2047 kfree(entry->name); 2048 kfree(entry); 2049 } 2050 mutex_unlock(&smi->proc_entry_lock); 2051 remove_proc_entry(smi->proc_dir_name, proc_ipmi_root); 2052 #endif /* CONFIG_PROC_FS */ 2053 } 2054 2055 static int __find_bmc_guid(struct device *dev, void *data) 2056 { 2057 unsigned char *id = data; 2058 struct bmc_device *bmc = dev_get_drvdata(dev); 2059 return memcmp(bmc->guid, id, 16) == 0; 2060 } 2061 2062 static struct bmc_device *ipmi_find_bmc_guid(struct device_driver *drv, 2063 unsigned char *guid) 2064 { 2065 struct device *dev; 2066 2067 dev = driver_find_device(drv, NULL, guid, __find_bmc_guid); 2068 if (dev) 2069 return dev_get_drvdata(dev); 2070 else 2071 return NULL; 2072 } 2073 2074 struct prod_dev_id { 2075 unsigned int product_id; 2076 unsigned char device_id; 2077 }; 2078 2079 static int __find_bmc_prod_dev_id(struct device *dev, void *data) 2080 { 2081 struct prod_dev_id *id = data; 2082 struct bmc_device *bmc = dev_get_drvdata(dev); 2083 2084 return (bmc->id.product_id == id->product_id 2085 && bmc->id.device_id == id->device_id); 2086 } 2087 2088 static struct bmc_device *ipmi_find_bmc_prod_dev_id( 2089 struct device_driver *drv, 2090 unsigned int product_id, unsigned char device_id) 2091 { 2092 struct prod_dev_id id = { 2093 .product_id = product_id, 2094 .device_id = device_id, 2095 }; 2096 struct device *dev; 2097 2098 dev = driver_find_device(drv, NULL, &id, __find_bmc_prod_dev_id); 2099 if (dev) 2100 return dev_get_drvdata(dev); 2101 else 2102 return NULL; 2103 } 2104 2105 static ssize_t device_id_show(struct device *dev, 2106 struct device_attribute *attr, 2107 char *buf) 2108 { 2109 struct bmc_device *bmc = dev_get_drvdata(dev); 2110 2111 return snprintf(buf, 10, "%u\n", bmc->id.device_id); 2112 } 2113 2114 static ssize_t provides_dev_sdrs_show(struct device *dev, 2115 struct device_attribute *attr, 2116 char *buf) 2117 { 2118 struct bmc_device *bmc = dev_get_drvdata(dev); 2119 2120 return snprintf(buf, 10, "%u\n", 2121 (bmc->id.device_revision & 0x80) >> 7); 2122 } 2123 2124 static ssize_t revision_show(struct device *dev, struct device_attribute *attr, 2125 char *buf) 2126 { 2127 struct bmc_device *bmc = dev_get_drvdata(dev); 2128 2129 return snprintf(buf, 20, "%u\n", 2130 bmc->id.device_revision & 0x0F); 2131 } 2132 2133 static ssize_t firmware_rev_show(struct device *dev, 2134 struct device_attribute *attr, 2135 char *buf) 2136 { 2137 struct bmc_device *bmc = dev_get_drvdata(dev); 2138 2139 return snprintf(buf, 20, "%u.%x\n", bmc->id.firmware_revision_1, 2140 bmc->id.firmware_revision_2); 2141 } 2142 2143 static ssize_t ipmi_version_show(struct device *dev, 2144 struct device_attribute *attr, 2145 char *buf) 2146 { 2147 struct bmc_device *bmc = dev_get_drvdata(dev); 2148 2149 return snprintf(buf, 20, "%u.%u\n", 2150 ipmi_version_major(&bmc->id), 2151 ipmi_version_minor(&bmc->id)); 2152 } 2153 2154 static ssize_t add_dev_support_show(struct device *dev, 2155 struct device_attribute *attr, 2156 char *buf) 2157 { 2158 struct bmc_device *bmc = dev_get_drvdata(dev); 2159 2160 return snprintf(buf, 10, "0x%02x\n", 2161 bmc->id.additional_device_support); 2162 } 2163 2164 static ssize_t manufacturer_id_show(struct device *dev, 2165 struct device_attribute *attr, 2166 char *buf) 2167 { 2168 struct bmc_device *bmc = dev_get_drvdata(dev); 2169 2170 return snprintf(buf, 20, "0x%6.6x\n", bmc->id.manufacturer_id); 2171 } 2172 2173 static ssize_t product_id_show(struct device *dev, 2174 struct device_attribute *attr, 2175 char *buf) 2176 { 2177 struct bmc_device *bmc = dev_get_drvdata(dev); 2178 2179 return snprintf(buf, 10, "0x%4.4x\n", bmc->id.product_id); 2180 } 2181 2182 static ssize_t aux_firmware_rev_show(struct device *dev, 2183 struct device_attribute *attr, 2184 char *buf) 2185 { 2186 struct bmc_device *bmc = dev_get_drvdata(dev); 2187 2188 return snprintf(buf, 21, "0x%02x 0x%02x 0x%02x 0x%02x\n", 2189 bmc->id.aux_firmware_revision[3], 2190 bmc->id.aux_firmware_revision[2], 2191 bmc->id.aux_firmware_revision[1], 2192 bmc->id.aux_firmware_revision[0]); 2193 } 2194 2195 static ssize_t guid_show(struct device *dev, struct device_attribute *attr, 2196 char *buf) 2197 { 2198 struct bmc_device *bmc = dev_get_drvdata(dev); 2199 2200 return snprintf(buf, 100, "%Lx%Lx\n", 2201 (long long) bmc->guid[0], 2202 (long long) bmc->guid[8]); 2203 } 2204 2205 static void remove_files(struct bmc_device *bmc) 2206 { 2207 if (!bmc->dev) 2208 return; 2209 2210 device_remove_file(&bmc->dev->dev, 2211 &bmc->device_id_attr); 2212 device_remove_file(&bmc->dev->dev, 2213 &bmc->provides_dev_sdrs_attr); 2214 device_remove_file(&bmc->dev->dev, 2215 &bmc->revision_attr); 2216 device_remove_file(&bmc->dev->dev, 2217 &bmc->firmware_rev_attr); 2218 device_remove_file(&bmc->dev->dev, 2219 &bmc->version_attr); 2220 device_remove_file(&bmc->dev->dev, 2221 &bmc->add_dev_support_attr); 2222 device_remove_file(&bmc->dev->dev, 2223 &bmc->manufacturer_id_attr); 2224 device_remove_file(&bmc->dev->dev, 2225 &bmc->product_id_attr); 2226 2227 if (bmc->id.aux_firmware_revision_set) 2228 device_remove_file(&bmc->dev->dev, 2229 &bmc->aux_firmware_rev_attr); 2230 if (bmc->guid_set) 2231 device_remove_file(&bmc->dev->dev, 2232 &bmc->guid_attr); 2233 } 2234 2235 static void 2236 cleanup_bmc_device(struct kref *ref) 2237 { 2238 struct bmc_device *bmc; 2239 2240 bmc = container_of(ref, struct bmc_device, refcount); 2241 2242 remove_files(bmc); 2243 platform_device_unregister(bmc->dev); 2244 kfree(bmc); 2245 } 2246 2247 static void ipmi_bmc_unregister(ipmi_smi_t intf) 2248 { 2249 struct bmc_device *bmc = intf->bmc; 2250 2251 if (intf->sysfs_name) { 2252 sysfs_remove_link(&intf->si_dev->kobj, intf->sysfs_name); 2253 kfree(intf->sysfs_name); 2254 intf->sysfs_name = NULL; 2255 } 2256 if (intf->my_dev_name) { 2257 sysfs_remove_link(&bmc->dev->dev.kobj, intf->my_dev_name); 2258 kfree(intf->my_dev_name); 2259 intf->my_dev_name = NULL; 2260 } 2261 2262 mutex_lock(&ipmidriver_mutex); 2263 kref_put(&bmc->refcount, cleanup_bmc_device); 2264 intf->bmc = NULL; 2265 mutex_unlock(&ipmidriver_mutex); 2266 } 2267 2268 static int create_files(struct bmc_device *bmc) 2269 { 2270 int err; 2271 2272 bmc->device_id_attr.attr.name = "device_id"; 2273 bmc->device_id_attr.attr.mode = S_IRUGO; 2274 bmc->device_id_attr.show = device_id_show; 2275 2276 bmc->provides_dev_sdrs_attr.attr.name = "provides_device_sdrs"; 2277 bmc->provides_dev_sdrs_attr.attr.mode = S_IRUGO; 2278 bmc->provides_dev_sdrs_attr.show = provides_dev_sdrs_show; 2279 2280 bmc->revision_attr.attr.name = "revision"; 2281 bmc->revision_attr.attr.mode = S_IRUGO; 2282 bmc->revision_attr.show = revision_show; 2283 2284 bmc->firmware_rev_attr.attr.name = "firmware_revision"; 2285 bmc->firmware_rev_attr.attr.mode = S_IRUGO; 2286 bmc->firmware_rev_attr.show = firmware_rev_show; 2287 2288 bmc->version_attr.attr.name = "ipmi_version"; 2289 bmc->version_attr.attr.mode = S_IRUGO; 2290 bmc->version_attr.show = ipmi_version_show; 2291 2292 bmc->add_dev_support_attr.attr.name = "additional_device_support"; 2293 bmc->add_dev_support_attr.attr.mode = S_IRUGO; 2294 bmc->add_dev_support_attr.show = add_dev_support_show; 2295 2296 bmc->manufacturer_id_attr.attr.name = "manufacturer_id"; 2297 bmc->manufacturer_id_attr.attr.mode = S_IRUGO; 2298 bmc->manufacturer_id_attr.show = manufacturer_id_show; 2299 2300 bmc->product_id_attr.attr.name = "product_id"; 2301 bmc->product_id_attr.attr.mode = S_IRUGO; 2302 bmc->product_id_attr.show = product_id_show; 2303 2304 bmc->guid_attr.attr.name = "guid"; 2305 bmc->guid_attr.attr.mode = S_IRUGO; 2306 bmc->guid_attr.show = guid_show; 2307 2308 bmc->aux_firmware_rev_attr.attr.name = "aux_firmware_revision"; 2309 bmc->aux_firmware_rev_attr.attr.mode = S_IRUGO; 2310 bmc->aux_firmware_rev_attr.show = aux_firmware_rev_show; 2311 2312 err = device_create_file(&bmc->dev->dev, 2313 &bmc->device_id_attr); 2314 if (err) 2315 goto out; 2316 err = device_create_file(&bmc->dev->dev, 2317 &bmc->provides_dev_sdrs_attr); 2318 if (err) 2319 goto out_devid; 2320 err = device_create_file(&bmc->dev->dev, 2321 &bmc->revision_attr); 2322 if (err) 2323 goto out_sdrs; 2324 err = device_create_file(&bmc->dev->dev, 2325 &bmc->firmware_rev_attr); 2326 if (err) 2327 goto out_rev; 2328 err = device_create_file(&bmc->dev->dev, 2329 &bmc->version_attr); 2330 if (err) 2331 goto out_firm; 2332 err = device_create_file(&bmc->dev->dev, 2333 &bmc->add_dev_support_attr); 2334 if (err) 2335 goto out_version; 2336 err = device_create_file(&bmc->dev->dev, 2337 &bmc->manufacturer_id_attr); 2338 if (err) 2339 goto out_add_dev; 2340 err = device_create_file(&bmc->dev->dev, 2341 &bmc->product_id_attr); 2342 if (err) 2343 goto out_manu; 2344 if (bmc->id.aux_firmware_revision_set) { 2345 err = device_create_file(&bmc->dev->dev, 2346 &bmc->aux_firmware_rev_attr); 2347 if (err) 2348 goto out_prod_id; 2349 } 2350 if (bmc->guid_set) { 2351 err = device_create_file(&bmc->dev->dev, 2352 &bmc->guid_attr); 2353 if (err) 2354 goto out_aux_firm; 2355 } 2356 2357 return 0; 2358 2359 out_aux_firm: 2360 if (bmc->id.aux_firmware_revision_set) 2361 device_remove_file(&bmc->dev->dev, 2362 &bmc->aux_firmware_rev_attr); 2363 out_prod_id: 2364 device_remove_file(&bmc->dev->dev, 2365 &bmc->product_id_attr); 2366 out_manu: 2367 device_remove_file(&bmc->dev->dev, 2368 &bmc->manufacturer_id_attr); 2369 out_add_dev: 2370 device_remove_file(&bmc->dev->dev, 2371 &bmc->add_dev_support_attr); 2372 out_version: 2373 device_remove_file(&bmc->dev->dev, 2374 &bmc->version_attr); 2375 out_firm: 2376 device_remove_file(&bmc->dev->dev, 2377 &bmc->firmware_rev_attr); 2378 out_rev: 2379 device_remove_file(&bmc->dev->dev, 2380 &bmc->revision_attr); 2381 out_sdrs: 2382 device_remove_file(&bmc->dev->dev, 2383 &bmc->provides_dev_sdrs_attr); 2384 out_devid: 2385 device_remove_file(&bmc->dev->dev, 2386 &bmc->device_id_attr); 2387 out: 2388 return err; 2389 } 2390 2391 static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum, 2392 const char *sysfs_name) 2393 { 2394 int rv; 2395 struct bmc_device *bmc = intf->bmc; 2396 struct bmc_device *old_bmc; 2397 int size; 2398 char dummy[1]; 2399 2400 mutex_lock(&ipmidriver_mutex); 2401 2402 /* 2403 * Try to find if there is an bmc_device struct 2404 * representing the interfaced BMC already 2405 */ 2406 if (bmc->guid_set) 2407 old_bmc = ipmi_find_bmc_guid(&ipmidriver.driver, bmc->guid); 2408 else 2409 old_bmc = ipmi_find_bmc_prod_dev_id(&ipmidriver.driver, 2410 bmc->id.product_id, 2411 bmc->id.device_id); 2412 2413 /* 2414 * If there is already an bmc_device, free the new one, 2415 * otherwise register the new BMC device 2416 */ 2417 if (old_bmc) { 2418 kfree(bmc); 2419 intf->bmc = old_bmc; 2420 bmc = old_bmc; 2421 2422 kref_get(&bmc->refcount); 2423 mutex_unlock(&ipmidriver_mutex); 2424 2425 printk(KERN_INFO 2426 "ipmi: interfacing existing BMC (man_id: 0x%6.6x," 2427 " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n", 2428 bmc->id.manufacturer_id, 2429 bmc->id.product_id, 2430 bmc->id.device_id); 2431 } else { 2432 char name[14]; 2433 unsigned char orig_dev_id = bmc->id.device_id; 2434 int warn_printed = 0; 2435 2436 snprintf(name, sizeof(name), 2437 "ipmi_bmc.%4.4x", bmc->id.product_id); 2438 2439 while (ipmi_find_bmc_prod_dev_id(&ipmidriver.driver, 2440 bmc->id.product_id, 2441 bmc->id.device_id)) { 2442 if (!warn_printed) { 2443 printk(KERN_WARNING PFX 2444 "This machine has two different BMCs" 2445 " with the same product id and device" 2446 " id. This is an error in the" 2447 " firmware, but incrementing the" 2448 " device id to work around the problem." 2449 " Prod ID = 0x%x, Dev ID = 0x%x\n", 2450 bmc->id.product_id, bmc->id.device_id); 2451 warn_printed = 1; 2452 } 2453 bmc->id.device_id++; /* Wraps at 255 */ 2454 if (bmc->id.device_id == orig_dev_id) { 2455 printk(KERN_ERR PFX 2456 "Out of device ids!\n"); 2457 break; 2458 } 2459 } 2460 2461 bmc->dev = platform_device_alloc(name, bmc->id.device_id); 2462 if (!bmc->dev) { 2463 mutex_unlock(&ipmidriver_mutex); 2464 printk(KERN_ERR 2465 "ipmi_msghandler:" 2466 " Unable to allocate platform device\n"); 2467 return -ENOMEM; 2468 } 2469 bmc->dev->dev.driver = &ipmidriver.driver; 2470 dev_set_drvdata(&bmc->dev->dev, bmc); 2471 kref_init(&bmc->refcount); 2472 2473 rv = platform_device_add(bmc->dev); 2474 mutex_unlock(&ipmidriver_mutex); 2475 if (rv) { 2476 platform_device_put(bmc->dev); 2477 bmc->dev = NULL; 2478 printk(KERN_ERR 2479 "ipmi_msghandler:" 2480 " Unable to register bmc device: %d\n", 2481 rv); 2482 /* 2483 * Don't go to out_err, you can only do that if 2484 * the device is registered already. 2485 */ 2486 return rv; 2487 } 2488 2489 rv = create_files(bmc); 2490 if (rv) { 2491 mutex_lock(&ipmidriver_mutex); 2492 platform_device_unregister(bmc->dev); 2493 mutex_unlock(&ipmidriver_mutex); 2494 2495 return rv; 2496 } 2497 2498 printk(KERN_INFO 2499 "ipmi: Found new BMC (man_id: 0x%6.6x, " 2500 " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n", 2501 bmc->id.manufacturer_id, 2502 bmc->id.product_id, 2503 bmc->id.device_id); 2504 } 2505 2506 /* 2507 * create symlink from system interface device to bmc device 2508 * and back. 2509 */ 2510 intf->sysfs_name = kstrdup(sysfs_name, GFP_KERNEL); 2511 if (!intf->sysfs_name) { 2512 rv = -ENOMEM; 2513 printk(KERN_ERR 2514 "ipmi_msghandler: allocate link to BMC: %d\n", 2515 rv); 2516 goto out_err; 2517 } 2518 2519 rv = sysfs_create_link(&intf->si_dev->kobj, 2520 &bmc->dev->dev.kobj, intf->sysfs_name); 2521 if (rv) { 2522 kfree(intf->sysfs_name); 2523 intf->sysfs_name = NULL; 2524 printk(KERN_ERR 2525 "ipmi_msghandler: Unable to create bmc symlink: %d\n", 2526 rv); 2527 goto out_err; 2528 } 2529 2530 size = snprintf(dummy, 0, "ipmi%d", ifnum); 2531 intf->my_dev_name = kmalloc(size+1, GFP_KERNEL); 2532 if (!intf->my_dev_name) { 2533 kfree(intf->sysfs_name); 2534 intf->sysfs_name = NULL; 2535 rv = -ENOMEM; 2536 printk(KERN_ERR 2537 "ipmi_msghandler: allocate link from BMC: %d\n", 2538 rv); 2539 goto out_err; 2540 } 2541 snprintf(intf->my_dev_name, size+1, "ipmi%d", ifnum); 2542 2543 rv = sysfs_create_link(&bmc->dev->dev.kobj, &intf->si_dev->kobj, 2544 intf->my_dev_name); 2545 if (rv) { 2546 kfree(intf->sysfs_name); 2547 intf->sysfs_name = NULL; 2548 kfree(intf->my_dev_name); 2549 intf->my_dev_name = NULL; 2550 printk(KERN_ERR 2551 "ipmi_msghandler:" 2552 " Unable to create symlink to bmc: %d\n", 2553 rv); 2554 goto out_err; 2555 } 2556 2557 return 0; 2558 2559 out_err: 2560 ipmi_bmc_unregister(intf); 2561 return rv; 2562 } 2563 2564 static int 2565 send_guid_cmd(ipmi_smi_t intf, int chan) 2566 { 2567 struct kernel_ipmi_msg msg; 2568 struct ipmi_system_interface_addr si; 2569 2570 si.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 2571 si.channel = IPMI_BMC_CHANNEL; 2572 si.lun = 0; 2573 2574 msg.netfn = IPMI_NETFN_APP_REQUEST; 2575 msg.cmd = IPMI_GET_DEVICE_GUID_CMD; 2576 msg.data = NULL; 2577 msg.data_len = 0; 2578 return i_ipmi_request(NULL, 2579 intf, 2580 (struct ipmi_addr *) &si, 2581 0, 2582 &msg, 2583 intf, 2584 NULL, 2585 NULL, 2586 0, 2587 intf->channels[0].address, 2588 intf->channels[0].lun, 2589 -1, 0); 2590 } 2591 2592 static void 2593 guid_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg) 2594 { 2595 if ((msg->addr.addr_type != IPMI_SYSTEM_INTERFACE_ADDR_TYPE) 2596 || (msg->msg.netfn != IPMI_NETFN_APP_RESPONSE) 2597 || (msg->msg.cmd != IPMI_GET_DEVICE_GUID_CMD)) 2598 /* Not for me */ 2599 return; 2600 2601 if (msg->msg.data[0] != 0) { 2602 /* Error from getting the GUID, the BMC doesn't have one. */ 2603 intf->bmc->guid_set = 0; 2604 goto out; 2605 } 2606 2607 if (msg->msg.data_len < 17) { 2608 intf->bmc->guid_set = 0; 2609 printk(KERN_WARNING PFX 2610 "guid_handler: The GUID response from the BMC was too" 2611 " short, it was %d but should have been 17. Assuming" 2612 " GUID is not available.\n", 2613 msg->msg.data_len); 2614 goto out; 2615 } 2616 2617 memcpy(intf->bmc->guid, msg->msg.data, 16); 2618 intf->bmc->guid_set = 1; 2619 out: 2620 wake_up(&intf->waitq); 2621 } 2622 2623 static void 2624 get_guid(ipmi_smi_t intf) 2625 { 2626 int rv; 2627 2628 intf->bmc->guid_set = 0x2; 2629 intf->null_user_handler = guid_handler; 2630 rv = send_guid_cmd(intf, 0); 2631 if (rv) 2632 /* Send failed, no GUID available. */ 2633 intf->bmc->guid_set = 0; 2634 wait_event(intf->waitq, intf->bmc->guid_set != 2); 2635 intf->null_user_handler = NULL; 2636 } 2637 2638 static int 2639 send_channel_info_cmd(ipmi_smi_t intf, int chan) 2640 { 2641 struct kernel_ipmi_msg msg; 2642 unsigned char data[1]; 2643 struct ipmi_system_interface_addr si; 2644 2645 si.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 2646 si.channel = IPMI_BMC_CHANNEL; 2647 si.lun = 0; 2648 2649 msg.netfn = IPMI_NETFN_APP_REQUEST; 2650 msg.cmd = IPMI_GET_CHANNEL_INFO_CMD; 2651 msg.data = data; 2652 msg.data_len = 1; 2653 data[0] = chan; 2654 return i_ipmi_request(NULL, 2655 intf, 2656 (struct ipmi_addr *) &si, 2657 0, 2658 &msg, 2659 intf, 2660 NULL, 2661 NULL, 2662 0, 2663 intf->channels[0].address, 2664 intf->channels[0].lun, 2665 -1, 0); 2666 } 2667 2668 static void 2669 channel_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg) 2670 { 2671 int rv = 0; 2672 int chan; 2673 2674 if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) 2675 && (msg->msg.netfn == IPMI_NETFN_APP_RESPONSE) 2676 && (msg->msg.cmd == IPMI_GET_CHANNEL_INFO_CMD)) { 2677 /* It's the one we want */ 2678 if (msg->msg.data[0] != 0) { 2679 /* Got an error from the channel, just go on. */ 2680 2681 if (msg->msg.data[0] == IPMI_INVALID_COMMAND_ERR) { 2682 /* 2683 * If the MC does not support this 2684 * command, that is legal. We just 2685 * assume it has one IPMB at channel 2686 * zero. 2687 */ 2688 intf->channels[0].medium 2689 = IPMI_CHANNEL_MEDIUM_IPMB; 2690 intf->channels[0].protocol 2691 = IPMI_CHANNEL_PROTOCOL_IPMB; 2692 rv = -ENOSYS; 2693 2694 intf->curr_channel = IPMI_MAX_CHANNELS; 2695 wake_up(&intf->waitq); 2696 goto out; 2697 } 2698 goto next_channel; 2699 } 2700 if (msg->msg.data_len < 4) { 2701 /* Message not big enough, just go on. */ 2702 goto next_channel; 2703 } 2704 chan = intf->curr_channel; 2705 intf->channels[chan].medium = msg->msg.data[2] & 0x7f; 2706 intf->channels[chan].protocol = msg->msg.data[3] & 0x1f; 2707 2708 next_channel: 2709 intf->curr_channel++; 2710 if (intf->curr_channel >= IPMI_MAX_CHANNELS) 2711 wake_up(&intf->waitq); 2712 else 2713 rv = send_channel_info_cmd(intf, intf->curr_channel); 2714 2715 if (rv) { 2716 /* Got an error somehow, just give up. */ 2717 intf->curr_channel = IPMI_MAX_CHANNELS; 2718 wake_up(&intf->waitq); 2719 2720 printk(KERN_WARNING PFX 2721 "Error sending channel information: %d\n", 2722 rv); 2723 } 2724 } 2725 out: 2726 return; 2727 } 2728 2729 void ipmi_poll_interface(ipmi_user_t user) 2730 { 2731 ipmi_smi_t intf = user->intf; 2732 2733 if (intf->handlers->poll) 2734 intf->handlers->poll(intf->send_info); 2735 } 2736 EXPORT_SYMBOL(ipmi_poll_interface); 2737 2738 int ipmi_register_smi(struct ipmi_smi_handlers *handlers, 2739 void *send_info, 2740 struct ipmi_device_id *device_id, 2741 struct device *si_dev, 2742 const char *sysfs_name, 2743 unsigned char slave_addr) 2744 { 2745 int i, j; 2746 int rv; 2747 ipmi_smi_t intf; 2748 ipmi_smi_t tintf; 2749 struct list_head *link; 2750 2751 /* 2752 * Make sure the driver is actually initialized, this handles 2753 * problems with initialization order. 2754 */ 2755 if (!initialized) { 2756 rv = ipmi_init_msghandler(); 2757 if (rv) 2758 return rv; 2759 /* 2760 * The init code doesn't return an error if it was turned 2761 * off, but it won't initialize. Check that. 2762 */ 2763 if (!initialized) 2764 return -ENODEV; 2765 } 2766 2767 intf = kzalloc(sizeof(*intf), GFP_KERNEL); 2768 if (!intf) 2769 return -ENOMEM; 2770 2771 intf->ipmi_version_major = ipmi_version_major(device_id); 2772 intf->ipmi_version_minor = ipmi_version_minor(device_id); 2773 2774 intf->bmc = kzalloc(sizeof(*intf->bmc), GFP_KERNEL); 2775 if (!intf->bmc) { 2776 kfree(intf); 2777 return -ENOMEM; 2778 } 2779 intf->intf_num = -1; /* Mark it invalid for now. */ 2780 kref_init(&intf->refcount); 2781 intf->bmc->id = *device_id; 2782 intf->si_dev = si_dev; 2783 for (j = 0; j < IPMI_MAX_CHANNELS; j++) { 2784 intf->channels[j].address = IPMI_BMC_SLAVE_ADDR; 2785 intf->channels[j].lun = 2; 2786 } 2787 if (slave_addr != 0) 2788 intf->channels[0].address = slave_addr; 2789 INIT_LIST_HEAD(&intf->users); 2790 intf->handlers = handlers; 2791 intf->send_info = send_info; 2792 spin_lock_init(&intf->seq_lock); 2793 for (j = 0; j < IPMI_IPMB_NUM_SEQ; j++) { 2794 intf->seq_table[j].inuse = 0; 2795 intf->seq_table[j].seqid = 0; 2796 } 2797 intf->curr_seq = 0; 2798 #ifdef CONFIG_PROC_FS 2799 mutex_init(&intf->proc_entry_lock); 2800 #endif 2801 spin_lock_init(&intf->waiting_msgs_lock); 2802 INIT_LIST_HEAD(&intf->waiting_msgs); 2803 spin_lock_init(&intf->events_lock); 2804 INIT_LIST_HEAD(&intf->waiting_events); 2805 intf->waiting_events_count = 0; 2806 mutex_init(&intf->cmd_rcvrs_mutex); 2807 spin_lock_init(&intf->maintenance_mode_lock); 2808 INIT_LIST_HEAD(&intf->cmd_rcvrs); 2809 init_waitqueue_head(&intf->waitq); 2810 for (i = 0; i < IPMI_NUM_STATS; i++) 2811 atomic_set(&intf->stats[i], 0); 2812 2813 intf->proc_dir = NULL; 2814 2815 mutex_lock(&smi_watchers_mutex); 2816 mutex_lock(&ipmi_interfaces_mutex); 2817 /* Look for a hole in the numbers. */ 2818 i = 0; 2819 link = &ipmi_interfaces; 2820 list_for_each_entry_rcu(tintf, &ipmi_interfaces, link) { 2821 if (tintf->intf_num != i) { 2822 link = &tintf->link; 2823 break; 2824 } 2825 i++; 2826 } 2827 /* Add the new interface in numeric order. */ 2828 if (i == 0) 2829 list_add_rcu(&intf->link, &ipmi_interfaces); 2830 else 2831 list_add_tail_rcu(&intf->link, link); 2832 2833 rv = handlers->start_processing(send_info, intf); 2834 if (rv) 2835 goto out; 2836 2837 get_guid(intf); 2838 2839 if ((intf->ipmi_version_major > 1) 2840 || ((intf->ipmi_version_major == 1) 2841 && (intf->ipmi_version_minor >= 5))) { 2842 /* 2843 * Start scanning the channels to see what is 2844 * available. 2845 */ 2846 intf->null_user_handler = channel_handler; 2847 intf->curr_channel = 0; 2848 rv = send_channel_info_cmd(intf, 0); 2849 if (rv) 2850 goto out; 2851 2852 /* Wait for the channel info to be read. */ 2853 wait_event(intf->waitq, 2854 intf->curr_channel >= IPMI_MAX_CHANNELS); 2855 intf->null_user_handler = NULL; 2856 } else { 2857 /* Assume a single IPMB channel at zero. */ 2858 intf->channels[0].medium = IPMI_CHANNEL_MEDIUM_IPMB; 2859 intf->channels[0].protocol = IPMI_CHANNEL_PROTOCOL_IPMB; 2860 intf->curr_channel = IPMI_MAX_CHANNELS; 2861 } 2862 2863 if (rv == 0) 2864 rv = add_proc_entries(intf, i); 2865 2866 rv = ipmi_bmc_register(intf, i, sysfs_name); 2867 2868 out: 2869 if (rv) { 2870 if (intf->proc_dir) 2871 remove_proc_entries(intf); 2872 intf->handlers = NULL; 2873 list_del_rcu(&intf->link); 2874 mutex_unlock(&ipmi_interfaces_mutex); 2875 mutex_unlock(&smi_watchers_mutex); 2876 synchronize_rcu(); 2877 kref_put(&intf->refcount, intf_free); 2878 } else { 2879 /* 2880 * Keep memory order straight for RCU readers. Make 2881 * sure everything else is committed to memory before 2882 * setting intf_num to mark the interface valid. 2883 */ 2884 smp_wmb(); 2885 intf->intf_num = i; 2886 mutex_unlock(&ipmi_interfaces_mutex); 2887 /* After this point the interface is legal to use. */ 2888 call_smi_watchers(i, intf->si_dev); 2889 mutex_unlock(&smi_watchers_mutex); 2890 } 2891 2892 return rv; 2893 } 2894 EXPORT_SYMBOL(ipmi_register_smi); 2895 2896 static void cleanup_smi_msgs(ipmi_smi_t intf) 2897 { 2898 int i; 2899 struct seq_table *ent; 2900 2901 /* No need for locks, the interface is down. */ 2902 for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) { 2903 ent = &(intf->seq_table[i]); 2904 if (!ent->inuse) 2905 continue; 2906 deliver_err_response(ent->recv_msg, IPMI_ERR_UNSPECIFIED); 2907 } 2908 } 2909 2910 int ipmi_unregister_smi(ipmi_smi_t intf) 2911 { 2912 struct ipmi_smi_watcher *w; 2913 int intf_num = intf->intf_num; 2914 2915 ipmi_bmc_unregister(intf); 2916 2917 mutex_lock(&smi_watchers_mutex); 2918 mutex_lock(&ipmi_interfaces_mutex); 2919 intf->intf_num = -1; 2920 intf->handlers = NULL; 2921 list_del_rcu(&intf->link); 2922 mutex_unlock(&ipmi_interfaces_mutex); 2923 synchronize_rcu(); 2924 2925 cleanup_smi_msgs(intf); 2926 2927 remove_proc_entries(intf); 2928 2929 /* 2930 * Call all the watcher interfaces to tell them that 2931 * an interface is gone. 2932 */ 2933 list_for_each_entry(w, &smi_watchers, link) 2934 w->smi_gone(intf_num); 2935 mutex_unlock(&smi_watchers_mutex); 2936 2937 kref_put(&intf->refcount, intf_free); 2938 return 0; 2939 } 2940 EXPORT_SYMBOL(ipmi_unregister_smi); 2941 2942 static int handle_ipmb_get_msg_rsp(ipmi_smi_t intf, 2943 struct ipmi_smi_msg *msg) 2944 { 2945 struct ipmi_ipmb_addr ipmb_addr; 2946 struct ipmi_recv_msg *recv_msg; 2947 2948 /* 2949 * This is 11, not 10, because the response must contain a 2950 * completion code. 2951 */ 2952 if (msg->rsp_size < 11) { 2953 /* Message not big enough, just ignore it. */ 2954 ipmi_inc_stat(intf, invalid_ipmb_responses); 2955 return 0; 2956 } 2957 2958 if (msg->rsp[2] != 0) { 2959 /* An error getting the response, just ignore it. */ 2960 return 0; 2961 } 2962 2963 ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE; 2964 ipmb_addr.slave_addr = msg->rsp[6]; 2965 ipmb_addr.channel = msg->rsp[3] & 0x0f; 2966 ipmb_addr.lun = msg->rsp[7] & 3; 2967 2968 /* 2969 * It's a response from a remote entity. Look up the sequence 2970 * number and handle the response. 2971 */ 2972 if (intf_find_seq(intf, 2973 msg->rsp[7] >> 2, 2974 msg->rsp[3] & 0x0f, 2975 msg->rsp[8], 2976 (msg->rsp[4] >> 2) & (~1), 2977 (struct ipmi_addr *) &(ipmb_addr), 2978 &recv_msg)) { 2979 /* 2980 * We were unable to find the sequence number, 2981 * so just nuke the message. 2982 */ 2983 ipmi_inc_stat(intf, unhandled_ipmb_responses); 2984 return 0; 2985 } 2986 2987 memcpy(recv_msg->msg_data, 2988 &(msg->rsp[9]), 2989 msg->rsp_size - 9); 2990 /* 2991 * The other fields matched, so no need to set them, except 2992 * for netfn, which needs to be the response that was 2993 * returned, not the request value. 2994 */ 2995 recv_msg->msg.netfn = msg->rsp[4] >> 2; 2996 recv_msg->msg.data = recv_msg->msg_data; 2997 recv_msg->msg.data_len = msg->rsp_size - 10; 2998 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE; 2999 ipmi_inc_stat(intf, handled_ipmb_responses); 3000 deliver_response(recv_msg); 3001 3002 return 0; 3003 } 3004 3005 static int handle_ipmb_get_msg_cmd(ipmi_smi_t intf, 3006 struct ipmi_smi_msg *msg) 3007 { 3008 struct cmd_rcvr *rcvr; 3009 int rv = 0; 3010 unsigned char netfn; 3011 unsigned char cmd; 3012 unsigned char chan; 3013 ipmi_user_t user = NULL; 3014 struct ipmi_ipmb_addr *ipmb_addr; 3015 struct ipmi_recv_msg *recv_msg; 3016 struct ipmi_smi_handlers *handlers; 3017 3018 if (msg->rsp_size < 10) { 3019 /* Message not big enough, just ignore it. */ 3020 ipmi_inc_stat(intf, invalid_commands); 3021 return 0; 3022 } 3023 3024 if (msg->rsp[2] != 0) { 3025 /* An error getting the response, just ignore it. */ 3026 return 0; 3027 } 3028 3029 netfn = msg->rsp[4] >> 2; 3030 cmd = msg->rsp[8]; 3031 chan = msg->rsp[3] & 0xf; 3032 3033 rcu_read_lock(); 3034 rcvr = find_cmd_rcvr(intf, netfn, cmd, chan); 3035 if (rcvr) { 3036 user = rcvr->user; 3037 kref_get(&user->refcount); 3038 } else 3039 user = NULL; 3040 rcu_read_unlock(); 3041 3042 if (user == NULL) { 3043 /* We didn't find a user, deliver an error response. */ 3044 ipmi_inc_stat(intf, unhandled_commands); 3045 3046 msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2); 3047 msg->data[1] = IPMI_SEND_MSG_CMD; 3048 msg->data[2] = msg->rsp[3]; 3049 msg->data[3] = msg->rsp[6]; 3050 msg->data[4] = ((netfn + 1) << 2) | (msg->rsp[7] & 0x3); 3051 msg->data[5] = ipmb_checksum(&(msg->data[3]), 2); 3052 msg->data[6] = intf->channels[msg->rsp[3] & 0xf].address; 3053 /* rqseq/lun */ 3054 msg->data[7] = (msg->rsp[7] & 0xfc) | (msg->rsp[4] & 0x3); 3055 msg->data[8] = msg->rsp[8]; /* cmd */ 3056 msg->data[9] = IPMI_INVALID_CMD_COMPLETION_CODE; 3057 msg->data[10] = ipmb_checksum(&(msg->data[6]), 4); 3058 msg->data_size = 11; 3059 3060 #ifdef DEBUG_MSGING 3061 { 3062 int m; 3063 printk("Invalid command:"); 3064 for (m = 0; m < msg->data_size; m++) 3065 printk(" %2.2x", msg->data[m]); 3066 printk("\n"); 3067 } 3068 #endif 3069 rcu_read_lock(); 3070 handlers = intf->handlers; 3071 if (handlers) { 3072 handlers->sender(intf->send_info, msg, 0); 3073 /* 3074 * We used the message, so return the value 3075 * that causes it to not be freed or 3076 * queued. 3077 */ 3078 rv = -1; 3079 } 3080 rcu_read_unlock(); 3081 } else { 3082 /* Deliver the message to the user. */ 3083 ipmi_inc_stat(intf, handled_commands); 3084 3085 recv_msg = ipmi_alloc_recv_msg(); 3086 if (!recv_msg) { 3087 /* 3088 * We couldn't allocate memory for the 3089 * message, so requeue it for handling 3090 * later. 3091 */ 3092 rv = 1; 3093 kref_put(&user->refcount, free_user); 3094 } else { 3095 /* Extract the source address from the data. */ 3096 ipmb_addr = (struct ipmi_ipmb_addr *) &recv_msg->addr; 3097 ipmb_addr->addr_type = IPMI_IPMB_ADDR_TYPE; 3098 ipmb_addr->slave_addr = msg->rsp[6]; 3099 ipmb_addr->lun = msg->rsp[7] & 3; 3100 ipmb_addr->channel = msg->rsp[3] & 0xf; 3101 3102 /* 3103 * Extract the rest of the message information 3104 * from the IPMB header. 3105 */ 3106 recv_msg->user = user; 3107 recv_msg->recv_type = IPMI_CMD_RECV_TYPE; 3108 recv_msg->msgid = msg->rsp[7] >> 2; 3109 recv_msg->msg.netfn = msg->rsp[4] >> 2; 3110 recv_msg->msg.cmd = msg->rsp[8]; 3111 recv_msg->msg.data = recv_msg->msg_data; 3112 3113 /* 3114 * We chop off 10, not 9 bytes because the checksum 3115 * at the end also needs to be removed. 3116 */ 3117 recv_msg->msg.data_len = msg->rsp_size - 10; 3118 memcpy(recv_msg->msg_data, 3119 &(msg->rsp[9]), 3120 msg->rsp_size - 10); 3121 deliver_response(recv_msg); 3122 } 3123 } 3124 3125 return rv; 3126 } 3127 3128 static int handle_lan_get_msg_rsp(ipmi_smi_t intf, 3129 struct ipmi_smi_msg *msg) 3130 { 3131 struct ipmi_lan_addr lan_addr; 3132 struct ipmi_recv_msg *recv_msg; 3133 3134 3135 /* 3136 * This is 13, not 12, because the response must contain a 3137 * completion code. 3138 */ 3139 if (msg->rsp_size < 13) { 3140 /* Message not big enough, just ignore it. */ 3141 ipmi_inc_stat(intf, invalid_lan_responses); 3142 return 0; 3143 } 3144 3145 if (msg->rsp[2] != 0) { 3146 /* An error getting the response, just ignore it. */ 3147 return 0; 3148 } 3149 3150 lan_addr.addr_type = IPMI_LAN_ADDR_TYPE; 3151 lan_addr.session_handle = msg->rsp[4]; 3152 lan_addr.remote_SWID = msg->rsp[8]; 3153 lan_addr.local_SWID = msg->rsp[5]; 3154 lan_addr.channel = msg->rsp[3] & 0x0f; 3155 lan_addr.privilege = msg->rsp[3] >> 4; 3156 lan_addr.lun = msg->rsp[9] & 3; 3157 3158 /* 3159 * It's a response from a remote entity. Look up the sequence 3160 * number and handle the response. 3161 */ 3162 if (intf_find_seq(intf, 3163 msg->rsp[9] >> 2, 3164 msg->rsp[3] & 0x0f, 3165 msg->rsp[10], 3166 (msg->rsp[6] >> 2) & (~1), 3167 (struct ipmi_addr *) &(lan_addr), 3168 &recv_msg)) { 3169 /* 3170 * We were unable to find the sequence number, 3171 * so just nuke the message. 3172 */ 3173 ipmi_inc_stat(intf, unhandled_lan_responses); 3174 return 0; 3175 } 3176 3177 memcpy(recv_msg->msg_data, 3178 &(msg->rsp[11]), 3179 msg->rsp_size - 11); 3180 /* 3181 * The other fields matched, so no need to set them, except 3182 * for netfn, which needs to be the response that was 3183 * returned, not the request value. 3184 */ 3185 recv_msg->msg.netfn = msg->rsp[6] >> 2; 3186 recv_msg->msg.data = recv_msg->msg_data; 3187 recv_msg->msg.data_len = msg->rsp_size - 12; 3188 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE; 3189 ipmi_inc_stat(intf, handled_lan_responses); 3190 deliver_response(recv_msg); 3191 3192 return 0; 3193 } 3194 3195 static int handle_lan_get_msg_cmd(ipmi_smi_t intf, 3196 struct ipmi_smi_msg *msg) 3197 { 3198 struct cmd_rcvr *rcvr; 3199 int rv = 0; 3200 unsigned char netfn; 3201 unsigned char cmd; 3202 unsigned char chan; 3203 ipmi_user_t user = NULL; 3204 struct ipmi_lan_addr *lan_addr; 3205 struct ipmi_recv_msg *recv_msg; 3206 3207 if (msg->rsp_size < 12) { 3208 /* Message not big enough, just ignore it. */ 3209 ipmi_inc_stat(intf, invalid_commands); 3210 return 0; 3211 } 3212 3213 if (msg->rsp[2] != 0) { 3214 /* An error getting the response, just ignore it. */ 3215 return 0; 3216 } 3217 3218 netfn = msg->rsp[6] >> 2; 3219 cmd = msg->rsp[10]; 3220 chan = msg->rsp[3] & 0xf; 3221 3222 rcu_read_lock(); 3223 rcvr = find_cmd_rcvr(intf, netfn, cmd, chan); 3224 if (rcvr) { 3225 user = rcvr->user; 3226 kref_get(&user->refcount); 3227 } else 3228 user = NULL; 3229 rcu_read_unlock(); 3230 3231 if (user == NULL) { 3232 /* We didn't find a user, just give up. */ 3233 ipmi_inc_stat(intf, unhandled_commands); 3234 3235 /* 3236 * Don't do anything with these messages, just allow 3237 * them to be freed. 3238 */ 3239 rv = 0; 3240 } else { 3241 /* Deliver the message to the user. */ 3242 ipmi_inc_stat(intf, handled_commands); 3243 3244 recv_msg = ipmi_alloc_recv_msg(); 3245 if (!recv_msg) { 3246 /* 3247 * We couldn't allocate memory for the 3248 * message, so requeue it for handling later. 3249 */ 3250 rv = 1; 3251 kref_put(&user->refcount, free_user); 3252 } else { 3253 /* Extract the source address from the data. */ 3254 lan_addr = (struct ipmi_lan_addr *) &recv_msg->addr; 3255 lan_addr->addr_type = IPMI_LAN_ADDR_TYPE; 3256 lan_addr->session_handle = msg->rsp[4]; 3257 lan_addr->remote_SWID = msg->rsp[8]; 3258 lan_addr->local_SWID = msg->rsp[5]; 3259 lan_addr->lun = msg->rsp[9] & 3; 3260 lan_addr->channel = msg->rsp[3] & 0xf; 3261 lan_addr->privilege = msg->rsp[3] >> 4; 3262 3263 /* 3264 * Extract the rest of the message information 3265 * from the IPMB header. 3266 */ 3267 recv_msg->user = user; 3268 recv_msg->recv_type = IPMI_CMD_RECV_TYPE; 3269 recv_msg->msgid = msg->rsp[9] >> 2; 3270 recv_msg->msg.netfn = msg->rsp[6] >> 2; 3271 recv_msg->msg.cmd = msg->rsp[10]; 3272 recv_msg->msg.data = recv_msg->msg_data; 3273 3274 /* 3275 * We chop off 12, not 11 bytes because the checksum 3276 * at the end also needs to be removed. 3277 */ 3278 recv_msg->msg.data_len = msg->rsp_size - 12; 3279 memcpy(recv_msg->msg_data, 3280 &(msg->rsp[11]), 3281 msg->rsp_size - 12); 3282 deliver_response(recv_msg); 3283 } 3284 } 3285 3286 return rv; 3287 } 3288 3289 /* 3290 * This routine will handle "Get Message" command responses with 3291 * channels that use an OEM Medium. The message format belongs to 3292 * the OEM. See IPMI 2.0 specification, Chapter 6 and 3293 * Chapter 22, sections 22.6 and 22.24 for more details. 3294 */ 3295 static int handle_oem_get_msg_cmd(ipmi_smi_t intf, 3296 struct ipmi_smi_msg *msg) 3297 { 3298 struct cmd_rcvr *rcvr; 3299 int rv = 0; 3300 unsigned char netfn; 3301 unsigned char cmd; 3302 unsigned char chan; 3303 ipmi_user_t user = NULL; 3304 struct ipmi_system_interface_addr *smi_addr; 3305 struct ipmi_recv_msg *recv_msg; 3306 3307 /* 3308 * We expect the OEM SW to perform error checking 3309 * so we just do some basic sanity checks 3310 */ 3311 if (msg->rsp_size < 4) { 3312 /* Message not big enough, just ignore it. */ 3313 ipmi_inc_stat(intf, invalid_commands); 3314 return 0; 3315 } 3316 3317 if (msg->rsp[2] != 0) { 3318 /* An error getting the response, just ignore it. */ 3319 return 0; 3320 } 3321 3322 /* 3323 * This is an OEM Message so the OEM needs to know how 3324 * handle the message. We do no interpretation. 3325 */ 3326 netfn = msg->rsp[0] >> 2; 3327 cmd = msg->rsp[1]; 3328 chan = msg->rsp[3] & 0xf; 3329 3330 rcu_read_lock(); 3331 rcvr = find_cmd_rcvr(intf, netfn, cmd, chan); 3332 if (rcvr) { 3333 user = rcvr->user; 3334 kref_get(&user->refcount); 3335 } else 3336 user = NULL; 3337 rcu_read_unlock(); 3338 3339 if (user == NULL) { 3340 /* We didn't find a user, just give up. */ 3341 ipmi_inc_stat(intf, unhandled_commands); 3342 3343 /* 3344 * Don't do anything with these messages, just allow 3345 * them to be freed. 3346 */ 3347 3348 rv = 0; 3349 } else { 3350 /* Deliver the message to the user. */ 3351 ipmi_inc_stat(intf, handled_commands); 3352 3353 recv_msg = ipmi_alloc_recv_msg(); 3354 if (!recv_msg) { 3355 /* 3356 * We couldn't allocate memory for the 3357 * message, so requeue it for handling 3358 * later. 3359 */ 3360 rv = 1; 3361 kref_put(&user->refcount, free_user); 3362 } else { 3363 /* 3364 * OEM Messages are expected to be delivered via 3365 * the system interface to SMS software. We might 3366 * need to visit this again depending on OEM 3367 * requirements 3368 */ 3369 smi_addr = ((struct ipmi_system_interface_addr *) 3370 &(recv_msg->addr)); 3371 smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 3372 smi_addr->channel = IPMI_BMC_CHANNEL; 3373 smi_addr->lun = msg->rsp[0] & 3; 3374 3375 recv_msg->user = user; 3376 recv_msg->user_msg_data = NULL; 3377 recv_msg->recv_type = IPMI_OEM_RECV_TYPE; 3378 recv_msg->msg.netfn = msg->rsp[0] >> 2; 3379 recv_msg->msg.cmd = msg->rsp[1]; 3380 recv_msg->msg.data = recv_msg->msg_data; 3381 3382 /* 3383 * The message starts at byte 4 which follows the 3384 * the Channel Byte in the "GET MESSAGE" command 3385 */ 3386 recv_msg->msg.data_len = msg->rsp_size - 4; 3387 memcpy(recv_msg->msg_data, 3388 &(msg->rsp[4]), 3389 msg->rsp_size - 4); 3390 deliver_response(recv_msg); 3391 } 3392 } 3393 3394 return rv; 3395 } 3396 3397 static void copy_event_into_recv_msg(struct ipmi_recv_msg *recv_msg, 3398 struct ipmi_smi_msg *msg) 3399 { 3400 struct ipmi_system_interface_addr *smi_addr; 3401 3402 recv_msg->msgid = 0; 3403 smi_addr = (struct ipmi_system_interface_addr *) &(recv_msg->addr); 3404 smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 3405 smi_addr->channel = IPMI_BMC_CHANNEL; 3406 smi_addr->lun = msg->rsp[0] & 3; 3407 recv_msg->recv_type = IPMI_ASYNC_EVENT_RECV_TYPE; 3408 recv_msg->msg.netfn = msg->rsp[0] >> 2; 3409 recv_msg->msg.cmd = msg->rsp[1]; 3410 memcpy(recv_msg->msg_data, &(msg->rsp[3]), msg->rsp_size - 3); 3411 recv_msg->msg.data = recv_msg->msg_data; 3412 recv_msg->msg.data_len = msg->rsp_size - 3; 3413 } 3414 3415 static int handle_read_event_rsp(ipmi_smi_t intf, 3416 struct ipmi_smi_msg *msg) 3417 { 3418 struct ipmi_recv_msg *recv_msg, *recv_msg2; 3419 struct list_head msgs; 3420 ipmi_user_t user; 3421 int rv = 0; 3422 int deliver_count = 0; 3423 unsigned long flags; 3424 3425 if (msg->rsp_size < 19) { 3426 /* Message is too small to be an IPMB event. */ 3427 ipmi_inc_stat(intf, invalid_events); 3428 return 0; 3429 } 3430 3431 if (msg->rsp[2] != 0) { 3432 /* An error getting the event, just ignore it. */ 3433 return 0; 3434 } 3435 3436 INIT_LIST_HEAD(&msgs); 3437 3438 spin_lock_irqsave(&intf->events_lock, flags); 3439 3440 ipmi_inc_stat(intf, events); 3441 3442 /* 3443 * Allocate and fill in one message for every user that is 3444 * getting events. 3445 */ 3446 rcu_read_lock(); 3447 list_for_each_entry_rcu(user, &intf->users, link) { 3448 if (!user->gets_events) 3449 continue; 3450 3451 recv_msg = ipmi_alloc_recv_msg(); 3452 if (!recv_msg) { 3453 rcu_read_unlock(); 3454 list_for_each_entry_safe(recv_msg, recv_msg2, &msgs, 3455 link) { 3456 list_del(&recv_msg->link); 3457 ipmi_free_recv_msg(recv_msg); 3458 } 3459 /* 3460 * We couldn't allocate memory for the 3461 * message, so requeue it for handling 3462 * later. 3463 */ 3464 rv = 1; 3465 goto out; 3466 } 3467 3468 deliver_count++; 3469 3470 copy_event_into_recv_msg(recv_msg, msg); 3471 recv_msg->user = user; 3472 kref_get(&user->refcount); 3473 list_add_tail(&(recv_msg->link), &msgs); 3474 } 3475 rcu_read_unlock(); 3476 3477 if (deliver_count) { 3478 /* Now deliver all the messages. */ 3479 list_for_each_entry_safe(recv_msg, recv_msg2, &msgs, link) { 3480 list_del(&recv_msg->link); 3481 deliver_response(recv_msg); 3482 } 3483 } else if (intf->waiting_events_count < MAX_EVENTS_IN_QUEUE) { 3484 /* 3485 * No one to receive the message, put it in queue if there's 3486 * not already too many things in the queue. 3487 */ 3488 recv_msg = ipmi_alloc_recv_msg(); 3489 if (!recv_msg) { 3490 /* 3491 * We couldn't allocate memory for the 3492 * message, so requeue it for handling 3493 * later. 3494 */ 3495 rv = 1; 3496 goto out; 3497 } 3498 3499 copy_event_into_recv_msg(recv_msg, msg); 3500 list_add_tail(&(recv_msg->link), &(intf->waiting_events)); 3501 intf->waiting_events_count++; 3502 } else if (!intf->event_msg_printed) { 3503 /* 3504 * There's too many things in the queue, discard this 3505 * message. 3506 */ 3507 printk(KERN_WARNING PFX "Event queue full, discarding" 3508 " incoming events\n"); 3509 intf->event_msg_printed = 1; 3510 } 3511 3512 out: 3513 spin_unlock_irqrestore(&(intf->events_lock), flags); 3514 3515 return rv; 3516 } 3517 3518 static int handle_bmc_rsp(ipmi_smi_t intf, 3519 struct ipmi_smi_msg *msg) 3520 { 3521 struct ipmi_recv_msg *recv_msg; 3522 struct ipmi_user *user; 3523 3524 recv_msg = (struct ipmi_recv_msg *) msg->user_data; 3525 if (recv_msg == NULL) { 3526 printk(KERN_WARNING 3527 "IPMI message received with no owner. This\n" 3528 "could be because of a malformed message, or\n" 3529 "because of a hardware error. Contact your\n" 3530 "hardware vender for assistance\n"); 3531 return 0; 3532 } 3533 3534 user = recv_msg->user; 3535 /* Make sure the user still exists. */ 3536 if (user && !user->valid) { 3537 /* The user for the message went away, so give up. */ 3538 ipmi_inc_stat(intf, unhandled_local_responses); 3539 ipmi_free_recv_msg(recv_msg); 3540 } else { 3541 struct ipmi_system_interface_addr *smi_addr; 3542 3543 ipmi_inc_stat(intf, handled_local_responses); 3544 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE; 3545 recv_msg->msgid = msg->msgid; 3546 smi_addr = ((struct ipmi_system_interface_addr *) 3547 &(recv_msg->addr)); 3548 smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 3549 smi_addr->channel = IPMI_BMC_CHANNEL; 3550 smi_addr->lun = msg->rsp[0] & 3; 3551 recv_msg->msg.netfn = msg->rsp[0] >> 2; 3552 recv_msg->msg.cmd = msg->rsp[1]; 3553 memcpy(recv_msg->msg_data, 3554 &(msg->rsp[2]), 3555 msg->rsp_size - 2); 3556 recv_msg->msg.data = recv_msg->msg_data; 3557 recv_msg->msg.data_len = msg->rsp_size - 2; 3558 deliver_response(recv_msg); 3559 } 3560 3561 return 0; 3562 } 3563 3564 /* 3565 * Handle a new message. Return 1 if the message should be requeued, 3566 * 0 if the message should be freed, or -1 if the message should not 3567 * be freed or requeued. 3568 */ 3569 static int handle_new_recv_msg(ipmi_smi_t intf, 3570 struct ipmi_smi_msg *msg) 3571 { 3572 int requeue; 3573 int chan; 3574 3575 #ifdef DEBUG_MSGING 3576 int m; 3577 printk("Recv:"); 3578 for (m = 0; m < msg->rsp_size; m++) 3579 printk(" %2.2x", msg->rsp[m]); 3580 printk("\n"); 3581 #endif 3582 if (msg->rsp_size < 2) { 3583 /* Message is too small to be correct. */ 3584 printk(KERN_WARNING PFX "BMC returned to small a message" 3585 " for netfn %x cmd %x, got %d bytes\n", 3586 (msg->data[0] >> 2) | 1, msg->data[1], msg->rsp_size); 3587 3588 /* Generate an error response for the message. */ 3589 msg->rsp[0] = msg->data[0] | (1 << 2); 3590 msg->rsp[1] = msg->data[1]; 3591 msg->rsp[2] = IPMI_ERR_UNSPECIFIED; 3592 msg->rsp_size = 3; 3593 } else if (((msg->rsp[0] >> 2) != ((msg->data[0] >> 2) | 1)) 3594 || (msg->rsp[1] != msg->data[1])) { 3595 /* 3596 * The NetFN and Command in the response is not even 3597 * marginally correct. 3598 */ 3599 printk(KERN_WARNING PFX "BMC returned incorrect response," 3600 " expected netfn %x cmd %x, got netfn %x cmd %x\n", 3601 (msg->data[0] >> 2) | 1, msg->data[1], 3602 msg->rsp[0] >> 2, msg->rsp[1]); 3603 3604 /* Generate an error response for the message. */ 3605 msg->rsp[0] = msg->data[0] | (1 << 2); 3606 msg->rsp[1] = msg->data[1]; 3607 msg->rsp[2] = IPMI_ERR_UNSPECIFIED; 3608 msg->rsp_size = 3; 3609 } 3610 3611 if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2)) 3612 && (msg->rsp[1] == IPMI_SEND_MSG_CMD) 3613 && (msg->user_data != NULL)) { 3614 /* 3615 * It's a response to a response we sent. For this we 3616 * deliver a send message response to the user. 3617 */ 3618 struct ipmi_recv_msg *recv_msg = msg->user_data; 3619 3620 requeue = 0; 3621 if (msg->rsp_size < 2) 3622 /* Message is too small to be correct. */ 3623 goto out; 3624 3625 chan = msg->data[2] & 0x0f; 3626 if (chan >= IPMI_MAX_CHANNELS) 3627 /* Invalid channel number */ 3628 goto out; 3629 3630 if (!recv_msg) 3631 goto out; 3632 3633 /* Make sure the user still exists. */ 3634 if (!recv_msg->user || !recv_msg->user->valid) 3635 goto out; 3636 3637 recv_msg->recv_type = IPMI_RESPONSE_RESPONSE_TYPE; 3638 recv_msg->msg.data = recv_msg->msg_data; 3639 recv_msg->msg.data_len = 1; 3640 recv_msg->msg_data[0] = msg->rsp[2]; 3641 deliver_response(recv_msg); 3642 } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2)) 3643 && (msg->rsp[1] == IPMI_GET_MSG_CMD)) { 3644 /* It's from the receive queue. */ 3645 chan = msg->rsp[3] & 0xf; 3646 if (chan >= IPMI_MAX_CHANNELS) { 3647 /* Invalid channel number */ 3648 requeue = 0; 3649 goto out; 3650 } 3651 3652 /* 3653 * We need to make sure the channels have been initialized. 3654 * The channel_handler routine will set the "curr_channel" 3655 * equal to or greater than IPMI_MAX_CHANNELS when all the 3656 * channels for this interface have been initialized. 3657 */ 3658 if (intf->curr_channel < IPMI_MAX_CHANNELS) { 3659 requeue = 0; /* Throw the message away */ 3660 goto out; 3661 } 3662 3663 switch (intf->channels[chan].medium) { 3664 case IPMI_CHANNEL_MEDIUM_IPMB: 3665 if (msg->rsp[4] & 0x04) { 3666 /* 3667 * It's a response, so find the 3668 * requesting message and send it up. 3669 */ 3670 requeue = handle_ipmb_get_msg_rsp(intf, msg); 3671 } else { 3672 /* 3673 * It's a command to the SMS from some other 3674 * entity. Handle that. 3675 */ 3676 requeue = handle_ipmb_get_msg_cmd(intf, msg); 3677 } 3678 break; 3679 3680 case IPMI_CHANNEL_MEDIUM_8023LAN: 3681 case IPMI_CHANNEL_MEDIUM_ASYNC: 3682 if (msg->rsp[6] & 0x04) { 3683 /* 3684 * It's a response, so find the 3685 * requesting message and send it up. 3686 */ 3687 requeue = handle_lan_get_msg_rsp(intf, msg); 3688 } else { 3689 /* 3690 * It's a command to the SMS from some other 3691 * entity. Handle that. 3692 */ 3693 requeue = handle_lan_get_msg_cmd(intf, msg); 3694 } 3695 break; 3696 3697 default: 3698 /* Check for OEM Channels. Clients had better 3699 register for these commands. */ 3700 if ((intf->channels[chan].medium 3701 >= IPMI_CHANNEL_MEDIUM_OEM_MIN) 3702 && (intf->channels[chan].medium 3703 <= IPMI_CHANNEL_MEDIUM_OEM_MAX)) { 3704 requeue = handle_oem_get_msg_cmd(intf, msg); 3705 } else { 3706 /* 3707 * We don't handle the channel type, so just 3708 * free the message. 3709 */ 3710 requeue = 0; 3711 } 3712 } 3713 3714 } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2)) 3715 && (msg->rsp[1] == IPMI_READ_EVENT_MSG_BUFFER_CMD)) { 3716 /* It's an asyncronous event. */ 3717 requeue = handle_read_event_rsp(intf, msg); 3718 } else { 3719 /* It's a response from the local BMC. */ 3720 requeue = handle_bmc_rsp(intf, msg); 3721 } 3722 3723 out: 3724 return requeue; 3725 } 3726 3727 /* Handle a new message from the lower layer. */ 3728 void ipmi_smi_msg_received(ipmi_smi_t intf, 3729 struct ipmi_smi_msg *msg) 3730 { 3731 unsigned long flags = 0; /* keep us warning-free. */ 3732 int rv; 3733 int run_to_completion; 3734 3735 3736 if ((msg->data_size >= 2) 3737 && (msg->data[0] == (IPMI_NETFN_APP_REQUEST << 2)) 3738 && (msg->data[1] == IPMI_SEND_MSG_CMD) 3739 && (msg->user_data == NULL)) { 3740 /* 3741 * This is the local response to a command send, start 3742 * the timer for these. The user_data will not be 3743 * NULL if this is a response send, and we will let 3744 * response sends just go through. 3745 */ 3746 3747 /* 3748 * Check for errors, if we get certain errors (ones 3749 * that mean basically we can try again later), we 3750 * ignore them and start the timer. Otherwise we 3751 * report the error immediately. 3752 */ 3753 if ((msg->rsp_size >= 3) && (msg->rsp[2] != 0) 3754 && (msg->rsp[2] != IPMI_NODE_BUSY_ERR) 3755 && (msg->rsp[2] != IPMI_LOST_ARBITRATION_ERR) 3756 && (msg->rsp[2] != IPMI_BUS_ERR) 3757 && (msg->rsp[2] != IPMI_NAK_ON_WRITE_ERR)) { 3758 int chan = msg->rsp[3] & 0xf; 3759 3760 /* Got an error sending the message, handle it. */ 3761 if (chan >= IPMI_MAX_CHANNELS) 3762 ; /* This shouldn't happen */ 3763 else if ((intf->channels[chan].medium 3764 == IPMI_CHANNEL_MEDIUM_8023LAN) 3765 || (intf->channels[chan].medium 3766 == IPMI_CHANNEL_MEDIUM_ASYNC)) 3767 ipmi_inc_stat(intf, sent_lan_command_errs); 3768 else 3769 ipmi_inc_stat(intf, sent_ipmb_command_errs); 3770 intf_err_seq(intf, msg->msgid, msg->rsp[2]); 3771 } else 3772 /* The message was sent, start the timer. */ 3773 intf_start_seq_timer(intf, msg->msgid); 3774 3775 ipmi_free_smi_msg(msg); 3776 goto out; 3777 } 3778 3779 /* 3780 * To preserve message order, if the list is not empty, we 3781 * tack this message onto the end of the list. 3782 */ 3783 run_to_completion = intf->run_to_completion; 3784 if (!run_to_completion) 3785 spin_lock_irqsave(&intf->waiting_msgs_lock, flags); 3786 if (!list_empty(&intf->waiting_msgs)) { 3787 list_add_tail(&msg->link, &intf->waiting_msgs); 3788 if (!run_to_completion) 3789 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags); 3790 goto out; 3791 } 3792 if (!run_to_completion) 3793 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags); 3794 3795 rv = handle_new_recv_msg(intf, msg); 3796 if (rv > 0) { 3797 /* 3798 * Could not handle the message now, just add it to a 3799 * list to handle later. 3800 */ 3801 run_to_completion = intf->run_to_completion; 3802 if (!run_to_completion) 3803 spin_lock_irqsave(&intf->waiting_msgs_lock, flags); 3804 list_add_tail(&msg->link, &intf->waiting_msgs); 3805 if (!run_to_completion) 3806 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags); 3807 } else if (rv == 0) { 3808 ipmi_free_smi_msg(msg); 3809 } 3810 3811 out: 3812 return; 3813 } 3814 EXPORT_SYMBOL(ipmi_smi_msg_received); 3815 3816 void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf) 3817 { 3818 ipmi_user_t user; 3819 3820 rcu_read_lock(); 3821 list_for_each_entry_rcu(user, &intf->users, link) { 3822 if (!user->handler->ipmi_watchdog_pretimeout) 3823 continue; 3824 3825 user->handler->ipmi_watchdog_pretimeout(user->handler_data); 3826 } 3827 rcu_read_unlock(); 3828 } 3829 EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout); 3830 3831 static struct ipmi_smi_msg * 3832 smi_from_recv_msg(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg, 3833 unsigned char seq, long seqid) 3834 { 3835 struct ipmi_smi_msg *smi_msg = ipmi_alloc_smi_msg(); 3836 if (!smi_msg) 3837 /* 3838 * If we can't allocate the message, then just return, we 3839 * get 4 retries, so this should be ok. 3840 */ 3841 return NULL; 3842 3843 memcpy(smi_msg->data, recv_msg->msg.data, recv_msg->msg.data_len); 3844 smi_msg->data_size = recv_msg->msg.data_len; 3845 smi_msg->msgid = STORE_SEQ_IN_MSGID(seq, seqid); 3846 3847 #ifdef DEBUG_MSGING 3848 { 3849 int m; 3850 printk("Resend: "); 3851 for (m = 0; m < smi_msg->data_size; m++) 3852 printk(" %2.2x", smi_msg->data[m]); 3853 printk("\n"); 3854 } 3855 #endif 3856 return smi_msg; 3857 } 3858 3859 static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent, 3860 struct list_head *timeouts, long timeout_period, 3861 int slot, unsigned long *flags) 3862 { 3863 struct ipmi_recv_msg *msg; 3864 struct ipmi_smi_handlers *handlers; 3865 3866 if (intf->intf_num == -1) 3867 return; 3868 3869 if (!ent->inuse) 3870 return; 3871 3872 ent->timeout -= timeout_period; 3873 if (ent->timeout > 0) 3874 return; 3875 3876 if (ent->retries_left == 0) { 3877 /* The message has used all its retries. */ 3878 ent->inuse = 0; 3879 msg = ent->recv_msg; 3880 list_add_tail(&msg->link, timeouts); 3881 if (ent->broadcast) 3882 ipmi_inc_stat(intf, timed_out_ipmb_broadcasts); 3883 else if (is_lan_addr(&ent->recv_msg->addr)) 3884 ipmi_inc_stat(intf, timed_out_lan_commands); 3885 else 3886 ipmi_inc_stat(intf, timed_out_ipmb_commands); 3887 } else { 3888 struct ipmi_smi_msg *smi_msg; 3889 /* More retries, send again. */ 3890 3891 /* 3892 * Start with the max timer, set to normal timer after 3893 * the message is sent. 3894 */ 3895 ent->timeout = MAX_MSG_TIMEOUT; 3896 ent->retries_left--; 3897 smi_msg = smi_from_recv_msg(intf, ent->recv_msg, slot, 3898 ent->seqid); 3899 if (!smi_msg) { 3900 if (is_lan_addr(&ent->recv_msg->addr)) 3901 ipmi_inc_stat(intf, 3902 dropped_rexmit_lan_commands); 3903 else 3904 ipmi_inc_stat(intf, 3905 dropped_rexmit_ipmb_commands); 3906 return; 3907 } 3908 3909 spin_unlock_irqrestore(&intf->seq_lock, *flags); 3910 3911 /* 3912 * Send the new message. We send with a zero 3913 * priority. It timed out, I doubt time is that 3914 * critical now, and high priority messages are really 3915 * only for messages to the local MC, which don't get 3916 * resent. 3917 */ 3918 handlers = intf->handlers; 3919 if (handlers) { 3920 if (is_lan_addr(&ent->recv_msg->addr)) 3921 ipmi_inc_stat(intf, 3922 retransmitted_lan_commands); 3923 else 3924 ipmi_inc_stat(intf, 3925 retransmitted_ipmb_commands); 3926 3927 intf->handlers->sender(intf->send_info, 3928 smi_msg, 0); 3929 } else 3930 ipmi_free_smi_msg(smi_msg); 3931 3932 spin_lock_irqsave(&intf->seq_lock, *flags); 3933 } 3934 } 3935 3936 static void ipmi_timeout_handler(long timeout_period) 3937 { 3938 ipmi_smi_t intf; 3939 struct list_head timeouts; 3940 struct ipmi_recv_msg *msg, *msg2; 3941 struct ipmi_smi_msg *smi_msg, *smi_msg2; 3942 unsigned long flags; 3943 int i; 3944 3945 rcu_read_lock(); 3946 list_for_each_entry_rcu(intf, &ipmi_interfaces, link) { 3947 /* See if any waiting messages need to be processed. */ 3948 spin_lock_irqsave(&intf->waiting_msgs_lock, flags); 3949 list_for_each_entry_safe(smi_msg, smi_msg2, 3950 &intf->waiting_msgs, link) { 3951 if (!handle_new_recv_msg(intf, smi_msg)) { 3952 list_del(&smi_msg->link); 3953 ipmi_free_smi_msg(smi_msg); 3954 } else { 3955 /* 3956 * To preserve message order, quit if we 3957 * can't handle a message. 3958 */ 3959 break; 3960 } 3961 } 3962 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags); 3963 3964 /* 3965 * Go through the seq table and find any messages that 3966 * have timed out, putting them in the timeouts 3967 * list. 3968 */ 3969 INIT_LIST_HEAD(&timeouts); 3970 spin_lock_irqsave(&intf->seq_lock, flags); 3971 for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) 3972 check_msg_timeout(intf, &(intf->seq_table[i]), 3973 &timeouts, timeout_period, i, 3974 &flags); 3975 spin_unlock_irqrestore(&intf->seq_lock, flags); 3976 3977 list_for_each_entry_safe(msg, msg2, &timeouts, link) 3978 deliver_err_response(msg, IPMI_TIMEOUT_COMPLETION_CODE); 3979 3980 /* 3981 * Maintenance mode handling. Check the timeout 3982 * optimistically before we claim the lock. It may 3983 * mean a timeout gets missed occasionally, but that 3984 * only means the timeout gets extended by one period 3985 * in that case. No big deal, and it avoids the lock 3986 * most of the time. 3987 */ 3988 if (intf->auto_maintenance_timeout > 0) { 3989 spin_lock_irqsave(&intf->maintenance_mode_lock, flags); 3990 if (intf->auto_maintenance_timeout > 0) { 3991 intf->auto_maintenance_timeout 3992 -= timeout_period; 3993 if (!intf->maintenance_mode 3994 && (intf->auto_maintenance_timeout <= 0)) { 3995 intf->maintenance_mode_enable = 0; 3996 maintenance_mode_update(intf); 3997 } 3998 } 3999 spin_unlock_irqrestore(&intf->maintenance_mode_lock, 4000 flags); 4001 } 4002 } 4003 rcu_read_unlock(); 4004 } 4005 4006 static void ipmi_request_event(void) 4007 { 4008 ipmi_smi_t intf; 4009 struct ipmi_smi_handlers *handlers; 4010 4011 rcu_read_lock(); 4012 /* 4013 * Called from the timer, no need to check if handlers is 4014 * valid. 4015 */ 4016 list_for_each_entry_rcu(intf, &ipmi_interfaces, link) { 4017 /* No event requests when in maintenance mode. */ 4018 if (intf->maintenance_mode_enable) 4019 continue; 4020 4021 handlers = intf->handlers; 4022 if (handlers) 4023 handlers->request_events(intf->send_info); 4024 } 4025 rcu_read_unlock(); 4026 } 4027 4028 static struct timer_list ipmi_timer; 4029 4030 /* Call every ~100 ms. */ 4031 #define IPMI_TIMEOUT_TIME 100 4032 4033 /* How many jiffies does it take to get to the timeout time. */ 4034 #define IPMI_TIMEOUT_JIFFIES ((IPMI_TIMEOUT_TIME * HZ) / 1000) 4035 4036 /* 4037 * Request events from the queue every second (this is the number of 4038 * IPMI_TIMEOUT_TIMES between event requests). Hopefully, in the 4039 * future, IPMI will add a way to know immediately if an event is in 4040 * the queue and this silliness can go away. 4041 */ 4042 #define IPMI_REQUEST_EV_TIME (1000 / (IPMI_TIMEOUT_TIME)) 4043 4044 static atomic_t stop_operation; 4045 static unsigned int ticks_to_req_ev = IPMI_REQUEST_EV_TIME; 4046 4047 static void ipmi_timeout(unsigned long data) 4048 { 4049 if (atomic_read(&stop_operation)) 4050 return; 4051 4052 ticks_to_req_ev--; 4053 if (ticks_to_req_ev == 0) { 4054 ipmi_request_event(); 4055 ticks_to_req_ev = IPMI_REQUEST_EV_TIME; 4056 } 4057 4058 ipmi_timeout_handler(IPMI_TIMEOUT_TIME); 4059 4060 mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES); 4061 } 4062 4063 4064 static atomic_t smi_msg_inuse_count = ATOMIC_INIT(0); 4065 static atomic_t recv_msg_inuse_count = ATOMIC_INIT(0); 4066 4067 /* FIXME - convert these to slabs. */ 4068 static void free_smi_msg(struct ipmi_smi_msg *msg) 4069 { 4070 atomic_dec(&smi_msg_inuse_count); 4071 kfree(msg); 4072 } 4073 4074 struct ipmi_smi_msg *ipmi_alloc_smi_msg(void) 4075 { 4076 struct ipmi_smi_msg *rv; 4077 rv = kmalloc(sizeof(struct ipmi_smi_msg), GFP_ATOMIC); 4078 if (rv) { 4079 rv->done = free_smi_msg; 4080 rv->user_data = NULL; 4081 atomic_inc(&smi_msg_inuse_count); 4082 } 4083 return rv; 4084 } 4085 EXPORT_SYMBOL(ipmi_alloc_smi_msg); 4086 4087 static void free_recv_msg(struct ipmi_recv_msg *msg) 4088 { 4089 atomic_dec(&recv_msg_inuse_count); 4090 kfree(msg); 4091 } 4092 4093 static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void) 4094 { 4095 struct ipmi_recv_msg *rv; 4096 4097 rv = kmalloc(sizeof(struct ipmi_recv_msg), GFP_ATOMIC); 4098 if (rv) { 4099 rv->user = NULL; 4100 rv->done = free_recv_msg; 4101 atomic_inc(&recv_msg_inuse_count); 4102 } 4103 return rv; 4104 } 4105 4106 void ipmi_free_recv_msg(struct ipmi_recv_msg *msg) 4107 { 4108 if (msg->user) 4109 kref_put(&msg->user->refcount, free_user); 4110 msg->done(msg); 4111 } 4112 EXPORT_SYMBOL(ipmi_free_recv_msg); 4113 4114 #ifdef CONFIG_IPMI_PANIC_EVENT 4115 4116 static void dummy_smi_done_handler(struct ipmi_smi_msg *msg) 4117 { 4118 } 4119 4120 static void dummy_recv_done_handler(struct ipmi_recv_msg *msg) 4121 { 4122 } 4123 4124 #ifdef CONFIG_IPMI_PANIC_STRING 4125 static void event_receiver_fetcher(ipmi_smi_t intf, struct ipmi_recv_msg *msg) 4126 { 4127 if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) 4128 && (msg->msg.netfn == IPMI_NETFN_SENSOR_EVENT_RESPONSE) 4129 && (msg->msg.cmd == IPMI_GET_EVENT_RECEIVER_CMD) 4130 && (msg->msg.data[0] == IPMI_CC_NO_ERROR)) { 4131 /* A get event receiver command, save it. */ 4132 intf->event_receiver = msg->msg.data[1]; 4133 intf->event_receiver_lun = msg->msg.data[2] & 0x3; 4134 } 4135 } 4136 4137 static void device_id_fetcher(ipmi_smi_t intf, struct ipmi_recv_msg *msg) 4138 { 4139 if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) 4140 && (msg->msg.netfn == IPMI_NETFN_APP_RESPONSE) 4141 && (msg->msg.cmd == IPMI_GET_DEVICE_ID_CMD) 4142 && (msg->msg.data[0] == IPMI_CC_NO_ERROR)) { 4143 /* 4144 * A get device id command, save if we are an event 4145 * receiver or generator. 4146 */ 4147 intf->local_sel_device = (msg->msg.data[6] >> 2) & 1; 4148 intf->local_event_generator = (msg->msg.data[6] >> 5) & 1; 4149 } 4150 } 4151 #endif 4152 4153 static void send_panic_events(char *str) 4154 { 4155 struct kernel_ipmi_msg msg; 4156 ipmi_smi_t intf; 4157 unsigned char data[16]; 4158 struct ipmi_system_interface_addr *si; 4159 struct ipmi_addr addr; 4160 struct ipmi_smi_msg smi_msg; 4161 struct ipmi_recv_msg recv_msg; 4162 4163 si = (struct ipmi_system_interface_addr *) &addr; 4164 si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 4165 si->channel = IPMI_BMC_CHANNEL; 4166 si->lun = 0; 4167 4168 /* Fill in an event telling that we have failed. */ 4169 msg.netfn = 0x04; /* Sensor or Event. */ 4170 msg.cmd = 2; /* Platform event command. */ 4171 msg.data = data; 4172 msg.data_len = 8; 4173 data[0] = 0x41; /* Kernel generator ID, IPMI table 5-4 */ 4174 data[1] = 0x03; /* This is for IPMI 1.0. */ 4175 data[2] = 0x20; /* OS Critical Stop, IPMI table 36-3 */ 4176 data[4] = 0x6f; /* Sensor specific, IPMI table 36-1 */ 4177 data[5] = 0xa1; /* Runtime stop OEM bytes 2 & 3. */ 4178 4179 /* 4180 * Put a few breadcrumbs in. Hopefully later we can add more things 4181 * to make the panic events more useful. 4182 */ 4183 if (str) { 4184 data[3] = str[0]; 4185 data[6] = str[1]; 4186 data[7] = str[2]; 4187 } 4188 4189 smi_msg.done = dummy_smi_done_handler; 4190 recv_msg.done = dummy_recv_done_handler; 4191 4192 /* For every registered interface, send the event. */ 4193 list_for_each_entry_rcu(intf, &ipmi_interfaces, link) { 4194 if (!intf->handlers) 4195 /* Interface is not ready. */ 4196 continue; 4197 4198 intf->run_to_completion = 1; 4199 /* Send the event announcing the panic. */ 4200 intf->handlers->set_run_to_completion(intf->send_info, 1); 4201 i_ipmi_request(NULL, 4202 intf, 4203 &addr, 4204 0, 4205 &msg, 4206 intf, 4207 &smi_msg, 4208 &recv_msg, 4209 0, 4210 intf->channels[0].address, 4211 intf->channels[0].lun, 4212 0, 1); /* Don't retry, and don't wait. */ 4213 } 4214 4215 #ifdef CONFIG_IPMI_PANIC_STRING 4216 /* 4217 * On every interface, dump a bunch of OEM event holding the 4218 * string. 4219 */ 4220 if (!str) 4221 return; 4222 4223 /* For every registered interface, send the event. */ 4224 list_for_each_entry_rcu(intf, &ipmi_interfaces, link) { 4225 char *p = str; 4226 struct ipmi_ipmb_addr *ipmb; 4227 int j; 4228 4229 if (intf->intf_num == -1) 4230 /* Interface was not ready yet. */ 4231 continue; 4232 4233 /* 4234 * intf_num is used as an marker to tell if the 4235 * interface is valid. Thus we need a read barrier to 4236 * make sure data fetched before checking intf_num 4237 * won't be used. 4238 */ 4239 smp_rmb(); 4240 4241 /* 4242 * First job here is to figure out where to send the 4243 * OEM events. There's no way in IPMI to send OEM 4244 * events using an event send command, so we have to 4245 * find the SEL to put them in and stick them in 4246 * there. 4247 */ 4248 4249 /* Get capabilities from the get device id. */ 4250 intf->local_sel_device = 0; 4251 intf->local_event_generator = 0; 4252 intf->event_receiver = 0; 4253 4254 /* Request the device info from the local MC. */ 4255 msg.netfn = IPMI_NETFN_APP_REQUEST; 4256 msg.cmd = IPMI_GET_DEVICE_ID_CMD; 4257 msg.data = NULL; 4258 msg.data_len = 0; 4259 intf->null_user_handler = device_id_fetcher; 4260 i_ipmi_request(NULL, 4261 intf, 4262 &addr, 4263 0, 4264 &msg, 4265 intf, 4266 &smi_msg, 4267 &recv_msg, 4268 0, 4269 intf->channels[0].address, 4270 intf->channels[0].lun, 4271 0, 1); /* Don't retry, and don't wait. */ 4272 4273 if (intf->local_event_generator) { 4274 /* Request the event receiver from the local MC. */ 4275 msg.netfn = IPMI_NETFN_SENSOR_EVENT_REQUEST; 4276 msg.cmd = IPMI_GET_EVENT_RECEIVER_CMD; 4277 msg.data = NULL; 4278 msg.data_len = 0; 4279 intf->null_user_handler = event_receiver_fetcher; 4280 i_ipmi_request(NULL, 4281 intf, 4282 &addr, 4283 0, 4284 &msg, 4285 intf, 4286 &smi_msg, 4287 &recv_msg, 4288 0, 4289 intf->channels[0].address, 4290 intf->channels[0].lun, 4291 0, 1); /* no retry, and no wait. */ 4292 } 4293 intf->null_user_handler = NULL; 4294 4295 /* 4296 * Validate the event receiver. The low bit must not 4297 * be 1 (it must be a valid IPMB address), it cannot 4298 * be zero, and it must not be my address. 4299 */ 4300 if (((intf->event_receiver & 1) == 0) 4301 && (intf->event_receiver != 0) 4302 && (intf->event_receiver != intf->channels[0].address)) { 4303 /* 4304 * The event receiver is valid, send an IPMB 4305 * message. 4306 */ 4307 ipmb = (struct ipmi_ipmb_addr *) &addr; 4308 ipmb->addr_type = IPMI_IPMB_ADDR_TYPE; 4309 ipmb->channel = 0; /* FIXME - is this right? */ 4310 ipmb->lun = intf->event_receiver_lun; 4311 ipmb->slave_addr = intf->event_receiver; 4312 } else if (intf->local_sel_device) { 4313 /* 4314 * The event receiver was not valid (or was 4315 * me), but I am an SEL device, just dump it 4316 * in my SEL. 4317 */ 4318 si = (struct ipmi_system_interface_addr *) &addr; 4319 si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 4320 si->channel = IPMI_BMC_CHANNEL; 4321 si->lun = 0; 4322 } else 4323 continue; /* No where to send the event. */ 4324 4325 msg.netfn = IPMI_NETFN_STORAGE_REQUEST; /* Storage. */ 4326 msg.cmd = IPMI_ADD_SEL_ENTRY_CMD; 4327 msg.data = data; 4328 msg.data_len = 16; 4329 4330 j = 0; 4331 while (*p) { 4332 int size = strlen(p); 4333 4334 if (size > 11) 4335 size = 11; 4336 data[0] = 0; 4337 data[1] = 0; 4338 data[2] = 0xf0; /* OEM event without timestamp. */ 4339 data[3] = intf->channels[0].address; 4340 data[4] = j++; /* sequence # */ 4341 /* 4342 * Always give 11 bytes, so strncpy will fill 4343 * it with zeroes for me. 4344 */ 4345 strncpy(data+5, p, 11); 4346 p += size; 4347 4348 i_ipmi_request(NULL, 4349 intf, 4350 &addr, 4351 0, 4352 &msg, 4353 intf, 4354 &smi_msg, 4355 &recv_msg, 4356 0, 4357 intf->channels[0].address, 4358 intf->channels[0].lun, 4359 0, 1); /* no retry, and no wait. */ 4360 } 4361 } 4362 #endif /* CONFIG_IPMI_PANIC_STRING */ 4363 } 4364 #endif /* CONFIG_IPMI_PANIC_EVENT */ 4365 4366 static int has_panicked; 4367 4368 static int panic_event(struct notifier_block *this, 4369 unsigned long event, 4370 void *ptr) 4371 { 4372 ipmi_smi_t intf; 4373 4374 if (has_panicked) 4375 return NOTIFY_DONE; 4376 has_panicked = 1; 4377 4378 /* For every registered interface, set it to run to completion. */ 4379 list_for_each_entry_rcu(intf, &ipmi_interfaces, link) { 4380 if (!intf->handlers) 4381 /* Interface is not ready. */ 4382 continue; 4383 4384 intf->run_to_completion = 1; 4385 intf->handlers->set_run_to_completion(intf->send_info, 1); 4386 } 4387 4388 #ifdef CONFIG_IPMI_PANIC_EVENT 4389 send_panic_events(ptr); 4390 #endif 4391 4392 return NOTIFY_DONE; 4393 } 4394 4395 static struct notifier_block panic_block = { 4396 .notifier_call = panic_event, 4397 .next = NULL, 4398 .priority = 200 /* priority: INT_MAX >= x >= 0 */ 4399 }; 4400 4401 static int ipmi_init_msghandler(void) 4402 { 4403 int rv; 4404 4405 if (initialized) 4406 return 0; 4407 4408 rv = driver_register(&ipmidriver.driver); 4409 if (rv) { 4410 printk(KERN_ERR PFX "Could not register IPMI driver\n"); 4411 return rv; 4412 } 4413 4414 printk(KERN_INFO "ipmi message handler version " 4415 IPMI_DRIVER_VERSION "\n"); 4416 4417 #ifdef CONFIG_PROC_FS 4418 proc_ipmi_root = proc_mkdir("ipmi", NULL); 4419 if (!proc_ipmi_root) { 4420 printk(KERN_ERR PFX "Unable to create IPMI proc dir"); 4421 return -ENOMEM; 4422 } 4423 4424 #endif /* CONFIG_PROC_FS */ 4425 4426 setup_timer(&ipmi_timer, ipmi_timeout, 0); 4427 mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES); 4428 4429 atomic_notifier_chain_register(&panic_notifier_list, &panic_block); 4430 4431 initialized = 1; 4432 4433 return 0; 4434 } 4435 4436 static __init int ipmi_init_msghandler_mod(void) 4437 { 4438 ipmi_init_msghandler(); 4439 return 0; 4440 } 4441 4442 static __exit void cleanup_ipmi(void) 4443 { 4444 int count; 4445 4446 if (!initialized) 4447 return; 4448 4449 atomic_notifier_chain_unregister(&panic_notifier_list, &panic_block); 4450 4451 /* 4452 * This can't be called if any interfaces exist, so no worry 4453 * about shutting down the interfaces. 4454 */ 4455 4456 /* 4457 * Tell the timer to stop, then wait for it to stop. This 4458 * avoids problems with race conditions removing the timer 4459 * here. 4460 */ 4461 atomic_inc(&stop_operation); 4462 del_timer_sync(&ipmi_timer); 4463 4464 #ifdef CONFIG_PROC_FS 4465 remove_proc_entry(proc_ipmi_root->name, NULL); 4466 #endif /* CONFIG_PROC_FS */ 4467 4468 driver_unregister(&ipmidriver.driver); 4469 4470 initialized = 0; 4471 4472 /* Check for buffer leaks. */ 4473 count = atomic_read(&smi_msg_inuse_count); 4474 if (count != 0) 4475 printk(KERN_WARNING PFX "SMI message count %d at exit\n", 4476 count); 4477 count = atomic_read(&recv_msg_inuse_count); 4478 if (count != 0) 4479 printk(KERN_WARNING PFX "recv message count %d at exit\n", 4480 count); 4481 } 4482 module_exit(cleanup_ipmi); 4483 4484 module_init(ipmi_init_msghandler_mod); 4485 MODULE_LICENSE("GPL"); 4486 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>"); 4487 MODULE_DESCRIPTION("Incoming and outgoing message routing for an IPMI" 4488 " interface."); 4489 MODULE_VERSION(IPMI_DRIVER_VERSION); 4490