Lines Matching refs:user
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. */
208 static struct ipmi_user *acquire_ipmi_user(struct ipmi_user *user, int *index)
209 __acquires(user->release_barrier)
213 *index = srcu_read_lock(&user->release_barrier);
214 ruser = srcu_dereference(user->self, &user->release_barrier);
216 srcu_read_unlock(&user->release_barrier, *index);
220 static void release_ipmi_user(struct ipmi_user *user, int index)
222 srcu_read_unlock(&user->release_barrier, index);
228 struct ipmi_user *user;
295 * but may be changed by the user.
337 /* Commands we got from the user that were invalid. */
343 /* Responses from the MC that were delivered to a user. */
346 /* Responses from the MC that were not delivered to a user. */
374 /* The response was delivered to the user. */
401 /* The response was delivered to the user. */
410 /* The command was delivered to the user. */
570 * interface comes in with a NULL user, call this routine with
890 if (!msg->user) {
908 struct ipmi_user *user = acquire_ipmi_user(msg->user, &index);
910 if (user) {
911 user->handler->ipmi_recv_hndl(msg, user->handler_data);
912 release_ipmi_user(user, index);
1107 * We do this verification because the user can be deleted
1137 * We do this verification because the user can be deleted
1159 struct ipmi_user *user = container_of(work, struct ipmi_user,
1162 cleanup_srcu_struct(&user->release_barrier);
1163 vfree(user);
1169 struct ipmi_user **user)
1220 /* Note that each existing user holds a refcount to the interface. */
1237 *user = new_user;
1275 struct ipmi_user *user = container_of(ref, struct ipmi_user, refcount);
1278 queue_work(remove_work_wq, &user->remove_work);
1281 static void _ipmi_destroy_user(struct ipmi_user *user)
1283 struct ipmi_smi *intf = user->intf;
1290 if (!acquire_ipmi_user(user, &i)) {
1292 * The user has already been cleaned up, just make sure
1295 synchronize_srcu(&user->release_barrier);
1299 rcu_assign_pointer(user->self, NULL);
1300 release_ipmi_user(user, i);
1302 synchronize_srcu(&user->release_barrier);
1304 if (user->handler->shutdown)
1305 user->handler->shutdown(user->handler_data);
1307 if (user->handler->ipmi_watchdog_pretimeout)
1310 if (user->gets_events)
1313 /* Remove the user from the interface's sequence table. */
1315 list_del_rcu(&user->link);
1319 && (intf->seq_table[i].recv_msg->user == user)) {
1328 * Remove the user from the command receiver's table. First
1336 if (rcvr->user == user) {
1355 int ipmi_destroy_user(struct ipmi_user *user)
1357 _ipmi_destroy_user(user);
1359 kref_put(&user->refcount, free_user);
1365 int ipmi_get_version(struct ipmi_user *user,
1372 user = acquire_ipmi_user(user, &index);
1373 if (!user)
1376 rv = bmc_get_device_id(user->intf, NULL, &id, NULL, NULL);
1381 release_ipmi_user(user, index);
1387 int ipmi_set_my_address(struct ipmi_user *user,
1393 user = acquire_ipmi_user(user, &index);
1394 if (!user)
1401 user->intf->addrinfo[channel].address = address;
1403 release_ipmi_user(user, index);
1409 int ipmi_get_my_address(struct ipmi_user *user,
1415 user = acquire_ipmi_user(user, &index);
1416 if (!user)
1423 *address = user->intf->addrinfo[channel].address;
1425 release_ipmi_user(user, index);
1431 int ipmi_set_my_LUN(struct ipmi_user *user,
1437 user = acquire_ipmi_user(user, &index);
1438 if (!user)
1445 user->intf->addrinfo[channel].lun = LUN & 0x3;
1447 release_ipmi_user(user, index);
1453 int ipmi_get_my_LUN(struct ipmi_user *user,
1459 user = acquire_ipmi_user(user, &index);
1460 if (!user)
1467 *address = user->intf->addrinfo[channel].lun;
1469 release_ipmi_user(user, index);
1475 int ipmi_get_maintenance_mode(struct ipmi_user *user)
1480 user = acquire_ipmi_user(user, &index);
1481 if (!user)
1484 spin_lock_irqsave(&user->intf->maintenance_mode_lock, flags);
1485 mode = user->intf->maintenance_mode;
1486 spin_unlock_irqrestore(&user->intf->maintenance_mode_lock, flags);
1487 release_ipmi_user(user, index);
1500 int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode)
1504 struct ipmi_smi *intf = user->intf;
1506 user = acquire_ipmi_user(user, &index);
1507 if (!user)
1536 release_ipmi_user(user, index);
1542 int ipmi_set_gets_events(struct ipmi_user *user, bool val)
1545 struct ipmi_smi *intf = user->intf;
1550 user = acquire_ipmi_user(user, &index);
1551 if (!user)
1557 if (user->gets_events == val)
1560 user->gets_events = val;
1577 while (user->gets_events && !list_empty(&intf->waiting_events)) {
1590 msg->user = user;
1591 kref_get(&user->refcount);
1601 release_ipmi_user(user, index);
1639 int ipmi_register_for_cmd(struct ipmi_user *user,
1644 struct ipmi_smi *intf = user->intf;
1648 user = acquire_ipmi_user(user, &index);
1649 if (!user)
1660 rcvr->user = user;
1678 release_ipmi_user(user, index);
1684 int ipmi_unregister_for_cmd(struct ipmi_user *user,
1689 struct ipmi_smi *intf = user->intf;
1694 user = acquire_ipmi_user(user, &index);
1695 if (!user)
1705 if (rcvr->user == user) {
1717 release_ipmi_user(user, index);
1890 * We don't let the user do these, since we manage
1989 * It's a response, so use the user's sequence
2117 * It's a response, so use the user's sequence
2189 * Separate from ipmi_request so that the user does not have to be
2194 static int i_ipmi_request(struct ipmi_user *user,
2241 recv_msg->user = user;
2242 if (user)
2244 kref_get(&user->refcount);
2296 int ipmi_request_settime(struct ipmi_user *user,
2308 if (!user)
2311 user = acquire_ipmi_user(user, &index);
2312 if (!user)
2315 rv = check_addr(user->intf, addr, &saddr, &lun);
2317 rv = i_ipmi_request(user,
2318 user->intf,
2330 release_ipmi_user(user, index);
2335 int ipmi_request_supply_msgs(struct ipmi_user *user,
2347 if (!user)
2350 user = acquire_ipmi_user(user, &index);
2351 if (!user)
2354 rv = check_addr(user->intf, addr, &saddr, &lun);
2356 rv = i_ipmi_request(user,
2357 user->intf,
2369 release_ipmi_user(user, index);
3385 void ipmi_poll_interface(struct ipmi_user *user)
3387 ipmi_poll(user->intf);
3623 struct ipmi_user *user =
3627 _ipmi_destroy_user(user);
3714 struct ipmi_user *user = NULL;
3736 user = rcvr->user;
3737 kref_get(&user->refcount);
3739 user = NULL;
3742 if (user == NULL) {
3743 /* We didn't find a user, deliver an error response. */
3782 kref_put(&user->refcount, free_user);
3795 recv_msg->user = user;
3894 struct ipmi_user *user = NULL;
3916 user = rcvr->user;
3917 kref_get(&user->refcount);
3919 user = NULL;
3922 if (user == NULL) {
3923 /* We didn't find a user, just give up. */
3939 kref_put(&user->refcount, free_user);
3955 recv_msg->user = user;
3993 struct ipmi_user *user = NULL;
4023 user = rcvr->user;
4024 kref_get(&user->refcount);
4026 user = NULL;
4029 if (user == NULL) {
4030 /* We didn't find a user, just give up. */
4048 kref_put(&user->refcount, free_user);
4062 recv_msg->user = user;
4109 struct ipmi_user *user;
4131 * Allocate and fill in one message for every user that is
4135 list_for_each_entry_rcu(user, &intf->users, link) {
4136 if (!user->gets_events)
4159 recv_msg->user = user;
4160 kref_get(&user->refcount);
4328 * deliver a send message response to the user.
4486 struct ipmi_user *user;
4490 list_for_each_entry_rcu(user, &intf->users, link) {
4491 if (user->handler->ipmi_watchdog_pretimeout)
4492 user->handler->ipmi_watchdog_pretimeout(
4493 user->handler_data);
4846 rv->user = NULL;
4855 if (msg->user && !oops_in_progress)
4856 kref_put(&msg->user->refcount, free_user);
5089 struct ipmi_user *user;
5126 list_for_each_entry_rcu(user, &intf->users, link) {
5127 if (user->handler->ipmi_panic_handler)
5128 user->handler->ipmi_panic_handler(
5129 user->handler_data);