Lines Matching defs:user
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.
184 * Set to NULL when the user is destroyed, a pointer to myself
196 /* The interface this user is bound to. */
210 static struct ipmi_user *acquire_ipmi_user(struct ipmi_user *user, int *index)
211 __acquires(user->release_barrier)
215 *index = srcu_read_lock(&user->release_barrier);
216 ruser = srcu_dereference(user->self, &user->release_barrier);
218 srcu_read_unlock(&user->release_barrier, *index);
222 static void release_ipmi_user(struct ipmi_user *user, int index)
224 srcu_read_unlock(&user->release_barrier, index);
230 struct ipmi_user *user;
297 * but may be changed by the user.
339 /* Commands we got from the user that were invalid. */
345 /* Responses from the MC that were delivered to a user. */
348 /* Responses from the MC that were not delivered to a user. */
376 /* The response was delivered to the user. */
403 /* The response was delivered to the user. */
412 /* The command was delivered to the user. */
576 * interface comes in with a NULL user, call this routine with
926 if (!msg->user) {
942 atomic_dec(&msg->user->nr_msgs);
945 struct ipmi_user *user = acquire_ipmi_user(msg->user, &index);
947 if (user) {
948 atomic_dec(&user->nr_msgs);
949 user->handler->ipmi_recv_hndl(msg, user->handler_data);
950 release_ipmi_user(user, index);
1145 * We do this verification because the user can be deleted
1175 * We do this verification because the user can be deleted
1197 struct ipmi_user *user = container_of(work, struct ipmi_user,
1200 cleanup_srcu_struct(&user->release_barrier);
1201 vfree(user);
1207 struct ipmi_user **user)
1263 /* Note that each existing user holds a refcount to the interface. */
1281 *user = new_user;
1320 struct ipmi_user *user = container_of(ref, struct ipmi_user, refcount);
1323 queue_work(remove_work_wq, &user->remove_work);
1326 static void _ipmi_destroy_user(struct ipmi_user *user)
1328 struct ipmi_smi *intf = user->intf;
1335 if (!acquire_ipmi_user(user, &i)) {
1337 * The user has already been cleaned up, just make sure
1340 synchronize_srcu(&user->release_barrier);
1344 rcu_assign_pointer(user->self, NULL);
1345 release_ipmi_user(user, i);
1347 synchronize_srcu(&user->release_barrier);
1349 if (user->handler->shutdown)
1350 user->handler->shutdown(user->handler_data);
1352 if (user->handler->ipmi_watchdog_pretimeout)
1355 if (user->gets_events)
1358 /* Remove the user from the interface's sequence table. */
1360 list_del_rcu(&user->link);
1365 && (intf->seq_table[i].recv_msg->user == user)) {
1374 * Remove the user from the command receiver's table. First
1382 if (rcvr->user == user) {
1401 int ipmi_destroy_user(struct ipmi_user *user)
1403 _ipmi_destroy_user(user);
1405 kref_put(&user->refcount, free_user);
1411 int ipmi_get_version(struct ipmi_user *user,
1418 user = acquire_ipmi_user(user, &index);
1419 if (!user)
1422 rv = bmc_get_device_id(user->intf, NULL, &id, NULL, NULL);
1427 release_ipmi_user(user, index);
1433 int ipmi_set_my_address(struct ipmi_user *user,
1439 user = acquire_ipmi_user(user, &index);
1440 if (!user)
1447 user->intf->addrinfo[channel].address = address;
1449 release_ipmi_user(user, index);
1455 int ipmi_get_my_address(struct ipmi_user *user,
1461 user = acquire_ipmi_user(user, &index);
1462 if (!user)
1469 *address = user->intf->addrinfo[channel].address;
1471 release_ipmi_user(user, index);
1477 int ipmi_set_my_LUN(struct ipmi_user *user,
1483 user = acquire_ipmi_user(user, &index);
1484 if (!user)
1491 user->intf->addrinfo[channel].lun = LUN & 0x3;
1493 release_ipmi_user(user, index);
1499 int ipmi_get_my_LUN(struct ipmi_user *user,
1505 user = acquire_ipmi_user(user, &index);
1506 if (!user)
1513 *address = user->intf->addrinfo[channel].lun;
1515 release_ipmi_user(user, index);
1521 int ipmi_get_maintenance_mode(struct ipmi_user *user)
1526 user = acquire_ipmi_user(user, &index);
1527 if (!user)
1530 spin_lock_irqsave(&user->intf->maintenance_mode_lock, flags);
1531 mode = user->intf->maintenance_mode;
1532 spin_unlock_irqrestore(&user->intf->maintenance_mode_lock, flags);
1533 release_ipmi_user(user, index);
1546 int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode)
1550 struct ipmi_smi *intf = user->intf;
1552 user = acquire_ipmi_user(user, &index);
1553 if (!user)
1582 release_ipmi_user(user, index);
1588 int ipmi_set_gets_events(struct ipmi_user *user, bool val)
1591 struct ipmi_smi *intf = user->intf;
1596 user = acquire_ipmi_user(user, &index);
1597 if (!user)
1603 if (user->gets_events == val)
1606 user->gets_events = val;
1623 while (user->gets_events && !list_empty(&intf->waiting_events)) {
1636 msg->user = user;
1637 kref_get(&user->refcount);
1647 release_ipmi_user(user, index);
1685 int ipmi_register_for_cmd(struct ipmi_user *user,
1690 struct ipmi_smi *intf = user->intf;
1694 user = acquire_ipmi_user(user, &index);
1695 if (!user)
1706 rcvr->user = user;
1724 release_ipmi_user(user, index);
1730 int ipmi_unregister_for_cmd(struct ipmi_user *user,
1735 struct ipmi_smi *intf = user->intf;
1740 user = acquire_ipmi_user(user, &index);
1741 if (!user)
1751 if (rcvr->user == user) {
1763 release_ipmi_user(user, index);
1937 * We don't let the user do these, since we manage
2036 * It's a response, so use the user's sequence
2216 * It's a response, so use the user's sequence
2288 * Separate from ipmi_request so that the user does not have to be
2293 static int i_ipmi_request(struct ipmi_user *user,
2311 if (user) {
2312 if (atomic_add_return(1, &user->nr_msgs) > max_msgs_per_user) {
2348 recv_msg->user = user;
2349 if (user)
2351 kref_get(&user->refcount);
2391 if (rv && user)
2392 atomic_dec(&user->nr_msgs);
2409 int ipmi_request_settime(struct ipmi_user *user,
2421 if (!user)
2424 user = acquire_ipmi_user(user, &index);
2425 if (!user)
2428 rv = check_addr(user->intf, addr, &saddr, &lun);
2430 rv = i_ipmi_request(user,
2431 user->intf,
2443 release_ipmi_user(user, index);
2448 int ipmi_request_supply_msgs(struct ipmi_user *user,
2460 if (!user)
2463 user = acquire_ipmi_user(user, &index);
2464 if (!user)
2467 rv = check_addr(user->intf, addr, &saddr, &lun);
2469 rv = i_ipmi_request(user,
2470 user->intf,
2482 release_ipmi_user(user, index);
3503 void ipmi_poll_interface(struct ipmi_user *user)
3505 ipmi_poll(user->intf);
3526 struct ipmi_user *user;
3531 list_for_each_entry_rcu(user, &intf->users, link)
3532 count += atomic_read(&user->nr_msgs);
3792 struct ipmi_user *user =
3796 _ipmi_destroy_user(user);
3883 struct ipmi_user *user = NULL;
3905 user = rcvr->user;
3906 kref_get(&user->refcount);
3908 user = NULL;
3911 if (user == NULL) {
3912 /* We didn't find a user, deliver an error response. */
3952 kref_put(&user->refcount, free_user);
3965 recv_msg->user = user;
3994 struct ipmi_user *user = NULL;
4004 user = rcvr->user;
4005 kref_get(&user->refcount);
4007 user = NULL;
4010 if (user == NULL) {
4011 /* We didn't find a user, deliver an error response. */
4043 kref_put(&user->refcount, free_user);
4057 recv_msg->user = user;
4183 struct ipmi_user *user = NULL;
4205 user = rcvr->user;
4206 kref_get(&user->refcount);
4208 user = NULL;
4211 if (user == NULL) {
4212 /* We didn't find a user, just give up. */
4228 kref_put(&user->refcount, free_user);
4244 recv_msg->user = user;
4282 struct ipmi_user *user = NULL;
4312 user = rcvr->user;
4313 kref_get(&user->refcount);
4315 user = NULL;
4318 if (user == NULL) {
4319 /* We didn't find a user, just give up. */
4337 kref_put(&user->refcount, free_user);
4351 recv_msg->user = user;
4398 struct ipmi_user *user;
4420 * Allocate and fill in one message for every user that is
4424 list_for_each_entry_rcu(user, &intf->users, link) {
4425 if (!user->gets_events)
4448 recv_msg->user = user;
4449 kref_get(&user->refcount);
4644 * deliver a send message response to the user.
4802 struct ipmi_user *user;
4806 list_for_each_entry_rcu(user, &intf->users, link) {
4807 if (user->handler->ipmi_watchdog_pretimeout)
4808 user->handler->ipmi_watchdog_pretimeout(
4809 user->handler_data);
5164 rv->user = NULL;
5173 if (msg->user && !oops_in_progress)
5174 kref_put(&msg->user->refcount, free_user);
5407 struct ipmi_user *user;
5444 list_for_each_entry_rcu(user, &intf->users, link) {
5445 if (user->handler->ipmi_panic_handler)
5446 user->handler->ipmi_panic_handler(
5447 user->handler_data);