Print this page 
8368 remove warlock leftovers from usr/src/uts
Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/io/ib/adapters/tavor/tavor_ioctl.c
          +++ new/usr/src/uts/common/io/ib/adapters/tavor/tavor_ioctl.c
↓ open down ↓ 901 lines elided ↑ open up ↑ 
 902  902          }
 903  903  
 904  904          /* Allocate space for temporary GID table/PKey table */
 905  905          tbl_size = (1 << state->ts_cfg_profile->cp_log_max_gidtbl);
 906  906          sgid_tbl = (ib_gid_t *)kmem_zalloc(tbl_size * sizeof (ib_gid_t),
 907  907              KM_SLEEP);
 908  908          tbl_size = (1 << state->ts_cfg_profile->cp_log_max_pkeytbl);
 909  909          pkey_tbl = (ib_pkey_t *)kmem_zalloc(tbl_size * sizeof (ib_pkey_t),
 910  910              KM_SLEEP);
 911  911  
 912      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*sgid_tbl, *pkey_tbl))
 913      -
 914  912          /*
 915  913           * Setup the number of ports, then loop through all ports and
 916  914           * query properties of each.
 917  915           */
 918  916          info.tp_num_ports = (uint8_t)state->ts_cfg_profile->cp_num_ports;
 919  917          for (i = 0; i < info.tp_num_ports; i++) {
 920  918                  /*
 921  919                   * Get portstate information from the device.  If
 922  920                   * tavor_port_query() fails, leave zeroes in user
 923  921                   * struct port entry and continue.
↓ open down ↓ 68 lines elided ↑ open up ↑ 
 992  990          tavor_loopback_ioctl_t  lb;
 993  991          tavor_loopback_state_t  lstate;
 994  992          ibt_hca_portinfo_t      pi;
 995  993          uint_t                  tbl_size, loopmax, max_usec;
 996  994          ib_gid_t                *sgid_tbl;
 997  995          ib_pkey_t               *pkey_tbl;
 998  996          int                     j, iter, ret;
 999  997  
1000  998          TAVOR_TNF_ENTER(tavor_ioctl_loopback);
1001  999  
1002      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(lstate))
1003      -
1004 1000          /*
1005 1001           * Access to Tavor VTS ioctls is not allowed in "maintenance mode".
1006 1002           */
1007 1003          if (state->ts_operational_mode == TAVOR_MAINTENANCE_MODE) {
1008 1004                  TNF_PROBE_0(tavor_ioctl_loopback_maintenance_mode_fail,
1009 1005                      TAVOR_TNF_ERROR, "");
1010 1006                  TAVOR_TNF_EXIT(tavor_ioctl_loopback);
1011 1007                  return (EFAULT);
1012 1008          }
1013 1009
↓ open down ↓ 930 lines elided ↑ open up ↑ 
1944 1940          uint32_t                bank;
1945 1941  
1946 1942          TAVOR_TNF_ENTER(tavor_flash_bank);
1947 1943  
1948 1944          /* Set handle */
1949 1945          hdl = state->ts_pci_cfghdl;
1950 1946  
1951 1947          /* Determine the bank setting from the address */
1952 1948          bank = addr & TAVOR_HW_FLASH_BANK_MASK;
1953 1949  
1954      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(state->ts_fw_flashbank))
1955      -
1956 1950          /*
1957 1951           * If the bank is different from the currently set bank, we need to
1958 1952           * change it.  Also, if an 'addr' of 0 is given, this allows the
1959 1953           * capability to force the flash bank to 0.  This is useful at init
1960 1954           * time to initially set the bank value
1961 1955           */
1962 1956          if (state->ts_fw_flashbank != bank || addr == 0) {
1963 1957                  /* Set bank using the GPIO settings */
1964 1958                  tavor_flash_write_cfg(hdl, TAVOR_HW_FLASH_GPIO_DATACLEAR, 0x70);
1965 1959                  tavor_flash_write_cfg(hdl, TAVOR_HW_FLASH_GPIO_DATASET,
↓ open down ↓ 360 lines elided ↑ open up ↑ 
2326 2320  }
2327 2321  
2328 2322  /*
2329 2323   * tavor_loopback_free_qps
2330 2324   */
2331 2325  static void
2332 2326  tavor_loopback_free_qps(tavor_loopback_state_t *lstate)
2333 2327  {
2334 2328          int i;
2335 2329  
2336      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*lstate))
2337      -
2338 2330          if (lstate->tls_tx.tlc_qp_hdl != NULL) {
2339 2331                  (void) tavor_qp_free(lstate->tls_state,
2340 2332                      &lstate->tls_tx.tlc_qp_hdl, IBC_FREE_QP_AND_QPN, NULL,
2341 2333                      TAVOR_NOSLEEP);
2342 2334          }
2343 2335          if (lstate->tls_rx.tlc_qp_hdl != NULL) {
2344 2336                  (void) tavor_qp_free(lstate->tls_state,
2345 2337                      &lstate->tls_rx.tlc_qp_hdl, IBC_FREE_QP_AND_QPN, NULL,
2346 2338                      TAVOR_NOSLEEP);
2347 2339          }
↓ open down ↓ 41 lines elided ↑ open up ↑ 
2389 2381          }
2390 2382          bzero(lstate, sizeof (tavor_loopback_state_t));
2391 2383  }
2392 2384  
2393 2385  /*
2394 2386   * tavor_loopback_init
2395 2387   */
2396 2388  static int
2397 2389  tavor_loopback_init(tavor_state_t *state, tavor_loopback_state_t *lstate)
2398 2390  {
2399      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*lstate))
2400      -
2401 2391          lstate->tls_hca_hdl = (ibc_hca_hdl_t)state;
2402 2392          lstate->tls_status  = tavor_pd_alloc(lstate->tls_state,
2403 2393              &lstate->tls_pd_hdl, TAVOR_NOSLEEP);
2404 2394          if (lstate->tls_status != IBT_SUCCESS) {
2405 2395                  lstate->tls_err = TAVOR_LOOPBACK_PROT_DOMAIN_ALLOC_FAIL;
2406 2396                  TNF_PROBE_0(tavor_ioctl_loopback_alloc_pd_fail,
2407 2397                      TAVOR_TNF_ERROR, "");
2408 2398                  return (EFAULT);
2409 2399          }
2410 2400
↓ open down ↓ 44 lines elided ↑ open up ↑ 
2455 2445          comm->tlc_qp_info.qp_transport.rc.rc_path_mtu = IB_MTU_1K;
2456 2446  }
2457 2447  
2458 2448  /*
2459 2449   * tavor_loopback_alloc_mem
2460 2450   */
2461 2451  static int
2462 2452  tavor_loopback_alloc_mem(tavor_loopback_state_t *lstate,
2463 2453      tavor_loopback_comm_t *comm, int sz)
2464 2454  {
2465      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*comm))
2466      -
2467 2455          /* Allocate buffer of specified size */
2468 2456          comm->tlc_buf_sz = sz;
2469 2457          comm->tlc_buf    = kmem_zalloc(sz, KM_NOSLEEP);
2470 2458          if (comm->tlc_buf == NULL) {
2471 2459                  return (EFAULT);
2472 2460          }
2473 2461  
2474 2462          /* Register the buffer as a memory region */
2475 2463          comm->tlc_memattr.mr_vaddr = (uint64_t)(uintptr_t)comm->tlc_buf;
2476 2464          comm->tlc_memattr.mr_len   = (ib_msglen_t)sz;
2477 2465          comm->tlc_memattr.mr_as    = NULL;
2478 2466          comm->tlc_memattr.mr_flags = IBT_MR_NOSLEEP |
2479 2467              IBT_MR_ENABLE_REMOTE_WRITE | IBT_MR_ENABLE_LOCAL_WRITE;
2480 2468  
2481 2469          comm->tlc_status = tavor_mr_register(lstate->tls_state,
2482 2470              lstate->tls_pd_hdl, &comm->tlc_memattr, &comm->tlc_mrhdl, NULL);
2483 2471  
2484      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*comm->tlc_mrhdl))
2485      -
2486 2472          comm->tlc_mrdesc.md_vaddr  = comm->tlc_mrhdl->mr_bindinfo.bi_addr;
2487 2473          comm->tlc_mrdesc.md_lkey   = comm->tlc_mrhdl->mr_lkey;
2488 2474          comm->tlc_mrdesc.md_rkey   = comm->tlc_mrhdl->mr_rkey;
2489 2475          if (comm->tlc_status != IBT_SUCCESS) {
2490 2476                  return (EFAULT);
2491 2477          }
2492 2478          return (0);
2493 2479  }
2494 2480  
2495 2481  /*
2496 2482   * tavor_loopback_alloc_qps
2497 2483   */
2498 2484  static int
2499 2485  tavor_loopback_alloc_qps(tavor_loopback_state_t *lstate,
2500 2486      tavor_loopback_comm_t *comm)
2501 2487  {
2502 2488          uint32_t                i, real_size;
2503 2489          tavor_qp_info_t         qpinfo;
2504 2490  
2505      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*comm))
2506      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*lstate))
2507      -
2508 2491          /* Allocate send and recv CQs */
2509 2492          for (i = 0; i < 2; i++) {
2510 2493                  bzero(&comm->tlc_cq_attr, sizeof (ibt_cq_attr_t));
2511 2494                  comm->tlc_cq_attr.cq_size = 128;
2512 2495                  comm->tlc_status = tavor_cq_alloc(lstate->tls_state,
2513 2496                      (ibt_cq_hdl_t)NULL, &comm->tlc_cq_attr, &real_size,
2514 2497                      &comm->tlc_cqhdl[i], TAVOR_NOSLEEP);
2515 2498                  if (comm->tlc_status != IBT_SUCCESS) {
2516 2499                          lstate->tls_err += i;
2517 2500                          return (EFAULT);
↓ open down ↓ 25 lines elided ↑ open up ↑ 
2543 2526          return (0);
2544 2527  }
2545 2528  
2546 2529  /*
2547 2530   * tavor_loopback_modify_qp
2548 2531   */
2549 2532  static int
2550 2533  tavor_loopback_modify_qp(tavor_loopback_state_t *lstate,
2551 2534      tavor_loopback_comm_t *comm, uint_t qp_num)
2552 2535  {
2553      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*comm))
2554      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*lstate))
2555      -
2556 2536          /* Modify QP to INIT */
2557 2537          tavor_loopback_init_qp_info(lstate, comm);
2558 2538          comm->tlc_qp_info.qp_state = IBT_STATE_INIT;
2559 2539          comm->tlc_status = tavor_qp_modify(lstate->tls_state, comm->tlc_qp_hdl,
2560 2540              IBT_CEP_SET_STATE, &comm->tlc_qp_info, &comm->tlc_queue_sizes);
2561 2541          if (comm->tlc_status != IBT_SUCCESS) {
2562 2542                  return (EFAULT);
2563 2543          }
2564 2544  
2565 2545          /*
↓ open down ↓ 65 lines elided ↑ open up ↑ 
2631 2611  
2632 2612  /*
2633 2613   * tavor_loopback_post_send
2634 2614   */
2635 2615  static int
2636 2616  tavor_loopback_post_send(tavor_loopback_state_t *lstate,
2637 2617      tavor_loopback_comm_t *tx, tavor_loopback_comm_t *rx)
2638 2618  {
2639 2619          int      ret;
2640 2620  
2641      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*tx))
2642      -
2643 2621          bzero(&tx->tlc_sgl, sizeof (ibt_wr_ds_t));
2644 2622          bzero(&tx->tlc_wr, sizeof (ibt_send_wr_t));
2645 2623  
2646 2624          /* Initialize local address for TX buffer */
2647 2625          tx->tlc_sgl.ds_va   = tx->tlc_mrdesc.md_vaddr;
2648 2626          tx->tlc_sgl.ds_key  = tx->tlc_mrdesc.md_lkey;
2649 2627          tx->tlc_sgl.ds_len  = tx->tlc_buf_sz;
2650 2628  
2651 2629          /* Initialize the remaining details of the work request */
2652 2630          tx->tlc_wr.wr_id = tx->tlc_wrid++;
↓ open down ↓ 15 lines elided ↑ open up ↑ 
2668 2646          return (0);
2669 2647  }
2670 2648  
2671 2649  /*
2672 2650   * tavor_loopback_poll_cq
2673 2651   */
2674 2652  static int
2675 2653  tavor_loopback_poll_cq(tavor_loopback_state_t *lstate,
2676 2654      tavor_loopback_comm_t *comm)
2677 2655  {
2678      -        _NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*comm))
2679      -
2680 2656          comm->tlc_wc.wc_status  = 0;
2681 2657          comm->tlc_num_polled    = 0;
2682 2658          comm->tlc_status = tavor_cq_poll(lstate->tls_state,
2683 2659              comm->tlc_cqhdl[0], &comm->tlc_wc, 1, &comm->tlc_num_polled);
2684 2660          if ((comm->tlc_status == IBT_SUCCESS) &&
2685 2661              (comm->tlc_wc.wc_status != IBT_WC_SUCCESS)) {
2686 2662                  comm->tlc_status = ibc_get_ci_failure(0);
2687 2663          }
2688 2664          return (comm->tlc_status);
2689 2665  }
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX