Print this page
patch as-lock-macro-simplification

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/xen/io/xpvtap.c
          +++ new/usr/src/uts/common/xen/io/xpvtap.c
↓ open down ↓ 781 lines elided ↑ open up ↑
 782  782  
 783  783  
 784  784          as = state->bt_map.um_as;
 785  785          pgcnt = btopr(state->bt_map.um_guest_size);
 786  786          uaddr = state->bt_map.um_guest_pages;
 787  787  
 788  788          if (pgcnt == 0) {
 789  789                  return (DDI_FAILURE);
 790  790          }
 791  791  
 792      -        AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
      792 +        AS_LOCK_ENTER(as, RW_READER);
 793  793  
 794  794          seg = as_findseg(as, state->bt_map.um_guest_pages, 0);
 795  795          if ((seg == NULL) || ((uaddr + state->bt_map.um_guest_size) >
 796  796              (seg->s_base + seg->s_size))) {
 797      -                AS_LOCK_EXIT(as, &as->a_lock);
      797 +                AS_LOCK_EXIT(as);
 798  798                  return (DDI_FAILURE);
 799  799          }
 800  800  
 801  801          /*
 802  802           * lock down the htables so the HAT can't steal them. Register the
 803  803           * PTE MA's for each gref page with seg_mf so we can do user space
 804  804           * gref mappings.
 805  805           */
 806  806          for (i = 0; i < pgcnt; i++) {
 807  807                  hat_prepare_mapping(as->a_hat, uaddr, &pte_ma);
 808  808                  hat_devload(as->a_hat, uaddr, PAGESIZE, (pfn_t)0,
 809  809                      PROT_READ | PROT_WRITE | PROT_USER | HAT_UNORDERED_OK,
 810  810                      HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
 811  811                  hat_release_mapping(as->a_hat, uaddr);
 812  812                  segmf_add_gref_pte(seg, uaddr, pte_ma);
 813  813                  uaddr += PAGESIZE;
 814  814          }
 815  815  
 816  816          state->bt_map.um_registered = B_TRUE;
 817  817  
 818      -        AS_LOCK_EXIT(as, &as->a_lock);
      818 +        AS_LOCK_EXIT(as);
 819  819  
 820  820          return (DDI_SUCCESS);
 821  821  }
 822  822  
 823  823  
 824  824  /*
 825  825   * xpvtap_segmf_unregister()
 826  826   *    as_callback routine
 827  827   */
 828  828  /*ARGSUSED*/
↓ open down ↓ 14 lines elided ↑ open up ↑
 843  843          }
 844  844  
 845  845          pgcnt = btopr(state->bt_map.um_guest_size);
 846  846          uaddr = state->bt_map.um_guest_pages;
 847  847  
 848  848          /* unmap any outstanding req's grefs */
 849  849          xpvtap_rs_flush(state->bt_map.um_rs, xpvtap_user_request_unmap, state);
 850  850  
 851  851          /* Unlock the gref pages */
 852  852          for (i = 0; i < pgcnt; i++) {
 853      -                AS_LOCK_ENTER(as, &as->a_lock, RW_WRITER);
      853 +                AS_LOCK_ENTER(as, RW_WRITER);
 854  854                  hat_prepare_mapping(as->a_hat, uaddr, NULL);
 855  855                  hat_unload(as->a_hat, uaddr, PAGESIZE, HAT_UNLOAD_UNLOCK);
 856  856                  hat_release_mapping(as->a_hat, uaddr);
 857      -                AS_LOCK_EXIT(as, &as->a_lock);
      857 +                AS_LOCK_EXIT(as);
 858  858                  uaddr += PAGESIZE;
 859  859          }
 860  860  
 861  861          /* remove the callback (which is this routine) */
 862  862          (void) as_delete_callback(as, arg);
 863  863  
 864  864          state->bt_map.um_registered = B_FALSE;
 865  865  }
 866  866  
 867  867  
