Lines Matching defs:seg
251 #include <vm/seg.h>
452 static int rsm_closeconnection(rsmseg_t *seg, void **cookie);
453 static int rsm_unpublish(rsmseg_t *seg, int mode);
454 static int rsm_unbind(rsmseg_t *seg);
462 int rsm_disconnect(rsmseg_t *seg);
1742 rsmsharecv_signal(rsmseg_t *seg, int oldstate, int newstate)
1744 ASSERT(rsmsharelock_held(seg));
1746 if (seg->s_share->rsmsi_state == oldstate) {
1747 seg->s_share->rsmsi_state = newstate;
1748 cv_broadcast(&seg->s_share->rsmsi_cv);
1831 rsmseg_free(rsmseg_t *seg)
1839 rsmseglock_acquire(seg);
1840 if (seg->s_ckl != NULL) {
1842 seg->s_state = RSM_STATE_END;
1843 rsmseglock_release(seg);
1849 rsmseglock_release(seg);
1851 ASSERT(seg->s_state == RSM_STATE_END || seg->s_state == RSM_STATE_NEW);
1858 if (seg->s_share != NULL) {
1860 ASSERT(seg->s_type == RSM_RESOURCE_IMPORT_SEGMENT);
1862 rsmsharelock_acquire(seg);
1864 ASSERT(seg->s_share->rsmsi_refcnt > 0);
1866 seg->s_share->rsmsi_refcnt--;
1868 if (seg->s_share->rsmsi_refcnt == 0) {
1869 rsmsharelock_release(seg);
1870 mutex_destroy(&seg->s_share->rsmsi_lock);
1871 cv_destroy(&seg->s_share->rsmsi_cv);
1872 kmem_free((void *)(seg->s_share),
1875 rsmsharelock_release(seg);
1879 * rsmsharelock calls which use seg->s_share.
1881 seg->s_share = NULL;
1884 cv_destroy(&seg->s_cv);
1885 mutex_destroy(&seg->s_lock);
1886 rsmacl_free(seg->s_acl, seg->s_acl_len);
1887 rsmpiacl_free(seg->s_acl_in, seg->s_acl_len);
1888 if (seg->s_adapter)
1889 rsmka_release_adapter(seg->s_adapter);
1891 kmem_free((void *)seg, sizeof (*seg));
1997 rsmseg_close(rsmseg_t *seg, int force_flag)
2005 rsmseglock_acquire(seg);
2006 if (!force_flag && (seg->s_hdr.rsmrc_type ==
2014 while (seg->s_flags & RSM_FORCE_DESTROY_WAIT) {
2015 cv_wait(&seg->s_cv, &seg->s_lock);
2018 rsmseglock_release(seg);
2021 switch (seg->s_state) {
2025 e = rsm_unpublish(seg, 1);
2030 e = rsm_unbind(seg);
2033 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_EXPORT_SEGMENT);
2036 rsmseglock_acquire(seg);
2037 seg->s_state = RSM_STATE_NEW;
2038 cv_broadcast(&seg->s_cv);
2039 rsmseglock_release(seg);
2060 rsmseglock_acquire(seg);
2061 seg->s_state = RSM_STATE_NEW;
2062 rsmseglock_release(seg);
2070 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
2071 (void) rsm_disconnect(seg);
2077 "Invalid segment state %d in rsm_close\n", seg->s_state));
2081 "Invalid segment state %d in rsm_close\n", seg->s_state));
2090 ASSERT(seg->s_state == RSM_STATE_NEW);
2102 rsmseglock_acquire(seg);
2103 seg->s_state = RSM_STATE_ZOMBIE;
2104 rsmseglock_release(seg);
2106 rsmseg_free(seg);
2286 rsm_unbind_pages(rsmseg_t *seg)
2292 ASSERT(rsmseglock_held(seg));
2294 if (seg->s_cookie != NULL) {
2296 ddi_umem_unlock(seg->s_cookie);
2297 rsm_dec_pgcnt(btopr(seg->s_len));
2298 seg->s_cookie = NULL;
2308 rsm_bind(rsmseg_t *seg, rsm_ioctlmsg_t *msg, intptr_t dataptr, int mode)
2338 rsmseglock_acquire(seg);
2340 while (seg->s_state == RSM_STATE_NEW_QUIESCED) {
2341 if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
2345 rsmseglock_release(seg);
2350 ASSERT(seg->s_state == RSM_STATE_NEW);
2352 ASSERT(seg->s_cookie == NULL);
2354 e = rsm_bind_pages(&seg->s_cookie, msg->vaddr, msg->len, curproc);
2356 seg->s_flags |= RSM_USER_MEMORY;
2358 seg->s_flags |= RSMKA_ALLOW_UNBIND_REBIND;
2361 seg->s_flags |= RSMKA_SET_RESOURCE_DONTWAIT;
2363 seg->s_region.r_vaddr = msg->vaddr;
2376 seg->s_pid = ddi_get_pid();
2377 seg->s_len = msg->len;
2378 seg->s_state = RSM_STATE_BIND;
2379 seg->s_adapter = adapter;
2380 seg->s_proc = curproc;
2387 msg->rnum = seg->s_minor;
2389 rsmseglock_release(seg);
2439 rsmseg_t *seg = (rsmseg_t *)p;
2440 rsmseglock_acquire(seg);
2449 if ((seg->s_segid == ex_segid) && (seg->s_node == src_nodeid) &&
2450 (seg->s_state == RSM_STATE_ACTIVE)) {
2451 seg->s_cookie = cookie;
2453 rsmseglock_release(seg);
2462 rsm_rebind(rsmseg_t *seg, rsm_ioctlmsg_t *msg)
2472 if (!(seg->s_flags & RSMKA_ALLOW_UNBIND_REBIND)) {
2476 if (seg->s_pid != ddi_get_pid() &&
2491 if (msg->len != seg->s_len) {
2498 rsmseglock_acquire(seg);
2500 while ((seg->s_state == RSM_STATE_BIND_QUIESCED) ||
2501 (seg->s_state == RSM_STATE_EXPORT_QUIESCING) ||
2502 (seg->s_state == RSM_STATE_EXPORT_QUIESCED)) {
2503 if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
2504 rsmseglock_release(seg);
2512 if ((seg->s_state != RSM_STATE_BIND) &&
2513 (seg->s_state != RSM_STATE_EXPORT)) {
2515 rsmseglock_release(seg);
2521 ASSERT(seg->s_cookie != NULL);
2523 if (msg->vaddr == seg->s_region.r_vaddr) {
2524 rsmseglock_release(seg);
2542 adapter = seg->s_adapter;
2544 seg->s_handle.out, 0, &mem,
2552 (void) rsm_unbind_pages(seg);
2553 seg->s_cookie = cookie;
2554 seg->s_region.r_vaddr = msg->vaddr;
2555 rsm_remap_local_importers(my_nodeid, seg->s_segid,
2562 * routine for the seg->s_cookie.
2578 rsmseglock_release(seg);
2586 rsm_unbind(rsmseg_t *seg)
2592 rsmseglock_acquire(seg);
2595 if ((seg->s_state != RSM_STATE_BIND) &&
2596 (seg->s_state != RSM_STATE_BIND_QUIESCED)) {
2597 rsmseglock_release(seg);
2604 (void) rsm_unbind_pages(seg);
2606 if (seg->s_state == RSM_STATE_BIND) {
2607 seg->s_state = RSM_STATE_NEW;
2608 } else if (seg->s_state == RSM_STATE_BIND_QUIESCED) {
2609 seg->s_state = RSM_STATE_NEW_QUIESCED;
2612 rsmseglock_release(seg);
2769 rsmseg_t *seg;
2782 seg = rsmexport_lookup(key);
2783 if (!seg) {
2789 ASSERT(rsmseglock_held(seg));
2790 ASSERT(seg->s_state == RSM_STATE_EXPORT);
2799 if (seg->s_acl_len > 0) {
2803 ASSERT(seg->s_acl != NULL);
2804 for (i = 0; i < seg->s_acl_len; i++) {
2805 if (seg->s_acl[i].ae_node == rnode) {
2806 perm &= seg->s_acl[i].ae_permission;
2811 rsmseglock_release(seg);
2817 perm &= seg->s_mode;
2823 reply->rsmipc_uid = seg->s_uid;
2824 reply->rsmipc_gid = seg->s_gid;
2825 reply->rsmipc_segid = seg->s_segid;
2826 reply->rsmipc_seglen = seg->s_len;
2831 rsmseglock_release(seg);
2849 rsm_publish(rsmseg_t *seg, rsm_ioctlmsg_t *msg, intptr_t dataptr, int mode)
2867 if (seg->s_adapter == &loopback_adapter)
2870 if (seg->s_pid != ddi_get_pid() &&
2928 e = rsmexport_add(seg, segment_id);
2936 seg->s_segid = segment_id;
2938 if ((seg->s_state != RSM_STATE_BIND) &&
2939 (seg->s_state != RSM_STATE_BIND_QUIESCED)) {
2941 rsmseglock_release(seg);
2942 rsmexport_rm(seg);
2946 seg->s_state));
2964 xbuf = ddi_umem_iosetup(seg->s_cookie, 0, seg->s_len, B_WRITE,
2973 adapter = seg->s_adapter;
2980 rsmseglock_release(seg);
2981 rsmexport_rm(seg);
2989 if (seg->s_state == RSM_STATE_BIND) {
2994 if (seg->s_flags & RSMKA_ALLOW_UNBIND_REBIND) {
2998 if (seg->s_flags & RSMKA_SET_RESOURCE_DONTWAIT) {
3006 &seg->s_handle.out, seg->s_len,
3017 rsmseglock_release(seg);
3018 rsmexport_rm(seg);
3037 seg->s_handle.out,
3039 seg->s_segid,
3043 adapter->rsmpi_ops->rsm_seg_destroy(seg->s_handle.out);
3044 rsmseglock_release(seg);
3045 rsmexport_rm(seg);
3055 seg->s_acl_in = rsmpi_acl;
3059 seg->s_acl_len = acl_len;
3060 seg->s_acl = acl;
3062 if (seg->s_state == RSM_STATE_BIND) {
3063 seg->s_state = RSM_STATE_EXPORT;
3064 } else if (seg->s_state == RSM_STATE_BIND_QUIESCED) {
3065 seg->s_state = RSM_STATE_EXPORT_QUIESCED;
3066 cv_broadcast(&seg->s_cv);
3069 rsmseglock_release(seg);
3104 rsm_republish(rsmseg_t *seg, rsm_ioctlmsg_t *msg, int mode)
3118 if ((seg->s_state != RSM_STATE_EXPORT) &&
3119 (seg->s_state != RSM_STATE_EXPORT_QUIESCED) &&
3120 (seg->s_state != RSM_STATE_EXPORT_QUIESCING))
3123 if (seg->s_pid != ddi_get_pid() &&
3130 if (seg->s_adapter == &loopback_adapter)
3144 rsmseglock_acquire(seg);
3150 while (((seg->s_state == RSM_STATE_EXPORT) &&
3151 (seg->s_flags & RSM_REPUBLISH_WAIT)) ||
3152 (seg->s_state == RSM_STATE_EXPORT_QUIESCED) ||
3153 (seg->s_state == RSM_STATE_EXPORT_QUIESCING)) {
3154 if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
3157 rsmseglock_release(seg);
3164 if (seg->s_state != RSM_STATE_EXPORT) {
3165 rsmseglock_release(seg);
3170 key = seg->s_key;
3171 old_acl = seg->s_acl;
3172 old_acl_len = seg->s_acl_len;
3174 seg->s_acl = new_acl;
3175 seg->s_acl_len = new_acl_len;
3181 adapter = seg->s_adapter;
3188 seg->s_acl = old_acl;
3189 seg->s_acl_len = old_acl_len;
3190 rsmseglock_release(seg);
3196 rsmpi_old_acl = seg->s_acl_in;
3197 seg->s_acl_in = rsmpi_new_acl;
3199 e = adapter->rsmpi_ops->rsm_republish(seg->s_handle.out,
3200 seg->s_acl_in, seg->s_acl_len,
3204 seg->s_acl = old_acl;
3205 seg->s_acl_in = rsmpi_old_acl;
3206 seg->s_acl_len = old_acl_len;
3207 rsmseglock_release(seg);
3235 permission = seg->s_mode;
3239 seg->s_flags |= RSM_REPUBLISH_WAIT;
3241 rsmseglock_release(seg);
3246 rsmseglock_acquire(seg);
3247 seg->s_flags &= ~RSM_REPUBLISH_WAIT;
3249 cv_broadcast(&seg->s_cv);
3250 rsmseglock_release(seg);
3261 rsm_unpublish(rsmseg_t *seg, int mode)
3272 if (seg->s_pid != ddi_get_pid() &&
3279 rsmseglock_acquire(seg);
3283 * the seg state from EXPORT_QUIESCING to EXPORT_QUIESCED and
3286 while ((seg->s_state == RSM_STATE_EXPORT_QUIESCING) ||
3287 ((seg->s_state == RSM_STATE_EXPORT) && (seg->s_rdmacnt > 0))) {
3288 if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
3289 rsmseglock_release(seg);
3298 if ((seg->s_state != RSM_STATE_EXPORT) &&
3299 (seg->s_state != RSM_STATE_EXPORT_QUIESCED)) {
3300 rsmseglock_release(seg);
3302 "rsm_unpublish done: bad state %x\n", seg->s_state));
3306 rsmseglock_release(seg);
3308 rsmexport_rm(seg);
3310 rsm_send_importer_disconnects(seg->s_segid, my_nodeid);
3312 rsmseglock_acquire(seg);
3316 while ((seg->s_state == RSM_STATE_EXPORT) &&
3317 (seg->s_flags & RSM_REPUBLISH_WAIT)) {
3318 if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
3321 rsmseglock_release(seg);
3326 if ((seg->s_state != RSM_STATE_EXPORT) &&
3327 (seg->s_state != RSM_STATE_EXPORT_QUIESCED)) {
3330 rsmseglock_release(seg);
3342 acl = seg->s_acl;
3348 /* The RSMPI unpublish/destroy has been done if seg is QUIESCED */
3349 if (seg->s_state == RSM_STATE_EXPORT_QUIESCED)
3352 adapter = seg->s_adapter;
3354 if (seg->s_state != RSM_STATE_EXPORT) {
3355 rsmseglock_release(seg);
3358 seg->s_state));
3363 e = adapter->rsmpi_ops->rsm_unpublish(seg->s_handle.out);
3373 seg->s_flags |= RSM_EXPORT_WAIT;
3381 (void) cv_reltimedwait(&seg->s_cv, &seg->s_lock,
3387 seg->s_flags &= ~RSM_EXPORT_WAIT;
3392 seg->s_state = RSM_STATE_BIND;
3394 rsmseglock_release(seg);
3400 e = adapter->rsmpi_ops->rsm_seg_destroy(seg->s_handle.out);
3405 seg->s_key, e));
3409 acl = seg->s_acl;
3410 rsmpi_acl = seg->s_acl_in;
3411 acl_len = seg->s_acl_len;
3413 seg->s_acl = NULL;
3414 seg->s_acl_in = NULL;
3415 seg->s_acl_len = 0;
3417 if (seg->s_state == RSM_STATE_EXPORT) {
3418 seg->s_state = RSM_STATE_BIND;
3419 } else if (seg->s_state == RSM_STATE_EXPORT_QUIESCED) {
3420 seg->s_state = RSM_STATE_BIND_QUIESCED;
3421 cv_broadcast(&seg->s_cv);
3424 rsmseglock_release(seg);
3666 rsmseg_t *seg = (rsmseg_t *)p;
3667 if ((seg->s_segid == ex_segid) && (seg->s_node == src_nodeid)) {
3677 rsmseglock_acquire(seg);
3679 seg->s_flags |= RSM_FORCE_DISCONNECT;
3680 rsmseg_unload(seg);
4022 rsmseg_t *seg;
4032 if ((seg = msg->rsmipc_segment_cookie) != NULL) {
4043 seg = (rsmseg_t *)p;
4044 rsmseglock_acquire(seg);
4046 atomic_inc_32(&seg->s_pollevent);
4048 if (seg->s_pollflag & RSM_SEGMENT_POLL)
4049 pollwakeup(&seg->s_poll, POLLRDNORM);
4051 rsmseglock_release(seg);
4058 seg = rsmexport_lookup(msg->rsmipc_key);
4059 if (!seg) {
4061 "rsm_intr_event done: exp seg not found\n"));
4065 ASSERT(rsmseglock_held(seg));
4067 atomic_inc_32(&seg->s_pollevent);
4075 if (seg->s_pollflag & RSM_SEGMENT_POLL)
4076 pollwakeup(&seg->s_poll, POLLRDNORM);
4078 rsmseglock_release(seg);
4094 rsmseg_t *seg;
4111 seg = (rsmseg_t *)p;
4113 rsmseglock_acquire(seg);
4114 rsmsharelock_acquire(seg);
4115 seg->s_share->rsmsi_mode = perm;
4116 rsmsharelock_release(seg);
4117 rsmseglock_release(seg);
4184 rsmseg_t *seg;
4201 seg = (rsmseg_t *)current;
4202 rsmseglock_acquire(seg);
4205 adapter = seg->s_adapter;
4210 if ((seg->s_acl == NULL) ||
4211 (seg->s_acl[0].ae_node != my_nodeid) ||
4212 (seg->s_acl[0].ae_permission != 0)) {
4215 seg->s_handle.out);
4220 seg->s_handle.out);
4227 (void) rsm_unbind_pages(seg);
4228 seg->s_state = RSM_STATE_EXPORT_QUIESCED;
4229 cv_broadcast(&seg->s_cv);
4231 rsmseglock_release(seg);
4263 rsmseg_t *seg;
4293 seg = (rsmseg_t *)curp;
4295 rsmseglock_acquire(seg);
4297 if ((seg->s_node != first->s_node) ||
4298 (seg->s_key != first->s_key) ||
4299 (seg->s_state == RSM_STATE_DISCONNECT)) {
4304 rsmseglock_release(seg);
4308 rsmseg_suspend(seg, &susp_flg);
4310 if (susp_flg) { /* seg already suspended */
4311 rsmseglock_release(seg);
4316 rsmsharelock_acquire(seg);
4322 seg->s_share->rsmsi_refcnt) {
4323 rsmsharelock_release(seg);
4324 rsmseglock_release(seg);
4327 rsmsharelock_release(seg);
4328 rsmseglock_release(seg);
4338 rsmsegshare_suspend(seg);
4355 rsmseg_suspend(rsmseg_t *seg, int *susp_flg)
4363 "rsmseg_suspend enter: key=%u\n", seg->s_key));
4367 ASSERT(rsmseglock_held(seg));
4369 while (seg->s_rdmacnt > 0)
4370 cv_wait(&seg->s_cv, &seg->s_lock);
4377 seg->s_key, seg->s_state));
4379 switch (seg->s_state) {
4384 seg->s_state = RSM_STATE_ABORT_CONNECT;
4389 seg->s_handle.in = NULL;
4390 seg->s_state = RSM_STATE_CONN_QUIESCE;
4394 while (seg->s_state == RSM_STATE_MAPPING)
4395 cv_wait(&seg->s_cv, &seg->s_lock);
4400 if (seg->s_ckl != NULL) {
4401 hdl = seg->s_ckl;
4407 seg->s_mapinfo = NULL;
4408 seg->s_state = RSM_STATE_MAP_QUIESCE;
4413 /* rsmseg_suspend already done for seg */
4427 rsmsegshare_suspend(rsmseg_t *seg)
4438 rsmseglock_acquire(seg);
4439 rsmsharelock_acquire(seg);
4441 sharedp = seg->s_share;
4442 adapter = seg->s_adapter;
4458 "rsm:rsmpi disconnect seg=%x:err=%d\n",
4471 e = adapter->rsmpi_ops->rsm_unmap(seg->s_handle.in);
4479 "rsm:rsmpi disconnect seg=%x:err=%d\n",
4495 rsmsharelock_release(seg);
4496 rsmseglock_release(seg);
4524 rsmseg_t *seg = (rsmseg_t *)p;
4526 rsmseglock_acquire(seg);
4529 if (seg->s_node != src_node) {
4530 rsmseglock_release(seg);
4534 if (rsmseg_resume(seg, &cookie) != RSM_SUCCESS) {
4543 request.rsmipc_key = seg->s_segid;
4545 rsmseglock_release(seg);
4546 (void) rsmipc_send(seg->s_node, &request,
4549 rsmseglock_release(seg);
4560 rsmseg_resume(rsmseg_t *seg, void **cookie)
4574 "rsmseg_resume enter: key=%u\n", seg->s_key));
4578 ASSERT(rsmseglock_held(seg));
4580 if ((seg->s_state != RSM_STATE_CONN_QUIESCE) &&
4581 (seg->s_state != RSM_STATE_MAP_QUIESCE)) {
4585 sharedp = seg->s_share;
4587 rsmsharelock_acquire(seg);
4590 retc = rsmsegshare_resume(seg);
4592 if (seg->s_state == RSM_STATE_CONN_QUIESCE) {
4597 seg->s_handle.in = sharedp->rsmsi_handle;
4598 rsmsharelock_release(seg);
4599 seg->s_state = RSM_STATE_CONNECT;
4602 seg->s_handle.in = NULL;
4603 seg->s_state = RSM_STATE_DISCONNECT;
4610 rsmsharelock_release(seg);
4619 rsmsharelock_release(seg);
4623 * rsmsharelock calls which use seg->s_share.
4625 seg->s_share = NULL;
4629 cv_broadcast(&seg->s_cv);
4632 "rsmseg_resume done:state=%d\n", seg->s_state));
4636 ASSERT(seg->s_state == RSM_STATE_MAP_QUIESCE);
4640 if (seg->s_mode & RSM_PERM_READ) {
4643 if (seg->s_mode & RSM_PERM_WRITE) {
4651 ASSERT(seg->s_ckl != NULL);
4653 for (hdl = seg->s_ckl; hdl != NULL; hdl = hdl->c_next) {
4662 seg->s_handle.in = NULL;
4663 seg->s_state = RSM_STATE_DISCONNECT;
4668 seg->s_mapinfo = NULL;
4672 rsmsharelock_release(seg);
4681 rsmsharelock_release(seg);
4685 * rsmsharelock calls which use seg->s_share.
4687 seg->s_share = NULL;
4690 cv_broadcast(&seg->s_cv);
4693 "rsmseg_resume done:seg=%x,err=%d\n",
4694 seg->s_key, retc));
4699 seg->s_handle.in = sharedp->rsmsi_handle;
4701 if (seg->s_node == my_nodeid) { /* loopback */
4702 ASSERT(seg->s_mapinfo == NULL);
4704 for (hdl = seg->s_ckl; hdl != NULL; hdl = hdl->c_next) {
4706 rsm_dip, seg->s_cookie,
4715 seg->s_mapinfo = sharedp->rsmsi_mapinfo;
4717 for (hdl = seg->s_ckl; hdl != NULL; hdl = hdl->c_next) {
4718 p = rsm_get_mapinfo(seg, hdl->c_off, hdl->c_len,
4729 rsmsharelock_release(seg);
4731 seg->s_state = RSM_STATE_ACTIVE;
4732 cv_broadcast(&seg->s_cv);
4740 rsmsegshare_resume(rsmseg_t *seg)
4750 ASSERT(rsmseglock_held(seg));
4751 ASSERT(rsmsharelock_held(seg));
4753 sharedp = seg->s_share;
4765 adapter = seg->s_adapter;
4776 "rsmsegshare_resume:rsmpi connect seg=%x:err=%d\n",
4847 (void) seg->s_adapter->rsmpi_ops->
4858 "rsmsegshare_resume:disconn seg=%x:err=%d\n",
6086 rsm_connect(rsmseg_t *seg, rsm_ioctlmsg_t *msg, cred_t *cred,
6117 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
6118 ASSERT(seg->s_state == RSM_STATE_NEW);
6135 seg->s_node = msg->nodeid;
6141 e = rsmimport_add(seg, msg->key);
6148 seg->s_state = RSM_STATE_CONNECTING;
6155 seg->s_adapter = adapter;
6157 rsmseglock_release(seg);
6163 sharedp = rsmshare_get(msg->key, msg->nodeid, adapter, seg);
6165 ASSERT(rsmsharelock_held(seg));
6191 rsmsharelock_release(seg);
6192 rsmimport_rm(seg);
6193 seg->s_adapter = NULL;
6195 seg->s_state = RSM_STATE_NEW;
6226 rsmsharelock_release(seg);
6232 rsmsharelock_acquire(seg);
6233 rsmsharecv_signal(seg, RSMSI_STATE_CONNECTING,
6235 rsmsharelock_release(seg);
6236 rsmimport_rm(seg);
6237 seg->s_adapter = NULL;
6239 seg->s_state = RSM_STATE_NEW;
6264 rsmsharelock_acquire(seg);
6265 rsmsharecv_signal(seg, RSMSI_STATE_CONNECTING,
6267 rsmsharelock_release(seg);
6268 rsmimport_rm(seg);
6269 seg->s_adapter = NULL;
6271 seg->s_state = RSM_STATE_NEW;
6278 rsmsharelock_acquire(seg);
6279 rsmsharecv_signal(seg, RSMSI_STATE_CONNECTING,
6281 rsmsharelock_release(seg);
6282 rsmimport_rm(seg);
6283 seg->s_adapter = NULL;
6285 seg->s_state = RSM_STATE_NEW;
6292 rsmsharelock_acquire(seg);
6301 rsmsharelock_release(seg);
6310 rsmseglock_acquire(seg);
6311 rsmsharelock_acquire(seg);
6312 ASSERT(seg->s_state == RSM_STATE_CONNECTING ||
6313 seg->s_state == RSM_STATE_ABORT_CONNECT);
6317 if ((seg->s_state == RSM_STATE_ABORT_CONNECT) ||
6319 seg->s_state = RSM_STATE_NEW;
6320 seg->s_adapter = NULL;
6321 rsmsharelock_release(seg);
6322 rsmseglock_release(seg);
6323 rsmimport_rm(seg);
6326 rsmsharelock_acquire(seg);
6333 rsmsharelock_release(seg);
6337 rsmsharelock_acquire(seg);
6344 rsmsharelock_release(seg);
6359 rsmsharelock_release(seg);
6360 seg->s_state = RSM_STATE_NEW;
6361 seg->s_adapter = NULL;
6362 rsmseglock_release(seg);
6363 rsmimport_rm(seg);
6369 rsmsharelock_acquire(seg);
6371 rsmsharelock_release(seg);
6376 rsmsharelock_acquire(seg);
6380 rsmsharelock_release(seg);
6388 seg->s_segid = sharedp->rsmsi_segid;
6389 seg->s_len = sharedp->rsmsi_seglen;
6390 seg->s_mode = access & sharedp->rsmsi_mode;
6391 seg->s_pid = ddi_get_pid();
6392 seg->s_mapinfo = NULL;
6394 if (seg->s_node != my_nodeid) {
6398 addr, seg->s_segid, &sharedp->rsmsi_handle);
6401 seg->s_state = RSM_STATE_NEW;
6402 seg->s_adapter = NULL;
6403 rsmsharelock_release(seg);
6404 rsmseglock_release(seg);
6405 rsmimport_rm(seg);
6424 rsmsharelock_acquire(seg);
6427 rsmsharelock_release(seg);
6442 seg->s_handle.in = sharedp->rsmsi_handle;
6446 seg->s_state = RSM_STATE_CONNECT;
6449 seg->s_flags &= ~RSM_IMPORT_DUMMY; /* clear dummy flag */
6452 atomic_inc_16(bar_va + seg->s_hdr.rsmrc_num);
6454 msg->off = (int)seg->s_hdr.rsmrc_num;
6462 msg->rnum = seg->s_minor;
6463 rsmsharecv_signal(seg, RSMSI_STATE_CONNECTING, RSMSI_STATE_CONNECTED);
6464 rsmsharelock_release(seg);
6465 rsmseglock_release(seg);
6502 rsm_unmap(rsmseg_t *seg)
6510 "rsm_unmap enter %u\n", seg->s_segid));
6512 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
6514 /* assert seg is locked */
6515 ASSERT(rsmseglock_held(seg));
6516 ASSERT(seg->s_state != RSM_STATE_MAPPING);
6518 if ((seg->s_state != RSM_STATE_ACTIVE) &&
6519 (seg->s_state != RSM_STATE_MAP_QUIESCE)) {
6525 sharedp = seg->s_share;
6527 rsmsharelock_acquire(seg);
6550 adapter = seg->s_adapter;
6551 if (seg->s_node != my_nodeid) {
6566 rsmsharelock_release(seg);
6581 seg->s_cookie = NULL;
6583 seg->s_mapinfo = NULL;
6585 if (seg->s_state == RSM_STATE_ACTIVE)
6586 seg->s_state = RSM_STATE_CONNECT;
6588 seg->s_state = RSM_STATE_CONN_QUIESCE;
6601 rsm_closeconnection(rsmseg_t *seg, void **cookie)
6613 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
6615 /* assert seg is locked */
6616 ASSERT(rsmseglock_held(seg));
6618 if (seg->s_state == RSM_STATE_DISCONNECT) {
6625 while (seg->s_rdmacnt > 0) {
6626 cv_wait(&seg->s_cv, &seg->s_lock);
6629 (void) rsm_unmap(seg);
6631 ASSERT(seg->s_state == RSM_STATE_CONNECT ||
6632 seg->s_state == RSM_STATE_CONN_QUIESCE);
6634 adapter = seg->s_adapter;
6635 sharedp = seg->s_share;
6639 rsmsharelock_acquire(seg);
6661 "rsm:disconnect failed seg=%x:err=%d\n",
6662 seg->s_key, e));
6667 seg->s_handle.in = NULL;
6675 rsmsharelock_release(seg);
6683 rsmsharelock_release(seg);
6688 atomic_inc_16(bar_va + seg->s_hdr.rsmrc_num);
6693 * rsmsharelock calls which use seg->s_share.
6695 seg->s_share = NULL;
6697 seg->s_state = RSM_STATE_DISCONNECT;
6699 cv_broadcast(&seg->s_cv);
6708 rsm_disconnect(rsmseg_t *seg)
6716 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
6718 /* assert seg isn't locked */
6719 ASSERT(!rsmseglock_held(seg));
6723 rsmimport_rm(seg);
6726 rsmseglock_acquire(seg);
6729 while (seg->s_state == RSM_STATE_MAPPING)
6730 cv_wait(&seg->s_cv, &seg->s_lock);
6732 if (seg->s_state == RSM_STATE_DISCONNECT) {
6733 seg->s_state = RSM_STATE_NEW;
6734 rsmseglock_release(seg);
6740 (void) rsm_closeconnection(seg, &shared_cookie);
6743 seg->s_state = RSM_STATE_NEW;
6751 request.rsmipc_key = seg->s_segid;
6753 rsmseglock_release(seg);
6754 (void) rsmipc_send(seg->s_node, &request, RSM_NO_REPLY);
6756 rsmseglock_release(seg);
6771 rsmseg_t *seg;
6792 seg = (rsmseg_t *)res;
6794 if (seg->s_pollevent) {
6798 *phpp = &seg->s_poll;
6799 seg->s_pollflag |= RSM_SEGMENT_POLL;
6814 rsmseg_t *seg;
6821 seg = (rsmseg_t *)res;
6824 seg = rsmseg_alloc(rnum, credp);
6838 seg->s_state = RSM_STATE_NEW_QUIESCED;
6843 rsmresource_insert(rnum, (rsmresource_t *)seg, type);
6848 return (seg);
6852 rsmexport_ioctl(rsmseg_t *seg, rsm_ioctlmsg_t *msg, int cmd, intptr_t arg,
6863 ASSERT(seg != NULL);
6867 error = rsm_bind(seg, msg, arg, mode);
6870 error = rsm_rebind(seg, msg);
6876 error = rsm_publish(seg, msg, arg, mode);
6879 error = rsm_republish(seg, msg, mode);
6882 error = rsm_unpublish(seg, 1);
6895 rsmimport_ioctl(rsmseg_t *seg, rsm_ioctlmsg_t *msg, int cmd, intptr_t arg,
6903 ASSERT(seg);
6907 error = rsm_connect(seg, msg, credp, arg, mode);
6920 rsmbar_ioctl(rsmseg_t *seg, rsm_ioctlmsg_t *msg, int cmd, intptr_t arg,
6930 if ((seg->s_flags & RSM_IMPORT_DUMMY) != 0) {
6934 } else if (seg->s_node == my_nodeid) {
6940 adapter = seg->s_adapter;
7001 exportbell_ioctl(rsmseg_t *seg, int cmd /*ARGSUSED*/)
7010 request.rsmipc_key = seg->s_segid;
7013 e = rsmipc_send(seg->s_node, &request, RSM_NO_REPLY);
7025 importbell_ioctl(rsmseg_t *seg, int cmd /*ARGSUSED*/)
7035 ASSERT(seg->s_state != RSM_STATE_NEW &&
7036 seg->s_state != RSM_STATE_NEW_QUIESCED);
7038 request.rsmipc_key = seg->s_segid;
7041 index = rsmhash(seg->s_segid);
7046 if (seg->s_key == token->key) {
7264 rsmseg_t *seg;
7280 seg = (rsmseg_t *)rsmresource_lookup(rnum, RSM_LOCK);
7281 if (seg) {
7283 "consumeevent_ioctl: rnum(%d) seg(%p)\n", rnum,
7284 seg));
7285 if (seg->s_pollevent) {
7287 atomic_dec_32(&seg->s_pollevent);
7290 rsmseglock_release(seg);
7962 rsmseg_t *seg;
8096 seg = rsmresource_seg(res, rnum, credp,
8098 if (seg->s_type == RSM_RESOURCE_EXPORT_SEGMENT) {
8099 error = rsmexport_ioctl(seg, &msg, cmd, arg, mode,
8107 seg = rsmresource_seg(res, rnum, credp,
8109 if (seg->s_type == RSM_RESOURCE_IMPORT_SEGMENT) {
8110 error = rsmimport_ioctl(seg, &msg, cmd, arg, mode,
8149 rsm_get_mapinfo(rsmseg_t *seg, off_t off, size_t len, off_t *dev_offset,
8155 * from the seg->s_mapinfo list.
8156 * The seg->s_mapinfo list contains in reverse order the mappings
8167 p = seg->s_mapinfo;
8199 rsmseg_t *seg;
8214 seg = (rsmseg_t *)res;
8216 rsmseglock_acquire(seg);
8218 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
8228 p->c_next = seg->s_ckl;
8229 seg->s_ckl = p;
8231 *pvtp = (void *)seg;
8233 rsmseglock_release(seg);
8249 rsmseg_t *seg = (rsmseg_t *)pvt;
8254 rsmseglock_acquire(seg);
8256 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
8258 while (seg->s_state == RSM_STATE_MAP_QUIESCE) {
8259 if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
8262 rsmseglock_release(seg);
8267 ASSERT(seg->s_state == RSM_STATE_DISCONNECT ||
8268 seg->s_state == RSM_STATE_ACTIVE);
8270 if (seg->s_state == RSM_STATE_DISCONNECT)
8271 seg->s_flags |= RSM_IMPORT_DUMMY;
8276 rsmseglock_release(seg);
8292 rsmseg_t *seg = (rsmseg_t *)oldpvt;
8303 rsmseglock_acquire(seg);
8305 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
8310 for (old = seg->s_ckl; old != NULL; old = old->c_next) {
8318 rsmseglock_release(seg);
8327 p->c_next = seg->s_ckl;
8328 seg->s_ckl = p;
8330 *newpvt = (void *)seg;
8332 rsmseglock_release(seg);
8347 rsmseg_t *seg = (rsmseg_t *)pvtp;
8357 rsmseglock_acquire(seg);
8359 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
8371 rsmcookie_t *tmp, **back = &seg->s_ckl;
8394 if ((seg->s_ckl == NULL) && (seg->s_state != RSM_STATE_MAPPING))
8395 (void) rsm_unmap(seg);
8397 if (seg->s_state == RSM_STATE_END && seg->s_ckl == NULL) {
8403 rsmseglock_release(seg);
8407 rsmseg_free(seg);
8429 rsmseg_t *seg;
8439 seg = (rsmseg_t *)rsmresource_lookup(rnum, RSM_NOLOCK);
8440 ASSERT(seg != NULL);
8442 if (seg->s_hdr.rsmrc_type == RSM_RESOURCE_BAR) {
8475 ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
8476 ASSERT(seg->s_state == RSM_STATE_MAPPING);
8482 if (seg->s_mode & RSM_PERM_READ) {
8486 if (seg->s_mode & RSM_PERM_WRITE) {
8501 if (seg->s_node != my_nodeid) {
8504 p = rsm_get_mapinfo(seg, off, len, &dev_offset, &cur_len);
8533 seg->s_cookie, off, len, maxprot,
8563 rsmseg_t *seg, *eseg;
8574 seg = (rsmseg_t *)rsmresource_lookup(rnum, RSM_LOCK);
8576 if (seg == NULL) {
8587 if (seg->s_hdr.rsmrc_type == RSM_RESOURCE_BAR) {
8588 rsmseglock_release(seg);
8617 if (seg->s_hdr.rsmrc_type != RSM_RESOURCE_IMPORT_SEGMENT) {
8618 rsmseglock_release(seg);
8624 ASSERT(seg->s_hdr.rsmrc_num == rnum);
8627 while (seg->s_state == RSM_STATE_CONN_QUIESCE) {
8628 if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
8629 rsmseglock_release(seg);
8637 while (seg->s_state == RSM_STATE_MAPPING)
8638 cv_wait(&seg->s_cv, &seg->s_lock);
8646 if ((seg->s_state != RSM_STATE_CONNECT) &&
8647 (seg->s_state != RSM_STATE_ACTIVE)) {
8648 rsmseglock_release(seg);
8658 if ((size_t)off + ptob(btopr(len)) > seg->s_len) {
8659 rsmseglock_release(seg);
8661 "rsm_segmap done: off+len>seg size\n"));
8669 if (seg->s_mode & RSM_PERM_READ) {
8673 if (seg->s_mode & RSM_PERM_WRITE) {
8679 rsmseglock_release(seg);
8685 old_state = seg->s_state;
8687 ASSERT(seg->s_share != NULL);
8689 rsmsharelock_acquire(seg);
8691 sharedp = seg->s_share;
8698 rsmsharelock_release(seg);
8699 rsmseglock_release(seg);
8710 if (seg->s_node != my_nodeid) {
8716 size_t length_to_map = seg->s_len;
8721 * length_to_map = seg->s_len is always an integral
8726 adapter = seg->s_adapter;
8733 while (total_length_mapped < seg->s_len) {
8737 seg->s_handle.in, tmp_off,
8761 seg->s_mapinfo = sharedp->rsmsi_mapinfo;
8770 (void) seg->s_adapter->rsmpi_ops->
8777 rsmsharelock_release(seg);
8778 rsmseglock_release(seg);
8797 seg->s_mapinfo = sharedp->rsmsi_mapinfo;
8802 rsmsharelock_release(seg);
8805 seg->s_state = RSM_STATE_MAPPING;
8806 rsmseglock_release(seg);
8811 rsmseglock_acquire(seg);
8812 ASSERT(seg->s_state == RSM_STATE_MAPPING);
8815 seg->s_state = RSM_STATE_ACTIVE;
8817 rsmsharelock_acquire(seg);
8832 rsmsharelock_release(seg);
8833 seg->s_state = old_state;
8837 cv_broadcast(&seg->s_cv);
8838 rsmseglock_release(seg);
8860 rsmsharelock_release(seg);
8881 seg->s_state = RSM_STATE_MAPPING;
8882 rsmseglock_release(seg);
8884 eseg = rsmexport_lookup(seg->s_key);
8887 rsmseglock_acquire(seg);
8893 seg->s_state = old_state;
8894 cv_broadcast(&seg->s_cv);
8895 rsmseglock_release(seg);
8897 "rsm_segmap done: key %d not found\n", seg->s_key));
8901 rsmsharelock_acquire(seg);
8907 rsmsharelock_release(seg);
8917 seg->s_cookie = eseg->s_cookie;
8924 rsmseglock_acquire(seg);
8925 ASSERT(seg->s_state == RSM_STATE_MAPPING);
8927 seg->s_state = RSM_STATE_ACTIVE;
8929 rsmsharelock_acquire(seg);
8938 rsmsharelock_release(seg);
8939 seg->s_state = old_state;
8940 seg->s_cookie = NULL;
8942 cv_broadcast(&seg->s_cv);
8943 rsmseglock_release(seg);