char/ipmi/ipmi_msghandler.c

154 /* The default maximum number of message a user may have outstanding. */
158 		 "The most message a user may have outstanding.");
178  * The main "user" data structure.
190 	/* The interface this user is bound to. */
202 	struct ipmi_user *user;
269 	 * but may be changed by the user.
313 	/* Commands we got from the user that were invalid. */
319 	/* Responses from the MC that were delivered to a user. */
322 	/* Responses from the MC that were not delivered to a user. */
350 	/* The response was delivered to the user. */
377 	/* The response was delivered to the user. */
386 	/* The command was delivered to the user. */
472 	 * Messages queued for deliver to the user.
555 	 * interface comes in with a NULL user, call this routine with
597 	struct ipmi_user *user = container_of(ref, struct ipmi_user, refcount);
600 	owner = user->intf->owner;
601 	kref_put(&user->intf->refcount, intf_free);
603 	vfree(user);
606 static void release_ipmi_user(struct ipmi_user *user)
608 	kref_put(&user->refcount, free_ipmi_user);
611 static struct ipmi_user *acquire_ipmi_user(struct ipmi_user *user)
613 	if (!kref_get_unless_zero(&user->refcount))
615 	return user;
748 	 * keep things in order for the user.
942 	if (!msg->user) {
958 		atomic_dec(&msg->user->nr_msgs);
962 		 * refcount to the user.
1157 	 * We do this verification because the user can be deleted
1187 	 * We do this verification because the user can be deleted
1210 		     struct ipmi_user      **user)
1267 	/* Note that each existing user holds a refcount to the interface. */
1294 		*user = new_user;
1324 static void _ipmi_destroy_user(struct ipmi_user *user)
1326 	struct ipmi_smi  *intf = user->intf;
1333 	if (!refcount_dec_if_one(&user->destroyed))
1336 	if (user->handler->shutdown)
1337 		user->handler->shutdown(user->handler_data);
1339 	if (user->handler->ipmi_watchdog_pretimeout)
1342 	if (user->gets_events)
1345 	/* Remove the user from the interface's list and sequence table. */
1346 	list_del(&user->link);
1352 		    && (intf->seq_table[i].recv_msg->user == user)) {
1361 	 * Remove the user from the command receiver's table.  First
1369 		if (rcvr->user == user) {
1384 		if (msg->user != user)
1391 	release_ipmi_user(user);
1394 void ipmi_destroy_user(struct ipmi_user *user)
1396 	struct ipmi_smi *intf = user->intf;
1399 	_ipmi_destroy_user(user);
1402 	kref_put(&user->refcount, free_ipmi_user);
1406 int ipmi_get_version(struct ipmi_user *user,
1413 	user = acquire_ipmi_user(user);
1414 	if (!user)
1417 	rv = bmc_get_device_id(user->intf, NULL, &id, NULL, NULL);
1422 	release_ipmi_user(user);
1428 int ipmi_set_my_address(struct ipmi_user *user,
1434 	user = acquire_ipmi_user(user);
1435 	if (!user)
1442 		user->intf->addrinfo[channel].address = address;
1444 	release_ipmi_user(user);
1450 int ipmi_get_my_address(struct ipmi_user *user,
1456 	user = acquire_ipmi_user(user);
1457 	if (!user)
1464 		*address = user->intf->addrinfo[channel].address;
1466 	release_ipmi_user(user);
1472 int ipmi_set_my_LUN(struct ipmi_user *user,
1478 	user = acquire_ipmi_user(user);
1479 	if (!user)
1486 		user->intf->addrinfo[channel].lun = LUN & 0x3;
1488 	release_ipmi_user(user);
1494 int ipmi_get_my_LUN(struct ipmi_user *user,
1500 	user = acquire_ipmi_user(user);
1501 	if (!user)
1508 		*address = user->intf->addrinfo[channel].lun;
1510 	release_ipmi_user(user);
1516 int ipmi_get_maintenance_mode(struct ipmi_user *user)
1521 	user = acquire_ipmi_user(user);
1522 	if (!user)
1525 	spin_lock_irqsave(&user->intf->maintenance_mode_lock, flags);
1526 	mode = user->intf->maintenance_mode;
1527 	spin_unlock_irqrestore(&user->intf->maintenance_mode_lock, flags);
1528 	release_ipmi_user(user);
1541 int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode)
1545 	struct ipmi_smi *intf = user->intf;
1547 	user = acquire_ipmi_user(user);
1548 	if (!user)
1577 	release_ipmi_user(user);
1583 int ipmi_set_gets_events(struct ipmi_user *user, bool val)
1585 	struct ipmi_smi      *intf = user->intf;
1589 	user = acquire_ipmi_user(user);
1590 	if (!user)
1596 	if (user->gets_events == val)
1599 	user->gets_events = val;
1609 	while (user->gets_events && !list_empty(&intf->waiting_events)) {
1619 			msg->user = user;
1620 			kref_get(&user->refcount);
1627 	release_ipmi_user(user);
1665 int ipmi_register_for_cmd(struct ipmi_user *user,
1670 	struct ipmi_smi *intf = user->intf;
1674 	user = acquire_ipmi_user(user);
1675 	if (!user)
1686 	rcvr->user = user;
1704 	release_ipmi_user(user);
1710 int ipmi_unregister_for_cmd(struct ipmi_user *user,
1715 	struct ipmi_smi *intf = user->intf;
1720 	user = acquire_ipmi_user(user);
1721 	if (!user)
1731 		if (rcvr->user == user) {
1743 	release_ipmi_user(user);
1916 		 * We don't let the user do these, since we manage
2015 		 * It's a response, so use the user's sequence
2195 		 * It's a response, so use the user's sequence
2267  * Separate from ipmi_request so that the user does not have to be
2272 static int i_ipmi_request(struct ipmi_user     *user,
2291 	if (user) {
2292 		if (atomic_add_return(1, &user->nr_msgs) > max_msgs_per_user) {
2329 	recv_msg->user = user;
2330 	if (user)
2332 		kref_get(&user->refcount);
2373 	if (rv && user)
2374 		atomic_dec(&user->nr_msgs);
2391 int ipmi_request_settime(struct ipmi_user *user,
2403 	if (!user)
2406 	user = acquire_ipmi_user(user);
2407 	if (!user)
2410 	rv = check_addr(user->intf, addr, &saddr, &lun);
2412 		rv = i_ipmi_request(user,
2413 				    user->intf,
2425 	release_ipmi_user(user);
2430 int ipmi_request_supply_msgs(struct ipmi_user     *user,
2442 	if (!user)
2445 	user = acquire_ipmi_user(user);
2446 	if (!user)
2449 	rv = check_addr(user->intf, addr, &saddr, &lun);
2451 		rv = i_ipmi_request(user,
2452 				    user->intf,
2464 	release_ipmi_user(user);
3485 void ipmi_poll_interface(struct ipmi_user *user)
3487 	ipmi_poll(user->intf);
3508 	struct ipmi_user *user;
3512 	list_for_each_entry(user, &intf->users, link)
3513 		count += atomic_read(&user->nr_msgs);
3777 		struct ipmi_user *user = list_first_entry(&intf->users,
3780 		_ipmi_destroy_user(user);
3863 	struct ipmi_user         *user = NULL;
3885 		user = rcvr->user;
3886 		kref_get(&user->refcount);
3888 		user = NULL;
3891 	if (user == NULL) {
3892 		/* We didn't find a user, deliver an error response. */
3927 			kref_put(&user->refcount, free_ipmi_user);
3940 			recv_msg->user = user;
3969 	struct ipmi_user         *user = NULL;
3979 		user = rcvr->user;
3980 		kref_get(&user->refcount);
3982 		user = NULL;
3985 	if (user == NULL) {
3986 		/* We didn't find a user, deliver an error response. */
4013 			kref_put(&user->refcount, free_ipmi_user);
4027 			recv_msg->user = user;
4153 	struct ipmi_user         *user = NULL;
4175 		user = rcvr->user;
4176 		kref_get(&user->refcount);
4178 		user = NULL;
4181 	if (user == NULL) {
4182 		/* We didn't find a user, just give up and return an error. */
4217 			kref_put(&user->refcount, free_ipmi_user);
4233 			recv_msg->user = user;
4271 	struct ipmi_user *user = NULL;
4301 		user = rcvr->user;
4302 		kref_get(&user->refcount);
4304 		user = NULL;
4307 	if (user == NULL) {
4308 		/* We didn't find a user, just give up. */
4326 			kref_put(&user->refcount, free_ipmi_user);
4340 			recv_msg->user = user;
4387 	struct ipmi_user     *user;
4408 	 * Allocate and fill in one message for every user that is
4412 	list_for_each_entry(user, &intf->users, link) {
4413 		if (!user->gets_events)
4421 				user = recv_msg->user;
4424 				kref_put(&user->refcount, free_ipmi_user);
4438 		recv_msg->user = user;
4439 		kref_get(&user->refcount);
4634 		 * deliver a send message response to the user.
4847 		struct ipmi_user *user;
4850 		list_for_each_entry(user, &intf->users, link) {
4851 			if (user->handler->ipmi_watchdog_pretimeout)
4852 				user->handler->ipmi_watchdog_pretimeout(
4853 					user->handler_data);
4859 	 * Freeing the message can cause a user to be released, which
4867 		struct ipmi_user *user = msg->user;
4871 		if (refcount_read(&user->destroyed) == 0) {
4874 			atomic_dec(&user->nr_msgs);
4875 			user->handler->ipmi_recv_hndl(msg, user->handler_data);
5199 		rv->user = NULL;
5208 	if (msg->user && !oops_in_progress)
5209 		kref_put(&msg->user->refcount, free_ipmi_user);
5261 void ipmi_panic_request_and_wait(struct ipmi_user *user,
5265 	user->intf->run_to_completion = 1;
5266 	_ipmi_panic_request_and_wait(user->intf, addr, msg);
5446 	struct ipmi_user *user;
5483 		list_for_each_entry(user, &intf->users, link) {
5484 			if (user->handler->ipmi_panic_handler)
5485 				user->handler->ipmi_panic_handler(
5486 					user->handler_data);