↓ open down ↓ 353 lines elided ↑ open up ↑
1221 1221          /* if we don't have any segments to map, we're done */
1222 1222          if ((req->operation == BLKIF_OP_WRITE_BARRIER) ||
1223 1223              (req->operation == BLKIF_OP_FLUSH_DISKCACHE) ||
1224 1224              (req->nr_segments == 0)) {
1225 1225                  return (DDI_SUCCESS);
1226 1226          }
1227 1227  
1228 1228          /* get the apps gref address */
1229 1229          uaddr = XPVTAP_GREF_REQADDR(state->bt_map.um_guest_pages, *uid);
1230 1230  
1231      -        AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
     1231 +        AS_LOCK_ENTER(as, RW_READER);
1232 1232          seg = as_findseg(as, state->bt_map.um_guest_pages, 0);
1233 1233          if ((seg == NULL) || ((uaddr + mmu_ptob(req->nr_segments)) >
1234 1234              (seg->s_base + seg->s_size))) {
1235      -                AS_LOCK_EXIT(as, &as->a_lock);
     1235 +                AS_LOCK_EXIT(as);
1236 1236                  return (DDI_FAILURE);
1237 1237          }
1238 1238  
1239 1239          /* if we are reading from disk, we are writing into memory */
1240 1240          flags = 0;
1241 1241          if (req->operation == BLKIF_OP_READ) {
1242 1242                  flags |= SEGMF_GREF_WR;
1243 1243          }
1244 1244  
1245 1245          /* Load the grefs into seg_mf */
1246 1246          for (i = 0; i < req->nr_segments; i++) {
1247 1247                  gref[i] = req->seg[i].gref;
1248 1248          }
1249 1249          (void) segmf_add_grefs(seg, uaddr, flags, gref, req->nr_segments,
1250 1250              domid);
1251 1251  
1252      -        AS_LOCK_EXIT(as, &as->a_lock);
     1252 +        AS_LOCK_EXIT(as);
1253 1253  
1254 1254          return (DDI_SUCCESS);
1255 1255  }
1256 1256  
1257 1257  
1258 1258  /*
1259 1259   * xpvtap_user_request_push()
1260 1260   */
1261 1261  static int
1262 1262  xpvtap_user_request_push(xpvtap_state_t *state, blkif_request_t *req,
↓ open down ↓ 44 lines elided ↑ open up ↑
1307 1307          }
1308 1308  
1309 1309          /* get a copy of the original request */
1310 1310          req = &state->bt_map.um_outstanding_reqs[uid];
1311 1311  
1312 1312          /* unmap the grefs for this request */
1313 1313          if ((req->operation != BLKIF_OP_WRITE_BARRIER) &&
1314 1314              (req->operation != BLKIF_OP_FLUSH_DISKCACHE) &&
1315 1315              (req->nr_segments != 0)) {
1316 1316                  uaddr = XPVTAP_GREF_REQADDR(state->bt_map.um_guest_pages, uid);
1317      -                AS_LOCK_ENTER(as, &as->a_lock, RW_READER);
     1317 +                AS_LOCK_ENTER(as, RW_READER);
1318 1318                  seg = as_findseg(as, state->bt_map.um_guest_pages, 0);
1319 1319                  if ((seg == NULL) || ((uaddr + mmu_ptob(req->nr_segments)) >
1320 1320                      (seg->s_base + seg->s_size))) {
1321      -                        AS_LOCK_EXIT(as, &as->a_lock);
     1321 +                        AS_LOCK_EXIT(as);
1322 1322                          xpvtap_rs_free(state->bt_map.um_rs, uid);
1323 1323                          return;
1324 1324                  }
1325 1325  
1326 1326                  e = segmf_release_grefs(seg, uaddr, req->nr_segments);
1327 1327                  if (e != 0) {
1328 1328                          cmn_err(CE_WARN, "unable to release grefs");
1329 1329                  }
1330 1330  
1331      -                AS_LOCK_EXIT(as, &as->a_lock);
     1331 +                AS_LOCK_EXIT(as);
1332 1332          }
1333 1333  
1334 1334          /* free up the user ring id */
1335 1335          xpvtap_rs_free(state->bt_map.um_rs, uid);
1336 1336  }
1337 1337  
1338 1338  
1339 1339  static int
1340 1340  xpvtap_user_response_get(xpvtap_state_t *state, blkif_response_t *resp,
1341 1341      uint_t *uid)
↓ open down ↓ 297 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX