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