1 /* 2 * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 /** 20 * DOC: Public APIs to perform operations on Peer object 21 */ 22 #include <wlan_objmgr_cmn.h> 23 #include <wlan_objmgr_global_obj.h> 24 #include <wlan_objmgr_psoc_obj.h> 25 #include <wlan_objmgr_pdev_obj.h> 26 #include <wlan_objmgr_vdev_obj.h> 27 #include <wlan_objmgr_peer_obj.h> 28 #include <wlan_objmgr_debug.h> 29 #include <qdf_mem.h> 30 #include <qdf_module.h> 31 #include "wlan_objmgr_global_obj_i.h" 32 #include "wlan_objmgr_psoc_obj_i.h" 33 #include "wlan_objmgr_pdev_obj_i.h" 34 #include "wlan_objmgr_vdev_obj_i.h" 35 36 37 /* 38 * APIs to Create/Delete Peer object APIs 39 */ 40 static QDF_STATUS wlan_objmgr_peer_object_status( 41 struct wlan_objmgr_peer *peer) 42 { 43 uint8_t id; 44 QDF_STATUS status = QDF_STATUS_SUCCESS; 45 46 wlan_peer_obj_lock(peer); 47 /* Iterate through all components to derive the object status */ 48 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 49 /* If component disabled, Ignore */ 50 if (peer->obj_status[id] == QDF_STATUS_COMP_DISABLED) 51 continue; 52 /* If component operates in Async, status is Partially created, 53 break */ 54 else if (peer->obj_status[id] == QDF_STATUS_COMP_ASYNC) { 55 if (!peer->peer_comp_priv_obj[id]) { 56 status = QDF_STATUS_COMP_ASYNC; 57 break; 58 } 59 /* If component failed to allocate its object, treat it as 60 failure, complete object need to be cleaned up */ 61 } else if ((peer->obj_status[id] == QDF_STATUS_E_NOMEM) || 62 (peer->obj_status[id] == QDF_STATUS_E_FAILURE)) { 63 obj_mgr_err("Peer comp object(id:%d) alloc fail", id); 64 status = QDF_STATUS_E_FAILURE; 65 break; 66 } 67 } 68 wlan_peer_obj_unlock(peer); 69 return status; 70 } 71 72 static QDF_STATUS wlan_objmgr_peer_obj_free(struct wlan_objmgr_peer *peer) 73 { 74 struct wlan_objmgr_psoc *psoc; 75 struct wlan_objmgr_vdev *vdev; 76 uint8_t *macaddr; 77 uint8_t vdev_id; 78 bool peer_free_notify = true; 79 80 if (!peer) { 81 obj_mgr_err("PEER is NULL"); 82 return QDF_STATUS_E_FAILURE; 83 } 84 85 macaddr = wlan_peer_get_macaddr(peer); 86 87 vdev = wlan_peer_get_vdev(peer); 88 if (!vdev) { 89 obj_mgr_err( 90 "VDEV is NULL for peer("QDF_MAC_ADDR_FMT")", 91 QDF_MAC_ADDR_REF(macaddr)); 92 return QDF_STATUS_E_FAILURE; 93 } 94 95 /* Notify peer free only for non self peer*/ 96 if (WLAN_ADDR_EQ(wlan_peer_get_macaddr(peer), 97 wlan_vdev_mlme_get_macaddr(vdev)) == 98 QDF_STATUS_SUCCESS) 99 peer_free_notify = false; 100 101 vdev_id = wlan_vdev_get_id(vdev); 102 103 /* get PSOC from VDEV, if it is NULL, return */ 104 psoc = wlan_vdev_get_psoc(vdev); 105 if (!psoc) { 106 obj_mgr_err( 107 "PSOC is NULL for peer("QDF_MAC_ADDR_FMT")", 108 QDF_MAC_ADDR_REF(macaddr)); 109 return QDF_STATUS_E_FAILURE; 110 } 111 112 /* Decrement ref count for BSS peer, so that BSS peer deletes last*/ 113 if ((wlan_peer_get_peer_type(peer) == WLAN_PEER_STA) || 114 (wlan_peer_get_peer_type(peer) == WLAN_PEER_STA_TEMP) || 115 (wlan_peer_get_peer_type(peer) == WLAN_PEER_P2P_CLI)) 116 wlan_objmgr_peer_release_ref(wlan_vdev_get_bsspeer(vdev), 117 WLAN_OBJMGR_ID); 118 119 wlan_objmgr_vdev_get_ref(vdev, WLAN_OBJMGR_ID); 120 121 /* Detach peer from VDEV's peer list */ 122 if (wlan_objmgr_vdev_peer_detach(vdev, peer) == QDF_STATUS_E_FAILURE) { 123 obj_mgr_err( 124 "Peer("QDF_MAC_ADDR_FMT") VDEV detach fail, vdev id: %d", 125 QDF_MAC_ADDR_REF(macaddr), vdev_id); 126 wlan_objmgr_vdev_release_ref(vdev, WLAN_OBJMGR_ID); 127 return QDF_STATUS_E_FAILURE; 128 } 129 /* Detach peer from PSOC's peer list */ 130 if (wlan_objmgr_psoc_peer_detach(psoc, peer) == QDF_STATUS_E_FAILURE) { 131 obj_mgr_err( 132 "Peer("QDF_MAC_ADDR_FMT") PSOC detach failure", 133 QDF_MAC_ADDR_REF(macaddr)); 134 wlan_objmgr_vdev_release_ref(vdev, WLAN_OBJMGR_ID); 135 return QDF_STATUS_E_FAILURE; 136 } 137 wlan_objmgr_peer_trace_del_ref_list(peer); 138 wlan_objmgr_peer_trace_deinit_lock(peer); 139 qdf_spinlock_destroy(&peer->peer_lock); 140 qdf_mem_free(peer); 141 peer = NULL; 142 143 if (peer_free_notify) 144 wlan_objmgr_vdev_peer_freed_notify(vdev); 145 146 wlan_objmgr_vdev_release_ref(vdev, WLAN_OBJMGR_ID); 147 148 return QDF_STATUS_SUCCESS; 149 150 } 151 152 #ifdef WLAN_OBJMGR_REF_ID_DEBUG 153 static void 154 wlan_objmgr_peer_init_ref_id_debug(struct wlan_objmgr_peer *peer) 155 { 156 uint8_t id; 157 158 for (id = 0; id < WLAN_REF_ID_MAX; id++) 159 qdf_atomic_init(&peer->peer_objmgr.ref_id_dbg[id]); 160 } 161 #else 162 static inline void 163 wlan_objmgr_peer_init_ref_id_debug(struct wlan_objmgr_peer *peer) {} 164 #endif 165 166 struct wlan_objmgr_peer *wlan_objmgr_peer_obj_create( 167 struct wlan_objmgr_vdev *vdev, 168 enum wlan_peer_type type, 169 uint8_t *macaddr) 170 { 171 struct wlan_objmgr_peer *peer; 172 struct wlan_objmgr_psoc *psoc; 173 wlan_objmgr_peer_create_handler handler; 174 wlan_objmgr_peer_status_handler stat_handler; 175 void *arg; 176 QDF_STATUS obj_status; 177 uint8_t id; 178 179 if (!vdev) { 180 obj_mgr_err( 181 "VDEV is NULL for peer ("QDF_MAC_ADDR_FMT")", 182 QDF_MAC_ADDR_REF(macaddr)); 183 return NULL; 184 } 185 /* Get psoc, if psoc is NULL, return */ 186 psoc = wlan_vdev_get_psoc(vdev); 187 if (!psoc) { 188 obj_mgr_err( 189 "PSOC is NULL for peer ("QDF_MAC_ADDR_FMT")", 190 QDF_MAC_ADDR_REF(macaddr)); 191 return NULL; 192 } 193 /* Allocate memory for peer object */ 194 peer = qdf_mem_malloc(sizeof(*peer)); 195 if (!peer) 196 return NULL; 197 198 peer->obj_state = WLAN_OBJ_STATE_ALLOCATED; 199 qdf_atomic_init(&peer->peer_objmgr.ref_cnt); 200 wlan_objmgr_peer_init_ref_id_debug(peer); 201 wlan_objmgr_peer_trace_init_lock(peer); 202 wlan_objmgr_peer_get_ref(peer, WLAN_OBJMGR_ID); 203 /* set vdev to peer */ 204 wlan_peer_set_vdev(peer, vdev); 205 /* set peer type */ 206 wlan_peer_set_peer_type(peer, type); 207 /* set mac address of peer */ 208 wlan_peer_set_macaddr(peer, macaddr); 209 /* initialize peer state */ 210 wlan_peer_mlme_set_state(peer, WLAN_INIT_STATE); 211 wlan_peer_mlme_reset_seq_num(peer); 212 peer->peer_objmgr.print_cnt = 0; 213 214 qdf_spinlock_create(&peer->peer_lock); 215 /* Attach peer to psoc, psoc maintains the node table for the device */ 216 if (wlan_objmgr_psoc_peer_attach(psoc, peer) != 217 QDF_STATUS_SUCCESS) { 218 obj_mgr_warn( 219 "Peer("QDF_MAC_ADDR_FMT") PSOC attach failure", 220 QDF_MAC_ADDR_REF(macaddr)); 221 qdf_spinlock_destroy(&peer->peer_lock); 222 wlan_objmgr_peer_trace_deinit_lock(peer); 223 qdf_mem_free(peer); 224 return NULL; 225 } 226 /* Attach peer to vdev peer table */ 227 if (wlan_objmgr_vdev_peer_attach(vdev, peer) != 228 QDF_STATUS_SUCCESS) { 229 obj_mgr_warn( 230 "Peer("QDF_MAC_ADDR_FMT") VDEV attach failure", 231 QDF_MAC_ADDR_REF(macaddr)); 232 /* if attach fails, detach from psoc table before free */ 233 wlan_objmgr_psoc_peer_detach(psoc, peer); 234 qdf_spinlock_destroy(&peer->peer_lock); 235 wlan_objmgr_peer_trace_deinit_lock(peer); 236 qdf_mem_free(peer); 237 return NULL; 238 } 239 wlan_peer_set_pdev_id(peer, wlan_objmgr_pdev_get_pdev_id( 240 wlan_vdev_get_pdev(vdev))); 241 /* Increment ref count for BSS peer, so that BSS peer deletes last*/ 242 if ((type == WLAN_PEER_STA) || (type == WLAN_PEER_STA_TEMP) 243 || (type == WLAN_PEER_P2P_CLI)) 244 wlan_objmgr_peer_get_ref(wlan_vdev_get_bsspeer(vdev), 245 WLAN_OBJMGR_ID); 246 /* TODO init other parameters */ 247 /* Invoke registered create handlers */ 248 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 249 handler = g_umac_glb_obj->peer_create_handler[id]; 250 arg = g_umac_glb_obj->peer_create_handler_arg[id]; 251 if (handler) 252 peer->obj_status[id] = handler(peer, arg); 253 else 254 peer->obj_status[id] = QDF_STATUS_COMP_DISABLED; 255 } 256 /* derive the object status */ 257 obj_status = wlan_objmgr_peer_object_status(peer); 258 /* If SUCCESS, Object is created */ 259 if (obj_status == QDF_STATUS_SUCCESS) { 260 peer->obj_state = WLAN_OBJ_STATE_CREATED; 261 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 262 stat_handler = g_umac_glb_obj->peer_status_handler[id]; 263 arg = g_umac_glb_obj->peer_status_handler_arg[id]; 264 if (stat_handler) 265 stat_handler(peer, arg, 266 QDF_STATUS_SUCCESS); 267 } 268 } else if (obj_status == QDF_STATUS_COMP_ASYNC) { 269 /* If any component operates in different context, update it 270 as partially created */ 271 peer->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED; 272 } else if (obj_status == QDF_STATUS_E_FAILURE) { 273 /* Clean up the peer */ 274 obj_mgr_err( 275 "Peer("QDF_MAC_ADDR_FMT") comp object alloc fail", 276 QDF_MAC_ADDR_REF(macaddr)); 277 wlan_objmgr_peer_obj_delete(peer); 278 return NULL; 279 } 280 281 obj_mgr_debug("Created peer " QDF_MAC_ADDR_FMT " type %d", 282 QDF_MAC_ADDR_REF(macaddr), type); 283 284 return peer; 285 } 286 287 static QDF_STATUS 288 __wlan_objmgr_peer_obj_destroy(struct wlan_objmgr_peer *peer) 289 { 290 uint8_t id; 291 wlan_objmgr_peer_destroy_handler handler; 292 QDF_STATUS obj_status; 293 void *arg; 294 uint8_t *macaddr; 295 296 if (!peer) { 297 obj_mgr_err("PEER is NULL"); 298 return QDF_STATUS_E_FAILURE; 299 } 300 wlan_objmgr_notify_destroy(peer, WLAN_PEER_OP); 301 302 macaddr = wlan_peer_get_macaddr(peer); 303 304 obj_mgr_debug("Physically deleting peer " QDF_MAC_ADDR_FMT, 305 QDF_MAC_ADDR_REF(macaddr)); 306 307 if (peer->obj_state != WLAN_OBJ_STATE_LOGICALLY_DELETED) { 308 obj_mgr_err("PEER object del is not invoked obj_state:%d peer " 309 QDF_MAC_ADDR_FMT, peer->obj_state, 310 QDF_MAC_ADDR_REF(macaddr)); 311 WLAN_OBJMGR_BUG(0); 312 } 313 314 /* Invoke registered destroy handlers */ 315 for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) { 316 handler = g_umac_glb_obj->peer_destroy_handler[id]; 317 arg = g_umac_glb_obj->peer_destroy_handler_arg[id]; 318 if (handler && 319 (peer->obj_status[id] == QDF_STATUS_SUCCESS || 320 peer->obj_status[id] == QDF_STATUS_COMP_ASYNC)) 321 peer->obj_status[id] = handler(peer, arg); 322 else 323 peer->obj_status[id] = QDF_STATUS_COMP_DISABLED; 324 } 325 /* Derive the object status */ 326 obj_status = wlan_objmgr_peer_object_status(peer); 327 if (obj_status == QDF_STATUS_E_FAILURE) { 328 /* If it status is failure, memory will not be freed */ 329 QDF_BUG(0); 330 return QDF_STATUS_E_FAILURE; 331 } 332 /* few components deletion is in progress */ 333 if (obj_status == QDF_STATUS_COMP_ASYNC) { 334 peer->obj_state = WLAN_OBJ_STATE_PARTIALLY_DELETED; 335 return QDF_STATUS_COMP_ASYNC; 336 } 337 338 /* Free the peer object */ 339 return wlan_objmgr_peer_obj_free(peer); 340 } 341 342 #ifdef FEATURE_DELAYED_PEER_OBJ_DESTROY 343 /* 344 * Length of the list used to hold delayed peer obj free. 345 * Must be a multiple of 2. 346 */ 347 #define MAX_DELAYED_FREE_PEERS 64 348 349 /** 350 * wlan_objmgr_peer_obj_free_work() - Peer obj freed in the delayed work 351 * @data: PDEV object 352 * 353 * Peer obj freed in the delayed work 354 * 355 * Return: None 356 */ 357 static void wlan_objmgr_peer_obj_free_work(void *data) 358 { 359 struct wlan_objmgr_pdev *pdev = data; 360 struct wlan_objmgr_peer *peer; 361 qdf_list_node_t *node; 362 uint8_t *macaddr; 363 364 if (!pdev) { 365 obj_mgr_err("pdev is NULL"); 366 return; 367 } 368 369 qdf_spin_lock_bh(&pdev->peer_free_lock); 370 while (!(qdf_list_empty(&pdev->peer_free_list))) { 371 qdf_list_remove_front(&pdev->peer_free_list, &node); 372 qdf_spin_unlock_bh(&pdev->peer_free_lock); 373 374 peer = qdf_container_of(node, 375 struct wlan_objmgr_peer, 376 free_node); 377 378 macaddr = wlan_peer_get_macaddr(peer); 379 obj_mgr_debug("active_work_cnt %u list size %u peer 0x%pK(" 380 QDF_MAC_ADDR_FMT ")", 381 pdev->active_work_cnt, 382 qdf_list_size(&pdev->peer_free_list), 383 peer, 384 QDF_MAC_ADDR_REF(macaddr)); 385 386 __wlan_objmgr_peer_obj_destroy(peer); 387 388 qdf_spin_lock_bh(&pdev->peer_free_lock); 389 } 390 391 pdev->active_work_cnt--; 392 393 qdf_spin_unlock_bh(&pdev->peer_free_lock); 394 } 395 396 /** 397 * wlan_peer_obj_free_enqueue() - enqueue freed peer into kworker 398 * @peer: PEER object 399 * 400 * Enqueue freed peer into kworker 401 * 402 * Return: None 403 */ 404 static QDF_STATUS 405 wlan_peer_obj_free_enqueue(struct wlan_objmgr_peer *peer) 406 { 407 struct wlan_objmgr_vdev *vdev; 408 struct wlan_objmgr_pdev *pdev; 409 uint8_t *macaddr; 410 411 if (!peer) { 412 obj_mgr_err("peer is NULL"); 413 return QDF_STATUS_E_FAILURE; 414 } 415 416 macaddr = wlan_peer_get_macaddr(peer); 417 418 vdev = wlan_peer_get_vdev(peer); 419 if (!vdev) { 420 obj_mgr_err("VDEV is NULL for peer(" QDF_MAC_ADDR_FMT ")", 421 QDF_MAC_ADDR_REF(macaddr)); 422 return QDF_STATUS_E_FAILURE; 423 } 424 /* get PDEV from VDEV, if it is NULL, return */ 425 pdev = wlan_vdev_get_pdev(vdev); 426 if (!pdev) { 427 obj_mgr_err("PDEV is NULL for peer(" QDF_MAC_ADDR_FMT ")", 428 QDF_MAC_ADDR_REF(macaddr)); 429 return QDF_STATUS_E_FAILURE; 430 } 431 432 qdf_spin_lock_bh(&pdev->peer_free_lock); 433 qdf_list_insert_back(&pdev->peer_free_list, &peer->free_node); 434 pdev->active_work_cnt++; 435 qdf_spin_unlock_bh(&pdev->peer_free_lock); 436 437 obj_mgr_debug("active_work_cnt %u list size %u peer 0x%pK(" 438 QDF_MAC_ADDR_FMT ")", 439 pdev->active_work_cnt, 440 qdf_list_size(&pdev->peer_free_list), 441 peer, 442 QDF_MAC_ADDR_REF(macaddr)); 443 444 qdf_sched_work(0, &pdev->peer_obj_free_work); 445 446 return QDF_STATUS_SUCCESS; 447 } 448 449 static QDF_STATUS 450 wlan_objmgr_peer_obj_destroy(struct wlan_objmgr_peer *peer) 451 { 452 QDF_STATUS status; 453 454 if (qdf_in_atomic()) { 455 status = wlan_peer_obj_free_enqueue(peer); 456 if (status == QDF_STATUS_SUCCESS) 457 return status; 458 459 obj_mgr_err("enqueue failure, call free obj directly"); 460 } 461 462 status = __wlan_objmgr_peer_obj_destroy(peer); 463 464 return status; 465 } 466 467 /** 468 * wlan_delayed_peer_obj_free_init() - Init for delayed peer obj freed queue 469 * @data: PDEV object 470 * 471 * Initialize main data structures to process peer obj destroy in a delayed 472 * workqueue. 473 * 474 * Return: QDF_STATUS_SUCCESS on success else a QDF error. 475 */ 476 QDF_STATUS wlan_delayed_peer_obj_free_init(void *data) 477 { 478 struct wlan_objmgr_pdev *pdev = data; 479 480 if (!pdev) { 481 obj_mgr_err("pdev is NULL"); 482 return QDF_STATUS_E_FAILURE; 483 } 484 485 qdf_spinlock_create(&pdev->peer_free_lock); 486 qdf_create_work(0, &pdev->peer_obj_free_work, 487 wlan_objmgr_peer_obj_free_work, 488 (void *)pdev); 489 pdev->active_work_cnt = 0; 490 491 /* Initialize PDEV's peer free list, assign default values */ 492 qdf_list_create(&pdev->peer_free_list, MAX_DELAYED_FREE_PEERS); 493 494 obj_mgr_debug("Delayed peer obj free init successfully"); 495 496 return QDF_STATUS_SUCCESS; 497 } 498 499 /** 500 * wlan_delayed_peer_obj_free_deinit() - De-Init delayed peer freed processing 501 * @data: PDEV object 502 * 503 * De-initialize main data structures to process peer obj freed in a delayed 504 * workqueue. 505 * 506 * Return: QDF_STATUS_SUCCESS on success else a QDF error. 507 */ 508 QDF_STATUS wlan_delayed_peer_obj_free_deinit(void *data) 509 { 510 struct wlan_objmgr_pdev *pdev = data; 511 512 if (!pdev) { 513 obj_mgr_err("pdev is NULL"); 514 return QDF_STATUS_E_FAILURE; 515 } 516 517 qdf_destroy_work(0, &pdev->peer_obj_free_work); 518 qdf_spinlock_destroy(&pdev->peer_free_lock); 519 520 obj_mgr_debug("Deinit successfully, active_work_cnt=%u", 521 pdev->active_work_cnt); 522 523 return QDF_STATUS_SUCCESS; 524 } 525 #else 526 static QDF_STATUS 527 wlan_objmgr_peer_obj_destroy(struct wlan_objmgr_peer *peer) 528 { 529 return __wlan_objmgr_peer_obj_destroy(peer); 530 } 531 #endif 532 533 QDF_STATUS wlan_objmgr_peer_obj_delete(struct wlan_objmgr_peer *peer) 534 { 535 uint8_t print_idx; 536 uint8_t *macaddr; 537 538 if (!peer) { 539 obj_mgr_err("PEER is NULL"); 540 return QDF_STATUS_E_FAILURE; 541 } 542 543 wlan_peer_obj_lock(peer); 544 macaddr = wlan_peer_get_macaddr(peer); 545 wlan_peer_obj_unlock(peer); 546 547 obj_mgr_debug("Logically deleting peer " QDF_MAC_ADDR_FMT, 548 QDF_MAC_ADDR_REF(macaddr)); 549 550 print_idx = qdf_get_pidx(); 551 wlan_objmgr_print_peer_ref_ids(peer, QDF_TRACE_LEVEL_DEBUG); 552 /* 553 * Update VDEV object state to LOGICALLY DELETED 554 * It prevents further access of this object 555 */ 556 wlan_peer_obj_lock(peer); 557 peer->obj_state = WLAN_OBJ_STATE_LOGICALLY_DELETED; 558 wlan_peer_obj_unlock(peer); 559 wlan_objmgr_notify_log_delete(peer, WLAN_PEER_OP); 560 wlan_objmgr_peer_release_ref(peer, WLAN_OBJMGR_ID); 561 562 return QDF_STATUS_SUCCESS; 563 } 564 qdf_export_symbol(wlan_objmgr_peer_obj_delete); 565 /* 566 * APIs to attach/detach component objects 567 */ 568 QDF_STATUS wlan_objmgr_peer_component_obj_attach( 569 struct wlan_objmgr_peer *peer, 570 enum wlan_umac_comp_id id, 571 void *comp_priv_obj, 572 QDF_STATUS status) 573 { 574 wlan_objmgr_peer_status_handler s_hler; 575 void *arg; 576 uint8_t i; 577 QDF_STATUS obj_status; 578 579 /* component id is invalid */ 580 if (id >= WLAN_UMAC_MAX_COMPONENTS) 581 return QDF_STATUS_MAXCOMP_FAIL; 582 583 wlan_peer_obj_lock(peer); 584 /* If there is a valid entry, return failure, 585 valid object needs to be freed first */ 586 if (peer->peer_comp_priv_obj[id]) { 587 wlan_peer_obj_unlock(peer); 588 return QDF_STATUS_E_FAILURE; 589 } 590 /* Assign component object private pointer(can be NULL also), status */ 591 peer->peer_comp_priv_obj[id] = comp_priv_obj; 592 peer->obj_status[id] = status; 593 wlan_peer_obj_unlock(peer); 594 595 if (peer->obj_state != WLAN_OBJ_STATE_PARTIALLY_CREATED) 596 return QDF_STATUS_SUCCESS; 597 598 /* If PEER object status is partially created means, this API is 599 invoked with different context. this block should be executed for async 600 components only */ 601 /* Derive status */ 602 obj_status = wlan_objmgr_peer_object_status(peer); 603 /* STATUS_SUCCESS means, object is CREATED */ 604 if (obj_status == QDF_STATUS_SUCCESS) 605 peer->obj_state = WLAN_OBJ_STATE_CREATED; 606 /* update state as CREATION failed, caller has to delete the 607 PEER object */ 608 else if (obj_status == QDF_STATUS_E_FAILURE) 609 peer->obj_state = WLAN_OBJ_STATE_CREATION_FAILED; 610 /* Notify components about the CREATION success/failure */ 611 if ((obj_status == QDF_STATUS_SUCCESS) || 612 (obj_status == QDF_STATUS_E_FAILURE)) { 613 /* notify object status */ 614 for (i = 0; i < WLAN_UMAC_MAX_COMPONENTS; i++) { 615 s_hler = g_umac_glb_obj->peer_status_handler[i]; 616 arg = g_umac_glb_obj->peer_status_handler_arg[i]; 617 if (s_hler) 618 s_hler(peer, arg, obj_status); 619 } 620 } 621 return QDF_STATUS_SUCCESS; 622 } 623 624 qdf_export_symbol(wlan_objmgr_peer_component_obj_attach); 625 626 QDF_STATUS wlan_objmgr_peer_component_obj_detach( 627 struct wlan_objmgr_peer *peer, 628 enum wlan_umac_comp_id id, 629 void *comp_priv_obj) 630 { 631 QDF_STATUS obj_status; 632 633 /* component id is invalid */ 634 if (id >= WLAN_UMAC_MAX_COMPONENTS) 635 return QDF_STATUS_MAXCOMP_FAIL; 636 637 wlan_peer_obj_lock(peer); 638 /* If there is a invalid entry, return failure */ 639 if (peer->peer_comp_priv_obj[id] != comp_priv_obj) { 640 peer->obj_status[id] = QDF_STATUS_E_FAILURE; 641 wlan_peer_obj_unlock(peer); 642 return QDF_STATUS_E_FAILURE; 643 } 644 /* Reset the pointer to NULL */ 645 peer->peer_comp_priv_obj[id] = NULL; 646 peer->obj_status[id] = QDF_STATUS_SUCCESS; 647 wlan_peer_obj_unlock(peer); 648 649 /* If PEER object status is partially destroyed means, this API is 650 invoked with different context, this block should be executed for async 651 components only */ 652 if ((peer->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) || 653 (peer->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS)) { 654 /* Derive object status */ 655 obj_status = wlan_objmgr_peer_object_status(peer); 656 if (obj_status == QDF_STATUS_SUCCESS) { 657 /*Update the status as Deleted, if full object 658 deletion is in progress */ 659 if (peer->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) 660 peer->obj_state = WLAN_OBJ_STATE_DELETED; 661 /* Move to creation state, since this component 662 deletion alone requested */ 663 if (peer->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS) 664 peer->obj_state = WLAN_OBJ_STATE_CREATED; 665 /* Object status is failure */ 666 } else if (obj_status == QDF_STATUS_E_FAILURE) { 667 /*Update the status as Deletion failed, if full object 668 deletion is in progress */ 669 if (peer->obj_state == WLAN_OBJ_STATE_PARTIALLY_DELETED) 670 peer->obj_state = 671 WLAN_OBJ_STATE_DELETION_FAILED; 672 /* Move to creation state, since this component 673 deletion alone requested (do not block other 674 components) */ 675 if (peer->obj_state == WLAN_OBJ_STATE_COMP_DEL_PROGRESS) 676 peer->obj_state = WLAN_OBJ_STATE_CREATED; 677 } 678 679 /* Delete peer object */ 680 if ((obj_status == QDF_STATUS_SUCCESS) && 681 (peer->obj_state == WLAN_OBJ_STATE_DELETED)) { 682 /* Free the peer object */ 683 return wlan_objmgr_peer_obj_free(peer); 684 } 685 } 686 687 return QDF_STATUS_SUCCESS; 688 } 689 690 qdf_export_symbol(wlan_objmgr_peer_component_obj_detach); 691 692 QDF_STATUS wlan_objmgr_trigger_peer_comp_priv_object_creation( 693 struct wlan_objmgr_peer *peer, 694 enum wlan_umac_comp_id id) 695 { 696 wlan_objmgr_peer_create_handler handler; 697 void *arg; 698 QDF_STATUS obj_status = QDF_STATUS_SUCCESS; 699 700 /* Component id is invalid */ 701 if (id >= WLAN_UMAC_MAX_COMPONENTS) 702 return QDF_STATUS_MAXCOMP_FAIL; 703 704 wlan_peer_obj_lock(peer); 705 /* If component object is already created, delete old 706 component object, then invoke creation */ 707 if (peer->peer_comp_priv_obj[id]) { 708 wlan_peer_obj_unlock(peer); 709 return QDF_STATUS_E_FAILURE; 710 } 711 wlan_peer_obj_unlock(peer); 712 713 /* Invoke registered create handlers */ 714 handler = g_umac_glb_obj->peer_create_handler[id]; 715 arg = g_umac_glb_obj->peer_create_handler_arg[id]; 716 if (handler) 717 peer->obj_status[id] = handler(peer, arg); 718 else 719 return QDF_STATUS_E_FAILURE; 720 721 /* If object status is created, then only handle this object status */ 722 if (peer->obj_state == WLAN_OBJ_STATE_CREATED) { 723 /* Derive object status */ 724 obj_status = wlan_objmgr_peer_object_status(peer); 725 /* Move PDEV object state to Partially created state */ 726 if (obj_status == QDF_STATUS_COMP_ASYNC) { 727 /*TODO atomic */ 728 peer->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED; 729 } 730 } 731 732 return obj_status; 733 } 734 735 736 QDF_STATUS wlan_objmgr_trigger_peer_comp_priv_object_deletion( 737 struct wlan_objmgr_peer *peer, 738 enum wlan_umac_comp_id id) 739 { 740 wlan_objmgr_peer_destroy_handler handler; 741 void *arg; 742 QDF_STATUS obj_status = QDF_STATUS_SUCCESS; 743 744 /* component id is invalid */ 745 if (id >= WLAN_UMAC_MAX_COMPONENTS) 746 return QDF_STATUS_MAXCOMP_FAIL; 747 748 wlan_peer_obj_lock(peer); 749 /* Component object was never created, invalid operation */ 750 if (!peer->peer_comp_priv_obj[id]) { 751 wlan_peer_obj_unlock(peer); 752 return QDF_STATUS_E_FAILURE; 753 } 754 755 wlan_peer_obj_unlock(peer); 756 757 /* Invoke registered destroy handlers */ 758 handler = g_umac_glb_obj->peer_destroy_handler[id]; 759 arg = g_umac_glb_obj->peer_destroy_handler_arg[id]; 760 if (handler) 761 peer->obj_status[id] = handler(peer, arg); 762 else 763 return QDF_STATUS_E_FAILURE; 764 765 /* If object status is created, then only handle this object status */ 766 if (peer->obj_state == WLAN_OBJ_STATE_CREATED) { 767 obj_status = wlan_objmgr_peer_object_status(peer); 768 /* move object state to DEL progress */ 769 if (obj_status == QDF_STATUS_COMP_ASYNC) 770 peer->obj_state = WLAN_OBJ_STATE_COMP_DEL_PROGRESS; 771 } 772 return obj_status; 773 } 774 775 void *wlan_objmgr_peer_get_comp_private_obj( 776 struct wlan_objmgr_peer *peer, 777 enum wlan_umac_comp_id id) 778 { 779 void *comp_priv_obj; 780 781 /* component id is invalid */ 782 if (id >= WLAN_UMAC_MAX_COMPONENTS) { 783 QDF_BUG(0); 784 return NULL; 785 } 786 787 if (!peer) { 788 QDF_BUG(0); 789 return NULL; 790 } 791 792 comp_priv_obj = peer->peer_comp_priv_obj[id]; 793 return comp_priv_obj; 794 } 795 qdf_export_symbol(wlan_objmgr_peer_get_comp_private_obj); 796 797 #ifdef WLAN_OBJMGR_REF_ID_DEBUG 798 static inline void 799 wlan_objmgr_peer_get_debug_id_ref(struct wlan_objmgr_peer *peer, 800 wlan_objmgr_ref_dbgid id) 801 { 802 qdf_atomic_inc(&peer->peer_objmgr.ref_id_dbg[id]); 803 } 804 #else 805 static inline void 806 wlan_objmgr_peer_get_debug_id_ref(struct wlan_objmgr_peer *peer, 807 wlan_objmgr_ref_dbgid id) {} 808 #endif 809 810 #ifdef WLAN_OBJMGR_REF_ID_DEBUG 811 static QDF_STATUS 812 wlan_objmgr_peer_release_debug_id_ref(struct wlan_objmgr_peer *peer, 813 wlan_objmgr_ref_dbgid id) 814 { 815 if (!qdf_atomic_read(&peer->peer_objmgr.ref_id_dbg[id])) { 816 uint8_t *macaddr; 817 818 macaddr = wlan_peer_get_macaddr(peer); 819 obj_mgr_err( 820 "peer("QDF_MAC_ADDR_FMT") ref was not taken by %d", 821 QDF_MAC_ADDR_REF(macaddr), id); 822 wlan_objmgr_print_ref_ids(peer->peer_objmgr.ref_id_dbg, 823 QDF_TRACE_LEVEL_FATAL); 824 WLAN_OBJMGR_BUG(0); 825 return QDF_STATUS_E_FAILURE; 826 } 827 828 qdf_atomic_dec(&peer->peer_objmgr.ref_id_dbg[id]); 829 return QDF_STATUS_SUCCESS; 830 } 831 #else 832 static QDF_STATUS 833 wlan_objmgr_peer_release_debug_id_ref(struct wlan_objmgr_peer *peer, 834 wlan_objmgr_ref_dbgid id) 835 { 836 return QDF_STATUS_SUCCESS; 837 } 838 #endif 839 840 #ifdef WLAN_OBJMGR_REF_ID_TRACE 841 static inline void 842 wlan_objmgr_peer_ref_trace(struct wlan_objmgr_peer *peer, 843 wlan_objmgr_ref_dbgid id, 844 const char *func, int line) 845 { 846 struct wlan_objmgr_trace *trace; 847 848 trace = &peer->peer_objmgr.trace; 849 850 if (func) 851 wlan_objmgr_trace_ref(&trace->references[id].head, 852 trace, func, line); 853 } 854 855 static inline void 856 wlan_objmgr_peer_deref_trace(struct wlan_objmgr_peer *peer, 857 wlan_objmgr_ref_dbgid id, 858 const char *func, int line) 859 { 860 struct wlan_objmgr_trace *trace; 861 862 trace = &peer->peer_objmgr.trace; 863 if (func) 864 wlan_objmgr_trace_ref(&trace->dereferences[id].head, 865 trace, func, line); 866 } 867 #endif 868 869 #ifdef WLAN_OBJMGR_REF_ID_TRACE 870 void wlan_objmgr_peer_get_ref_debug(struct wlan_objmgr_peer *peer, 871 wlan_objmgr_ref_dbgid id, 872 const char *func, int line) 873 { 874 if (!peer) { 875 obj_mgr_err("peer obj is NULL for %d", id); 876 QDF_ASSERT(0); 877 return; 878 } 879 /* Increment ref count */ 880 qdf_atomic_inc(&peer->peer_objmgr.ref_cnt); 881 wlan_objmgr_peer_get_debug_id_ref(peer, id); 882 883 wlan_objmgr_peer_ref_trace(peer, id, func, line); 884 return; 885 } 886 887 qdf_export_symbol(wlan_objmgr_peer_get_ref_debug); 888 #else 889 void wlan_objmgr_peer_get_ref(struct wlan_objmgr_peer *peer, 890 wlan_objmgr_ref_dbgid id) 891 { 892 if (!peer) { 893 obj_mgr_err("peer obj is NULL for %d", id); 894 QDF_ASSERT(0); 895 return; 896 } 897 /* Increment ref count */ 898 qdf_atomic_inc(&peer->peer_objmgr.ref_cnt); 899 wlan_objmgr_peer_get_debug_id_ref(peer, id); 900 } 901 902 qdf_export_symbol(wlan_objmgr_peer_get_ref); 903 #endif 904 905 #ifdef WLAN_OBJMGR_REF_ID_TRACE 906 QDF_STATUS wlan_objmgr_peer_try_get_ref_debug(struct wlan_objmgr_peer *peer, 907 wlan_objmgr_ref_dbgid id, 908 const char *func, int line) 909 { 910 if (!peer) { 911 obj_mgr_err("peer obj is NULL for %d", id); 912 QDF_ASSERT(0); 913 return QDF_STATUS_E_FAILURE; 914 } 915 916 wlan_peer_obj_lock(peer); 917 if (peer->obj_state != WLAN_OBJ_STATE_CREATED) { 918 wlan_peer_obj_unlock(peer); 919 if (peer->peer_objmgr.print_cnt++ <= 920 WLAN_OBJMGR_RATELIMIT_THRESH) { 921 uint8_t *macaddr; 922 923 macaddr = wlan_peer_get_macaddr(peer); 924 obj_mgr_debug( 925 "peer(" QDF_MAC_ADDR_FMT ") not in Created st(%d)", 926 QDF_MAC_ADDR_REF(macaddr), 927 peer->obj_state); 928 } 929 return QDF_STATUS_E_RESOURCES; 930 } 931 932 wlan_objmgr_peer_get_ref_debug(peer, id, func, line); 933 wlan_peer_obj_unlock(peer); 934 935 return QDF_STATUS_SUCCESS; 936 } 937 938 qdf_export_symbol(wlan_objmgr_peer_try_get_ref_debug); 939 #else 940 QDF_STATUS wlan_objmgr_peer_try_get_ref(struct wlan_objmgr_peer *peer, 941 wlan_objmgr_ref_dbgid id) 942 { 943 if (!peer) { 944 obj_mgr_err("peer obj is NULL for %d", id); 945 QDF_ASSERT(0); 946 return QDF_STATUS_E_FAILURE; 947 } 948 949 wlan_peer_obj_lock(peer); 950 if (peer->obj_state != WLAN_OBJ_STATE_CREATED) { 951 wlan_peer_obj_unlock(peer); 952 if (peer->peer_objmgr.print_cnt++ <= 953 WLAN_OBJMGR_RATELIMIT_THRESH) { 954 uint8_t *macaddr; 955 956 macaddr = wlan_peer_get_macaddr(peer); 957 obj_mgr_debug( 958 "peer(" QDF_MAC_ADDR_FMT ") not in Created st(%d)", 959 QDF_MAC_ADDR_REF(macaddr), 960 peer->obj_state); 961 } 962 return QDF_STATUS_E_RESOURCES; 963 } 964 965 wlan_objmgr_peer_get_ref(peer, id); 966 wlan_peer_obj_unlock(peer); 967 968 return QDF_STATUS_SUCCESS; 969 } 970 971 qdf_export_symbol(wlan_objmgr_peer_try_get_ref); 972 #endif 973 974 #ifdef WLAN_OBJMGR_REF_ID_TRACE 975 struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc_debug( 976 struct wlan_peer_list *peer_list, 977 uint8_t hash_index, 978 struct wlan_objmgr_peer *peer, 979 wlan_objmgr_ref_dbgid dbg_id, 980 const char *func, int line) 981 { 982 struct wlan_objmgr_peer *peer_next = NULL; 983 qdf_list_node_t *psoc_node = NULL; 984 qdf_list_node_t *prev_psoc_node = NULL; 985 qdf_list_t *obj_list; 986 987 qdf_spin_lock_bh(&peer_list->peer_list_lock); 988 obj_list = &peer_list->peer_hash[hash_index]; 989 990 prev_psoc_node = &peer->psoc_peer; 991 while (qdf_list_peek_next(obj_list, prev_psoc_node, &psoc_node) == 992 QDF_STATUS_SUCCESS) { 993 peer_next = qdf_container_of(psoc_node, struct wlan_objmgr_peer, 994 psoc_peer); 995 996 if (wlan_objmgr_peer_try_get_ref_debug(peer_next, dbg_id, 997 func, line) == 998 QDF_STATUS_SUCCESS) { 999 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1000 return peer_next; 1001 } 1002 1003 prev_psoc_node = psoc_node; 1004 } 1005 1006 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1007 1008 return NULL; 1009 } 1010 #else 1011 struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_psoc( 1012 struct wlan_peer_list *peer_list, 1013 uint8_t hash_index, 1014 struct wlan_objmgr_peer *peer, 1015 wlan_objmgr_ref_dbgid dbg_id) 1016 { 1017 struct wlan_objmgr_peer *peer_next = NULL; 1018 qdf_list_node_t *psoc_node = NULL; 1019 qdf_list_node_t *prev_psoc_node = NULL; 1020 qdf_list_t *obj_list; 1021 1022 qdf_spin_lock_bh(&peer_list->peer_list_lock); 1023 obj_list = &peer_list->peer_hash[hash_index]; 1024 1025 prev_psoc_node = &peer->psoc_peer; 1026 while (qdf_list_peek_next(obj_list, prev_psoc_node, &psoc_node) == 1027 QDF_STATUS_SUCCESS) { 1028 peer_next = qdf_container_of(psoc_node, struct wlan_objmgr_peer, 1029 psoc_peer); 1030 1031 if (wlan_objmgr_peer_try_get_ref(peer_next, dbg_id) == 1032 QDF_STATUS_SUCCESS) { 1033 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1034 return peer_next; 1035 } 1036 1037 prev_psoc_node = psoc_node; 1038 } 1039 1040 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1041 1042 return NULL; 1043 } 1044 #endif 1045 1046 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1047 struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_active_head_debug( 1048 struct wlan_objmgr_vdev *vdev, 1049 qdf_list_t *peer_list, 1050 wlan_objmgr_ref_dbgid dbg_id, 1051 const char *func, int line) 1052 { 1053 struct wlan_objmgr_peer *peer; 1054 qdf_list_node_t *vdev_node = NULL; 1055 qdf_list_node_t *prev_vdev_node = NULL; 1056 1057 wlan_vdev_obj_lock(vdev); 1058 1059 if (qdf_list_peek_front(peer_list, &vdev_node) != QDF_STATUS_SUCCESS) { 1060 wlan_vdev_obj_unlock(vdev); 1061 return NULL; 1062 } 1063 1064 do { 1065 peer = qdf_container_of(vdev_node, struct wlan_objmgr_peer, 1066 vdev_peer); 1067 1068 if (wlan_objmgr_peer_try_get_ref_debug(peer, dbg_id, 1069 func, line) == 1070 QDF_STATUS_SUCCESS) { 1071 wlan_vdev_obj_unlock(vdev); 1072 return peer; 1073 } 1074 1075 prev_vdev_node = vdev_node; 1076 } while (qdf_list_peek_next(peer_list, prev_vdev_node, &vdev_node) == 1077 QDF_STATUS_SUCCESS); 1078 1079 wlan_vdev_obj_unlock(vdev); 1080 1081 return NULL; 1082 } 1083 #else 1084 struct wlan_objmgr_peer *wlan_vdev_peer_list_peek_active_head( 1085 struct wlan_objmgr_vdev *vdev, 1086 qdf_list_t *peer_list, 1087 wlan_objmgr_ref_dbgid dbg_id) 1088 { 1089 struct wlan_objmgr_peer *peer; 1090 qdf_list_node_t *vdev_node = NULL; 1091 qdf_list_node_t *prev_vdev_node = NULL; 1092 1093 wlan_vdev_obj_lock(vdev); 1094 1095 if (qdf_list_peek_front(peer_list, &vdev_node) != QDF_STATUS_SUCCESS) { 1096 wlan_vdev_obj_unlock(vdev); 1097 return NULL; 1098 } 1099 1100 do { 1101 peer = qdf_container_of(vdev_node, struct wlan_objmgr_peer, 1102 vdev_peer); 1103 1104 if (wlan_objmgr_peer_try_get_ref(peer, dbg_id) == 1105 QDF_STATUS_SUCCESS) { 1106 wlan_vdev_obj_unlock(vdev); 1107 return peer; 1108 } 1109 1110 prev_vdev_node = vdev_node; 1111 } while (qdf_list_peek_next(peer_list, prev_vdev_node, &vdev_node) == 1112 QDF_STATUS_SUCCESS); 1113 1114 wlan_vdev_obj_unlock(vdev); 1115 1116 return NULL; 1117 } 1118 #endif 1119 1120 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1121 struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_vdev_debug( 1122 struct wlan_objmgr_vdev *vdev, 1123 qdf_list_t *peer_list, 1124 struct wlan_objmgr_peer *peer, 1125 wlan_objmgr_ref_dbgid dbg_id, 1126 const char *func, int line) 1127 { 1128 struct wlan_objmgr_peer *peer_next; 1129 qdf_list_node_t *vdev_node = NULL; 1130 qdf_list_node_t *prev_vdev_node = NULL; 1131 1132 if (!peer) 1133 return NULL; 1134 1135 wlan_vdev_obj_lock(vdev); 1136 1137 prev_vdev_node = &peer->vdev_peer; 1138 while (qdf_list_peek_next(peer_list, prev_vdev_node, &vdev_node) == 1139 QDF_STATUS_SUCCESS) { 1140 peer_next = qdf_container_of(vdev_node, struct wlan_objmgr_peer, 1141 vdev_peer); 1142 1143 if (wlan_objmgr_peer_try_get_ref_debug(peer_next, dbg_id, 1144 func, line) == 1145 QDF_STATUS_SUCCESS) { 1146 wlan_vdev_obj_unlock(vdev); 1147 return peer_next; 1148 } 1149 1150 prev_vdev_node = vdev_node; 1151 } 1152 1153 wlan_vdev_obj_unlock(vdev); 1154 1155 return NULL; 1156 } 1157 #else 1158 struct wlan_objmgr_peer *wlan_peer_get_next_active_peer_of_vdev( 1159 struct wlan_objmgr_vdev *vdev, 1160 qdf_list_t *peer_list, 1161 struct wlan_objmgr_peer *peer, 1162 wlan_objmgr_ref_dbgid dbg_id) 1163 { 1164 struct wlan_objmgr_peer *peer_next; 1165 qdf_list_node_t *vdev_node = NULL; 1166 qdf_list_node_t *prev_vdev_node = NULL; 1167 1168 if (!peer) 1169 return NULL; 1170 1171 wlan_vdev_obj_lock(vdev); 1172 1173 prev_vdev_node = &peer->vdev_peer; 1174 while (qdf_list_peek_next(peer_list, prev_vdev_node, &vdev_node) == 1175 QDF_STATUS_SUCCESS) { 1176 peer_next = qdf_container_of(vdev_node, struct wlan_objmgr_peer, 1177 vdev_peer); 1178 1179 if (wlan_objmgr_peer_try_get_ref(peer_next, dbg_id) == 1180 QDF_STATUS_SUCCESS) { 1181 wlan_vdev_obj_unlock(vdev); 1182 return peer_next; 1183 } 1184 1185 prev_vdev_node = vdev_node; 1186 } 1187 1188 wlan_vdev_obj_unlock(vdev); 1189 1190 return NULL; 1191 } 1192 #endif 1193 1194 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1195 struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head_debug( 1196 struct wlan_peer_list *peer_list, 1197 uint8_t hash_index, 1198 wlan_objmgr_ref_dbgid dbg_id, 1199 const char *func, int line) 1200 { 1201 struct wlan_objmgr_peer *peer; 1202 qdf_list_node_t *psoc_node = NULL; 1203 qdf_list_node_t *prev_psoc_node = NULL; 1204 qdf_list_t *obj_list; 1205 1206 qdf_spin_lock_bh(&peer_list->peer_list_lock); 1207 obj_list = &peer_list->peer_hash[hash_index]; 1208 1209 if (qdf_list_peek_front(obj_list, &psoc_node) != QDF_STATUS_SUCCESS) { 1210 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1211 return NULL; 1212 } 1213 1214 do { 1215 peer = qdf_container_of(psoc_node, struct wlan_objmgr_peer, 1216 psoc_peer); 1217 if (wlan_objmgr_peer_try_get_ref_debug(peer, dbg_id, 1218 func, line) == 1219 QDF_STATUS_SUCCESS) { 1220 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1221 return peer; 1222 } 1223 1224 prev_psoc_node = psoc_node; 1225 } while (qdf_list_peek_next(obj_list, prev_psoc_node, &psoc_node) == 1226 QDF_STATUS_SUCCESS); 1227 1228 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1229 return NULL; 1230 } 1231 #else 1232 struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_active_head( 1233 struct wlan_peer_list *peer_list, 1234 uint8_t hash_index, 1235 wlan_objmgr_ref_dbgid dbg_id) 1236 { 1237 struct wlan_objmgr_peer *peer; 1238 qdf_list_node_t *psoc_node = NULL; 1239 qdf_list_node_t *prev_psoc_node = NULL; 1240 qdf_list_t *obj_list; 1241 1242 qdf_spin_lock_bh(&peer_list->peer_list_lock); 1243 obj_list = &peer_list->peer_hash[hash_index]; 1244 1245 if (qdf_list_peek_front(obj_list, &psoc_node) != QDF_STATUS_SUCCESS) { 1246 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1247 return NULL; 1248 } 1249 1250 do { 1251 peer = qdf_container_of(psoc_node, struct wlan_objmgr_peer, 1252 psoc_peer); 1253 if (wlan_objmgr_peer_try_get_ref(peer, dbg_id) == 1254 QDF_STATUS_SUCCESS) { 1255 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1256 return peer; 1257 } 1258 1259 prev_psoc_node = psoc_node; 1260 } while (qdf_list_peek_next(obj_list, prev_psoc_node, &psoc_node) == 1261 QDF_STATUS_SUCCESS); 1262 1263 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1264 return NULL; 1265 } 1266 #endif 1267 1268 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1269 struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref_debug( 1270 struct wlan_peer_list *peer_list, 1271 uint8_t hash_index, 1272 wlan_objmgr_ref_dbgid dbg_id, 1273 const char *func, int line) 1274 { 1275 struct wlan_objmgr_peer *peer; 1276 qdf_list_t *obj_list; 1277 1278 qdf_spin_lock_bh(&peer_list->peer_list_lock); 1279 obj_list = &peer_list->peer_hash[hash_index]; 1280 1281 peer = wlan_psoc_peer_list_peek_head(obj_list); 1282 1283 /* This API is invoked by caller, only when caller need to access the 1284 * peer object, though object is not in active state, this API should be 1285 * used carefully, where multiple object frees are not triggered 1286 */ 1287 if (peer) 1288 wlan_objmgr_peer_get_ref_debug(peer, dbg_id, func, line); 1289 1290 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1291 1292 return peer; 1293 } 1294 #else 1295 struct wlan_objmgr_peer *wlan_psoc_peer_list_peek_head_ref( 1296 struct wlan_peer_list *peer_list, 1297 uint8_t hash_index, 1298 wlan_objmgr_ref_dbgid dbg_id) 1299 { 1300 struct wlan_objmgr_peer *peer; 1301 qdf_list_t *obj_list; 1302 1303 qdf_spin_lock_bh(&peer_list->peer_list_lock); 1304 obj_list = &peer_list->peer_hash[hash_index]; 1305 1306 peer = wlan_psoc_peer_list_peek_head(obj_list); 1307 1308 /* This API is invoked by caller, only when caller need to access the 1309 * peer object, though object is not in active state, this API should be 1310 * used carefully, where multiple object frees are not triggered 1311 */ 1312 if (peer) 1313 wlan_objmgr_peer_get_ref(peer, dbg_id); 1314 1315 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1316 1317 return peer; 1318 } 1319 #endif 1320 1321 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1322 struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref_debug( 1323 struct wlan_peer_list *peer_list, uint8_t hash_index, 1324 struct wlan_objmgr_peer *peer, 1325 wlan_objmgr_ref_dbgid dbg_id, 1326 const char *func, int line) 1327 { 1328 qdf_list_t *obj_list; 1329 struct wlan_objmgr_peer *peer_next; 1330 1331 qdf_spin_lock_bh(&peer_list->peer_list_lock); 1332 obj_list = &peer_list->peer_hash[hash_index]; 1333 1334 peer_next = wlan_peer_get_next_peer_of_psoc(obj_list, peer); 1335 /* This API is invoked by caller, only when caller need to access the 1336 * peer object, though object is not in active state, this API should be 1337 * used carefully, where multiple free on object are not triggered 1338 */ 1339 if (peer_next) 1340 wlan_objmgr_peer_get_ref_debug(peer_next, dbg_id, func, line); 1341 1342 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1343 1344 return peer_next; 1345 } 1346 #else 1347 struct wlan_objmgr_peer *wlan_peer_get_next_peer_of_psoc_ref( 1348 struct wlan_peer_list *peer_list, uint8_t hash_index, 1349 struct wlan_objmgr_peer *peer, 1350 wlan_objmgr_ref_dbgid dbg_id) 1351 { 1352 qdf_list_t *obj_list; 1353 struct wlan_objmgr_peer *peer_next; 1354 1355 qdf_spin_lock_bh(&peer_list->peer_list_lock); 1356 obj_list = &peer_list->peer_hash[hash_index]; 1357 1358 peer_next = wlan_peer_get_next_peer_of_psoc(obj_list, peer); 1359 /* This API is invoked by caller, only when caller need to access the 1360 * peer object, though object is not in active state, this API should be 1361 * used carefully, where multiple free on object are not triggered 1362 */ 1363 if (peer_next) 1364 wlan_objmgr_peer_get_ref(peer_next, dbg_id); 1365 1366 qdf_spin_unlock_bh(&peer_list->peer_list_lock); 1367 1368 return peer_next; 1369 } 1370 #endif 1371 1372 #ifdef WLAN_OBJMGR_REF_ID_TRACE 1373 void wlan_objmgr_peer_release_ref_debug(struct wlan_objmgr_peer *peer, 1374 wlan_objmgr_ref_dbgid id, 1375 const char *func, int line) 1376 { 1377 QDF_STATUS status; 1378 1379 if (!peer) { 1380 obj_mgr_err("peer obj is NULL for %d", id); 1381 QDF_ASSERT(0); 1382 return; 1383 } 1384 1385 if (!qdf_atomic_read(&peer->peer_objmgr.ref_cnt)) { 1386 uint8_t *macaddr; 1387 1388 macaddr = wlan_peer_get_macaddr(peer); 1389 obj_mgr_err("peer("QDF_MAC_ADDR_FMT") ref cnt is 0", 1390 QDF_MAC_ADDR_REF(macaddr)); 1391 WLAN_OBJMGR_BUG(0); 1392 return; 1393 } 1394 1395 status = wlan_objmgr_peer_release_debug_id_ref(peer, id); 1396 if (QDF_IS_STATUS_ERROR(status)) 1397 return; 1398 1399 wlan_objmgr_peer_deref_trace(peer, id, func, line); 1400 /* Provide synchronization from the access to add peer 1401 * to logically deleted peer list. 1402 */ 1403 wlan_peer_obj_lock(peer); 1404 /* Decrement ref count, free peer object, if ref count == 0 */ 1405 if (qdf_atomic_dec_and_test(&peer->peer_objmgr.ref_cnt)) { 1406 wlan_peer_obj_unlock(peer); 1407 wlan_objmgr_peer_obj_destroy(peer); 1408 } else { 1409 wlan_peer_obj_unlock(peer); 1410 } 1411 1412 return; 1413 } 1414 1415 qdf_export_symbol(wlan_objmgr_peer_release_ref_debug); 1416 #else 1417 void wlan_objmgr_peer_release_ref(struct wlan_objmgr_peer *peer, 1418 wlan_objmgr_ref_dbgid id) 1419 { 1420 QDF_STATUS status; 1421 1422 if (!peer) { 1423 obj_mgr_err("peer obj is NULL for %d", id); 1424 QDF_ASSERT(0); 1425 return; 1426 } 1427 1428 if (!qdf_atomic_read(&peer->peer_objmgr.ref_cnt)) { 1429 uint8_t *macaddr; 1430 1431 macaddr = wlan_peer_get_macaddr(peer); 1432 obj_mgr_err("peer("QDF_MAC_ADDR_FMT") ref cnt is 0", 1433 QDF_MAC_ADDR_REF(macaddr)); 1434 WLAN_OBJMGR_BUG(0); 1435 return; 1436 } 1437 1438 status = wlan_objmgr_peer_release_debug_id_ref(peer, id); 1439 if (QDF_IS_STATUS_ERROR(status)) 1440 return; 1441 1442 /* Provide synchronization from the access to add peer 1443 * to logically deleted peer list. 1444 */ 1445 wlan_peer_obj_lock(peer); 1446 /* Decrement ref count, free peer object, if ref count == 0 */ 1447 if (qdf_atomic_dec_and_test(&peer->peer_objmgr.ref_cnt)) { 1448 wlan_peer_obj_unlock(peer); 1449 wlan_objmgr_peer_obj_destroy(peer); 1450 } else { 1451 wlan_peer_obj_unlock(peer); 1452 } 1453 } 1454 1455 qdf_export_symbol(wlan_objmgr_peer_release_ref); 1456 #endif 1457 1458 #ifdef WLAN_OBJMGR_REF_ID_DEBUG 1459 void 1460 wlan_objmgr_print_peer_ref_ids(struct wlan_objmgr_peer *peer, 1461 QDF_TRACE_LEVEL log_level) 1462 { 1463 wlan_objmgr_print_ref_ids(peer->peer_objmgr.ref_id_dbg, log_level); 1464 } 1465 1466 uint32_t 1467 wlan_objmgr_peer_get_comp_ref_cnt(struct wlan_objmgr_peer *peer, 1468 enum wlan_umac_comp_id id) 1469 { 1470 return qdf_atomic_read(&peer->peer_objmgr.ref_id_dbg[id]); 1471 } 1472 #else 1473 void 1474 wlan_objmgr_print_peer_ref_ids(struct wlan_objmgr_peer *peer, 1475 QDF_TRACE_LEVEL log_level) 1476 { 1477 uint32_t pending_ref; 1478 1479 pending_ref = qdf_atomic_read(&peer->peer_objmgr.ref_cnt); 1480 obj_mgr_log_level(log_level, "Pending refs -- %d", pending_ref); 1481 } 1482 1483 uint32_t 1484 wlan_objmgr_peer_get_comp_ref_cnt(struct wlan_objmgr_peer *peer, 1485 enum wlan_umac_comp_id id) 1486 { 1487 return 0; 1488 } 1489 #endif 1490 1491 #ifdef WLAN_FEATURE_DYNAMIC_MAC_ADDR_UPDATE 1492 QDF_STATUS wlan_peer_update_macaddr(struct wlan_objmgr_peer *peer, 1493 uint8_t *new_macaddr) 1494 { 1495 struct wlan_objmgr_psoc *psoc; 1496 struct wlan_objmgr_vdev *vdev; 1497 uint8_t *macaddr; 1498 QDF_STATUS status; 1499 1500 if (!peer) { 1501 obj_mgr_err("PEER is NULL"); 1502 return QDF_STATUS_E_FAILURE; 1503 } 1504 1505 macaddr = wlan_peer_get_macaddr(peer); 1506 1507 vdev = wlan_peer_get_vdev(peer); 1508 if (!vdev) { 1509 obj_mgr_err("VDEV is NULL for peer(" QDF_MAC_ADDR_FMT ")", 1510 QDF_MAC_ADDR_REF(macaddr)); 1511 return QDF_STATUS_E_FAILURE; 1512 } 1513 1514 /* get PSOC from VDEV, if it is NULL, return */ 1515 psoc = wlan_vdev_get_psoc(vdev); 1516 if (!psoc) { 1517 obj_mgr_err("PSOC is NULL for peer(" QDF_MAC_ADDR_FMT ")", 1518 QDF_MAC_ADDR_REF(macaddr)); 1519 return QDF_STATUS_E_FAILURE; 1520 } 1521 1522 status = wlan_objmgr_psoc_peer_detach(psoc, peer); 1523 if (QDF_IS_STATUS_ERROR(status)) { 1524 obj_mgr_err("Failed to detach peer(" QDF_MAC_ADDR_FMT ")", 1525 QDF_MAC_ADDR_REF(macaddr)); 1526 return status; 1527 } 1528 1529 wlan_peer_set_macaddr(peer, new_macaddr); 1530 1531 status = wlan_objmgr_psoc_peer_attach(psoc, peer); 1532 if (QDF_IS_STATUS_ERROR(status)) { 1533 obj_mgr_err("Failed to attach peer(" QDF_MAC_ADDR_FMT ")", 1534 QDF_MAC_ADDR_REF(new_macaddr)); 1535 return status; 1536 } 1537 return QDF_STATUS_SUCCESS; 1538 } 1539 #endif 1540