5045 use atomic_{inc,dec}_* instead of atomic_add_*

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 
  25 #include <sys/conf.h>
  26 #include <sys/file.h>
  27 #include <sys/ddi.h>
  28 #include <sys/sunddi.h>
  29 #include <sys/modctl.h>
  30 #include <sys/scsi/scsi.h>
  31 #include <sys/scsi/impl/scsi_reset_notify.h>
  32 #include <sys/disp.h>
  33 #include <sys/byteorder.h>
  34 #include <sys/atomic.h>
  35 
  36 #include <sys/stmf.h>
  37 #include <sys/lpif.h>
  38 #include <sys/portif.h>
  39 #include <sys/stmf_ioctl.h>
  40 
  41 #include "stmf_impl.h"
  42 #include "lun_map.h"
  43 #include "stmf_state.h"
  44 
  45 void stmf_update_sessions_per_ve(stmf_view_entry_t *ve,
  46                 stmf_lu_t *lu, int action);
  47 void stmf_add_lus_to_session_per_vemap(stmf_i_local_port_t *ilport,
  48                 stmf_i_scsi_session_t *iss, stmf_lun_map_t *vemap);
  49 stmf_id_data_t *stmf_lookup_group_for_host(uint8_t *ident, uint16_t ident_size);
  50 stmf_status_t stmf_add_ent_to_map(stmf_lun_map_t *sm, void *ent, uint8_t *lun);
  51 stmf_status_t stmf_remove_ent_from_map(stmf_lun_map_t *sm, uint8_t *lun);
  52 uint16_t stmf_get_next_free_lun(stmf_lun_map_t *sm, uint8_t *lun);
  53 stmf_status_t stmf_add_tg(uint8_t *tg_name, uint16_t tg_name_size,
  54                 int allow_special, uint32_t *err_detail);
  55 stmf_status_t stmf_add_hg(uint8_t *hg_name, uint16_t hg_name_size,
  56                 int allow_special, uint32_t *err_detail);
  57 stmf_i_local_port_t *stmf_targetident_to_ilport(uint8_t *target_ident,
  58                 uint16_t ident_size);
  59 stmf_i_scsi_session_t *stmf_lookup_session_for_hostident(
  60                 stmf_i_local_port_t *ilport, uint8_t *host_ident,
  61                 uint16_t ident_size);
  62 stmf_i_lu_t *stmf_luident_to_ilu(uint8_t *lu_ident);
  63 stmf_lun_map_t *stmf_get_ve_map_per_ids(stmf_id_data_t *tgid,
  64                 stmf_id_data_t *hgid);
  65 stmf_lun_map_t *stmf_duplicate_ve_map(stmf_lun_map_t *src);
  66 int stmf_merge_ve_map(stmf_lun_map_t *src, stmf_lun_map_t *dst,
  67                 stmf_lun_map_t **pp_ret_map, stmf_merge_flags_t mf);
  68 void stmf_destroy_ve_map(stmf_lun_map_t *dst);
  69 void stmf_free_id(stmf_id_data_t *id);
  70 
  71 
  72 /*
  73  * Init the view
  74  */
  75 void
  76 stmf_view_init()
  77 {
  78         uint8_t grpname_forall = '*';
  79         (void) stmf_add_hg(&grpname_forall, 1, 1, NULL);
  80         (void) stmf_add_tg(&grpname_forall, 1, 1, NULL);
  81 }
  82 
  83 /*
  84  * Clear config database here
  85  */
  86 void
  87 stmf_view_clear_config()
  88 {
  89         stmf_id_data_t *idgrp, *idgrp_next, *idmemb, *idmemb_next;
  90         stmf_ver_tg_t *vtg, *vtg_next;
  91         stmf_ver_hg_t *vhg, *vhg_next;
  92         stmf_view_entry_t *ve, *ve_next;
  93         stmf_i_lu_t     *ilu;
  94         stmf_id_list_t  *idlist;
  95         stmf_i_local_port_t *ilport;
  96 
  97         for (vtg = stmf_state.stmf_ver_tg_head; vtg; vtg = vtg_next) {
  98                 for (vhg = vtg->vert_verh_list; vhg; vhg = vhg_next) {
  99                         if (vhg->verh_ve_map.lm_nentries) {
 100                                 kmem_free(vhg->verh_ve_map.lm_plus,
 101                                     vhg->verh_ve_map.lm_nentries *
 102                                     sizeof (void *));
 103                         }
 104                         vhg_next = vhg->verh_next;
 105                         kmem_free(vhg, sizeof (stmf_ver_hg_t));
 106                 }
 107                 vtg_next = vtg->vert_next;
 108                 kmem_free(vtg, sizeof (stmf_ver_tg_t));
 109         }
 110         stmf_state.stmf_ver_tg_head = NULL;
 111 
 112         if (stmf_state.stmf_luid_list.id_count) {
 113                 /* clear the views for lus */
 114                 for (idmemb = stmf_state.stmf_luid_list.idl_head;
 115                     idmemb; idmemb = idmemb_next) {
 116                         for (ve = (stmf_view_entry_t *)idmemb->id_impl_specific;
 117                             ve; ve = ve_next) {
 118                                 ve_next = ve->ve_next;
 119                                 ve->ve_hg->id_refcnt--;
 120                                 ve->ve_tg->id_refcnt--;
 121                                 kmem_free(ve, sizeof (stmf_view_entry_t));
 122                         }
 123                         if (idmemb->id_pt_to_object) {
 124                                 ilu = (stmf_i_lu_t *)(idmemb->id_pt_to_object);
 125                                 ilu->ilu_luid = NULL;
 126                         }
 127                         idmemb_next = idmemb->id_next;
 128                         stmf_free_id(idmemb);
 129                 }
 130                 stmf_state.stmf_luid_list.id_count = 0;
 131                 stmf_state.stmf_luid_list.idl_head =
 132                     stmf_state.stmf_luid_list.idl_tail = NULL;
 133         }
 134 
 135         if (stmf_state.stmf_hg_list.id_count) {
 136                 /* free all the host group */
 137                 for (idgrp = stmf_state.stmf_hg_list.idl_head;
 138                     idgrp; idgrp = idgrp_next) {
 139                         idlist = (stmf_id_list_t *)(idgrp->id_impl_specific);
 140                         if (idlist->id_count) {
 141                                 for (idmemb = idlist->idl_head; idmemb;
 142                                     idmemb = idmemb_next) {
 143                                         idmemb_next = idmemb->id_next;
 144                                         stmf_free_id(idmemb);
 145                                 }
 146                         }
 147                         idgrp_next = idgrp->id_next;
 148                         stmf_free_id(idgrp);
 149                 }
 150                 stmf_state.stmf_hg_list.id_count = 0;
 151                 stmf_state.stmf_hg_list.idl_head =
 152                     stmf_state.stmf_hg_list.idl_tail = NULL;
 153         }
 154         if (stmf_state.stmf_tg_list.id_count) {
 155                 /* free all the target group */
 156                 for (idgrp = stmf_state.stmf_tg_list.idl_head;
 157                     idgrp; idgrp = idgrp_next) {
 158                         idlist = (stmf_id_list_t *)(idgrp->id_impl_specific);
 159                         if (idlist->id_count) {
 160                                 for (idmemb = idlist->idl_head; idmemb;
 161                                     idmemb = idmemb_next) {
 162                                         idmemb_next = idmemb->id_next;
 163                                         stmf_free_id(idmemb);
 164                                 }
 165                         }
 166                         idgrp_next = idgrp->id_next;
 167                         stmf_free_id(idgrp);
 168                 }
 169                 stmf_state.stmf_tg_list.id_count = 0;
 170                 stmf_state.stmf_tg_list.idl_head =
 171                     stmf_state.stmf_tg_list.idl_tail = NULL;
 172         }
 173 
 174         for (ilport = stmf_state.stmf_ilportlist; ilport;
 175             ilport = ilport->ilport_next) {
 176                 ilport->ilport_tg = NULL;
 177         }
 178 }
 179 
 180 /*
 181  * Create luns map for session based on the view
 182  */
 183 stmf_status_t
 184 stmf_session_create_lun_map(stmf_i_local_port_t *ilport,
 185                 stmf_i_scsi_session_t *iss)
 186 {
 187         stmf_id_data_t *tg;
 188         stmf_id_data_t *hg;
 189         stmf_ver_tg_t   *vertg;
 190         char *phg_data, *ptg_data;
 191         stmf_ver_hg_t   *verhg;
 192         stmf_lun_map_t  *ve_map;
 193 
 194         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 195 
 196         tg = ilport->ilport_tg;
 197         hg = stmf_lookup_group_for_host(iss->iss_ss->ss_rport_id->ident,
 198             iss->iss_ss->ss_rport_id->ident_length);
 199         iss->iss_hg = hg;
 200 
 201         /*
 202          * get the view entry map,
 203          * take all host/target group into consideration
 204          */
 205         ve_map = stmf_duplicate_ve_map(0);
 206         for (vertg = stmf_state.stmf_ver_tg_head; vertg != NULL;
 207             vertg = vertg->vert_next) {
 208                 ptg_data = (char *)vertg->vert_tg_ref->id_data;
 209                 if ((ptg_data[0] != '*') && (!tg ||
 210                     ((tg->id_data[0] != '*') &&
 211                     (vertg->vert_tg_ref != tg)))) {
 212                         continue;
 213                 }
 214                 for (verhg = vertg->vert_verh_list; verhg != NULL;
 215                     verhg = verhg->verh_next) {
 216                         phg_data = (char *)verhg->verh_hg_ref->id_data;
 217                         if ((phg_data[0] != '*') && (!hg ||
 218                             ((hg->id_data[0] != '*') &&
 219                             (verhg->verh_hg_ref != hg)))) {
 220                                 continue;
 221                         }
 222                         (void) stmf_merge_ve_map(&verhg->verh_ve_map, ve_map,
 223                             &ve_map, 0);
 224                 }
 225         }
 226 
 227 
 228         if (ve_map->lm_nluns) {
 229                 stmf_add_lus_to_session_per_vemap(ilport, iss, ve_map);
 230         }
 231         /* not configured, cannot access any luns for now */
 232 
 233         stmf_destroy_ve_map(ve_map);
 234 
 235         return (STMF_SUCCESS);
 236 }
 237 
 238 /*
 239  * destroy lun map for session
 240  */
 241 /* ARGSUSED */
 242 stmf_status_t
 243 stmf_session_destroy_lun_map(stmf_i_local_port_t *ilport,
 244                 stmf_i_scsi_session_t *iss)
 245 {
 246         stmf_lun_map_t *sm;
 247         stmf_i_lu_t *ilu;
 248         uint16_t n;
 249         stmf_lun_map_ent_t *ent;
 250 
 251         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 252         /*
 253          * to avoid conflict with updating session's map,
 254          * which only grab stmf_lock
 255          */
 256         sm = iss->iss_sm;
 257         iss->iss_sm = NULL;
 258         iss->iss_hg = NULL;
 259         if (sm->lm_nentries) {
 260                 for (n = 0; n < sm->lm_nentries; n++) {
 261                         if ((ent = (stmf_lun_map_ent_t *)sm->lm_plus[n])
 262                             != NULL) {
 263                                 if (ent->ent_itl_datap) {
 264                                         stmf_do_itl_dereg(ent->ent_lu,
 265                                             ent->ent_itl_datap,
 266                                             STMF_ITL_REASON_IT_NEXUS_LOSS);
 267                                 }
 268                                 ilu = (stmf_i_lu_t *)
 269                                     ent->ent_lu->lu_stmf_private;
 270                                 atomic_dec_32(&ilu->ilu_ref_cnt);
 271                                 kmem_free(sm->lm_plus[n],
 272                                     sizeof (stmf_lun_map_ent_t));
 273                         }
 274                 }
 275                 kmem_free(sm->lm_plus,
 276                     sizeof (stmf_lun_map_ent_t *) * sm->lm_nentries);
 277         }
 278 
 279         kmem_free(sm, sizeof (*sm));
 280         return (STMF_SUCCESS);
 281 }
 282 
 283 /*
 284  * Expects the session lock to be held.
 285  */
 286 stmf_xfer_data_t *
 287 stmf_session_prepare_report_lun_data(stmf_lun_map_t *sm)
 288 {
 289         stmf_xfer_data_t *xd;
 290         uint16_t nluns, ent;
 291         uint32_t alloc_size, data_size;
 292         int i;
 293 
 294         nluns = sm->lm_nluns;
 295 
 296         data_size = 8 + (((uint32_t)nluns) << 3);
 297         if (nluns == 0) {
 298                 data_size += 8;
 299         }
 300         alloc_size = data_size + sizeof (stmf_xfer_data_t) - 4;
 301 
 302         xd = (stmf_xfer_data_t *)kmem_zalloc(alloc_size, KM_NOSLEEP);
 303 
 304         if (xd == NULL)
 305                 return (NULL);
 306 
 307         xd->alloc_size = alloc_size;
 308         xd->size_left = data_size;
 309 
 310         *((uint32_t *)xd->buf) = BE_32(data_size - 8);
 311         if (nluns == 0) {
 312                 return (xd);
 313         }
 314 
 315         ent = 0;
 316 
 317         for (i = 0; ((i < sm->lm_nentries) && (ent < nluns)); i++) {
 318                 if (sm->lm_plus[i] == NULL)
 319                         continue;
 320                 /* Fill in the entry */
 321                 xd->buf[8 + (ent << 3) + 1] = (uchar_t)i;
 322                 xd->buf[8 + (ent << 3) + 0] = ((uchar_t)(i >> 8));
 323                 ent++;
 324         }
 325 
 326         ASSERT(ent == nluns);
 327 
 328         return (xd);
 329 }
 330 
 331 /*
 332  * Add a lu to active sessions based on LUN inventory.
 333  * Only invoked when the lu is onlined
 334  */
 335 void
 336 stmf_add_lu_to_active_sessions(stmf_lu_t *lu)
 337 {
 338         stmf_id_data_t *luid;
 339         stmf_view_entry_t       *ve;
 340         stmf_i_lu_t *ilu;
 341 
 342         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 343         ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
 344         ASSERT(ilu->ilu_state == STMF_STATE_ONLINE);
 345 
 346         luid = ((stmf_i_lu_t *)lu->lu_stmf_private)->ilu_luid;
 347 
 348         if (!luid) {
 349                 /* we did not configure view for this lun, so just return */
 350                 return;
 351         }
 352 
 353         for (ve = (stmf_view_entry_t *)luid->id_impl_specific;
 354             ve; ve = ve->ve_next) {
 355                 stmf_update_sessions_per_ve(ve, lu, 1);
 356         }
 357 }
 358 /*
 359  * Unmap a lun from all sessions
 360  */
 361 void
 362 stmf_session_lu_unmapall(stmf_lu_t *lu)
 363 {
 364         stmf_i_lu_t *ilu;
 365         stmf_id_data_t *luid;
 366         stmf_view_entry_t *ve;
 367 
 368         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 369 
 370         ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
 371 
 372         if (ilu->ilu_ref_cnt == 0)
 373                 return;
 374 
 375         luid = ((stmf_i_lu_t *)lu->lu_stmf_private)->ilu_luid;
 376         if (!luid) {
 377                 /*
 378                  * we did not configure view for this lun, this should be
 379                  * an error
 380                  */
 381                 return;
 382         }
 383 
 384         for (ve = (stmf_view_entry_t *)luid->id_impl_specific;
 385             ve; ve = ve->ve_next) {
 386                 stmf_update_sessions_per_ve(ve, lu, 0);
 387                 if (ilu->ilu_ref_cnt == 0)
 388                         break;
 389         }
 390 }
 391 /*
 392  * add lu to a session, stmf_lock is already held
 393  */
 394 stmf_status_t
 395 stmf_add_lu_to_session(stmf_i_local_port_t *ilport,
 396                 stmf_i_scsi_session_t   *iss,
 397                 stmf_lu_t *lu,
 398                 uint8_t *lu_nbr)
 399 {
 400         stmf_lun_map_t *sm = iss->iss_sm;
 401         stmf_status_t ret;
 402         stmf_i_lu_t *ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
 403         stmf_lun_map_ent_t *lun_map_ent;
 404         uint32_t new_flags = 0;
 405         uint16_t luNbr =
 406             ((uint16_t)lu_nbr[1] | (((uint16_t)(lu_nbr[0] & 0x3F)) << 8));
 407 
 408         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 409         ASSERT(!stmf_get_ent_from_map(sm, luNbr));
 410 
 411         if ((sm->lm_nluns == 0) &&
 412             ((iss->iss_flags & ISS_BEING_CREATED) == 0)) {
 413                 new_flags = ISS_GOT_INITIAL_LUNS;
 414                 atomic_or_32(&ilport->ilport_flags, ILPORT_SS_GOT_INITIAL_LUNS);
 415                 stmf_state.stmf_process_initial_luns = 1;
 416         }
 417 
 418         lun_map_ent = (stmf_lun_map_ent_t *)
 419             kmem_zalloc(sizeof (stmf_lun_map_ent_t), KM_SLEEP);
 420         lun_map_ent->ent_lu = lu;
 421         ret = stmf_add_ent_to_map(sm, (void *)lun_map_ent, lu_nbr);
 422         ASSERT(ret == STMF_SUCCESS);
 423         atomic_inc_32(&ilu->ilu_ref_cnt);
 424         /*
 425          * do not set lun inventory flag for standby port
 426          * as this would be handled from peer
 427          */
 428         if (ilport->ilport_standby == 0) {
 429                 new_flags |= ISS_LUN_INVENTORY_CHANGED;
 430         }
 431         atomic_or_32(&iss->iss_flags, new_flags);
 432         return (STMF_SUCCESS);
 433 }
 434 
 435 /*
 436  * remvoe lu from a session, stmf_lock is already held
 437  */
 438 /* ARGSUSED */
 439 stmf_status_t
 440 stmf_remove_lu_from_session(stmf_i_local_port_t *ilport,
 441                 stmf_i_scsi_session_t *iss,
 442                 stmf_lu_t *lu,
 443                 uint8_t *lu_nbr)
 444 {
 445         stmf_status_t ret;
 446         stmf_i_lu_t *ilu;
 447         stmf_lun_map_t *sm = iss->iss_sm;
 448         stmf_lun_map_ent_t *lun_map_ent;
 449         uint16_t luNbr =
 450             ((uint16_t)lu_nbr[1] | (((uint16_t)(lu_nbr[0] & 0x3F)) << 8));
 451 
 452         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 453         lun_map_ent = stmf_get_ent_from_map(sm, luNbr);
 454         ASSERT(lun_map_ent && lun_map_ent->ent_lu == lu);
 455 
 456         ilu = (stmf_i_lu_t *)lu->lu_stmf_private;
 457 
 458         ret = stmf_remove_ent_from_map(sm, lu_nbr);
 459         ASSERT(ret == STMF_SUCCESS);
 460         atomic_dec_32(&ilu->ilu_ref_cnt);
 461         iss->iss_flags |= ISS_LUN_INVENTORY_CHANGED;
 462         if (lun_map_ent->ent_itl_datap) {
 463                 stmf_do_itl_dereg(lu, lun_map_ent->ent_itl_datap,
 464                     STMF_ITL_REASON_USER_REQUEST);
 465         }
 466         kmem_free((void *)lun_map_ent, sizeof (stmf_lun_map_ent_t));
 467         return (STMF_SUCCESS);
 468 }
 469 
 470 /*
 471  * add or remove lu from all related sessions based on view entry,
 472  * action is 0 for delete, 1 for add
 473  */
 474 void
 475 stmf_update_sessions_per_ve(stmf_view_entry_t *ve,
 476                 stmf_lu_t *lu, int action)
 477 {
 478         stmf_i_lu_t *ilu_tmp;
 479         stmf_lu_t *lu_to_add;
 480         stmf_i_local_port_t *ilport;
 481         stmf_i_scsi_session_t *iss;
 482         stmf_id_list_t  *hostlist;
 483         stmf_id_list_t  *targetlist;
 484         int all_hg = 0, all_tg = 0;
 485 
 486         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 487 
 488         if (!lu) {
 489                 ilu_tmp = (stmf_i_lu_t *)ve->ve_luid->id_pt_to_object;
 490                 if (!ilu_tmp)
 491                         return;
 492                 lu_to_add = ilu_tmp->ilu_lu;
 493         } else {
 494                 lu_to_add = lu;
 495                 ilu_tmp = (stmf_i_lu_t *)lu->lu_stmf_private;
 496         }
 497 
 498         if (ve->ve_hg->id_data[0] == '*')
 499                 all_hg = 1;
 500         if (ve->ve_tg->id_data[0] == '*')
 501                 all_tg = 1;
 502         hostlist = (stmf_id_list_t *)ve->ve_hg->id_impl_specific;
 503         targetlist = (stmf_id_list_t *)ve->ve_tg->id_impl_specific;
 504 
 505         if ((!all_hg && !hostlist->idl_head) ||
 506             (!all_tg && !targetlist->idl_head))
 507                 /* No sessions to be updated */
 508                 return;
 509 
 510         for (ilport = stmf_state.stmf_ilportlist; ilport != NULL;
 511             ilport = ilport->ilport_next) {
 512                 if (!all_tg && ilport->ilport_tg != ve->ve_tg)
 513                         continue;
 514                 /* This ilport belongs to the target group */
 515                 rw_enter(&ilport->ilport_lock, RW_WRITER);
 516                 for (iss = ilport->ilport_ss_list; iss != NULL;
 517                     iss = iss->iss_next) {
 518                         if (!all_hg && iss->iss_hg != ve->ve_hg)
 519                                 continue;
 520                         /* This host belongs to the host group */
 521                         if (action == 0) { /* to remove */
 522                                 (void) stmf_remove_lu_from_session(ilport, iss,
 523                                     lu_to_add, ve->ve_lun);
 524                                 if (ilu_tmp->ilu_ref_cnt == 0) {
 525                                         rw_exit(&ilport->ilport_lock);
 526                                         return;
 527                                 }
 528                         } else {
 529                                 (void) stmf_add_lu_to_session(ilport, iss,
 530                                     lu_to_add, ve->ve_lun);
 531                         }
 532                 }
 533                 rw_exit(&ilport->ilport_lock);
 534         }
 535 }
 536 
 537 /*
 538  * add luns in view entry map to a session,
 539  * and stmf_lock is already held
 540  */
 541 void
 542 stmf_add_lus_to_session_per_vemap(stmf_i_local_port_t *ilport,
 543                 stmf_i_scsi_session_t *iss,
 544                 stmf_lun_map_t *vemap)
 545 {
 546         stmf_lu_t *lu;
 547         stmf_i_lu_t *ilu;
 548         stmf_view_entry_t *ve;
 549         uint32_t        i;
 550 
 551         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 552 
 553         for (i = 0; i < vemap->lm_nentries; i++) {
 554                 ve = (stmf_view_entry_t *)vemap->lm_plus[i];
 555                 if (!ve)
 556                         continue;
 557                 ilu = (stmf_i_lu_t *)ve->ve_luid->id_pt_to_object;
 558                 if (ilu && ilu->ilu_state == STMF_STATE_ONLINE) {
 559                         lu = ilu->ilu_lu;
 560                         (void) stmf_add_lu_to_session(ilport, iss, lu,
 561                             ve->ve_lun);
 562                 }
 563         }
 564 }
 565 /* remove luns in view entry map from a session */
 566 void
 567 stmf_remove_lus_from_session_per_vemap(stmf_i_local_port_t *ilport,
 568                 stmf_i_scsi_session_t *iss,
 569                 stmf_lun_map_t *vemap)
 570 {
 571         stmf_lu_t *lu;
 572         stmf_i_lu_t *ilu;
 573         stmf_view_entry_t *ve;
 574         uint32_t i;
 575 
 576         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 577 
 578         for (i = 0; i < vemap->lm_nentries; i++) {
 579                 ve = (stmf_view_entry_t *)vemap->lm_plus[i];
 580                 if (!ve)
 581                         continue;
 582                 ilu = (stmf_i_lu_t *)ve->ve_luid->id_pt_to_object;
 583                 if (ilu && ilu->ilu_state == STMF_STATE_ONLINE) {
 584                         lu = ilu->ilu_lu;
 585                         (void) stmf_remove_lu_from_session(ilport, iss, lu,
 586                             ve->ve_lun);
 587                 }
 588         }
 589 }
 590 
 591 stmf_id_data_t *
 592 stmf_alloc_id(uint16_t id_size, uint16_t type, uint8_t *id_data,
 593                         uint32_t additional_size)
 594 {
 595         stmf_id_data_t *id;
 596         int struct_size, total_size, real_id_size;
 597 
 598         real_id_size = ((uint32_t)id_size + 7) & (~7);
 599         struct_size = (sizeof (*id) + 7) & (~7);
 600         total_size = ((additional_size + 7) & (~7)) + struct_size +
 601             real_id_size;
 602         id = (stmf_id_data_t *)kmem_zalloc(total_size, KM_SLEEP);
 603         id->id_type = type;
 604         id->id_data_size = id_size;
 605         id->id_data = ((uint8_t *)id) + struct_size;
 606         id->id_total_alloc_size = total_size;
 607         if (additional_size) {
 608                 id->id_impl_specific = ((uint8_t *)id) + struct_size +
 609                     real_id_size;
 610         }
 611         bcopy(id_data, id->id_data, id_size);
 612 
 613         return (id);
 614 }
 615 
 616 void
 617 stmf_free_id(stmf_id_data_t *id)
 618 {
 619         kmem_free(id, id->id_total_alloc_size);
 620 }
 621 
 622 
 623 stmf_id_data_t *
 624 stmf_lookup_id(stmf_id_list_t *idlist, uint16_t id_size, uint8_t *data)
 625 {
 626         stmf_id_data_t *id;
 627 
 628         for (id = idlist->idl_head; id != NULL; id = id->id_next) {
 629                 if ((id->id_data_size == id_size) &&
 630                     (bcmp(id->id_data, data, id_size) == 0)) {
 631                         return (id);
 632                 }
 633         }
 634 
 635         return (NULL);
 636 }
 637 /* Return the target group which a target belong to */
 638 stmf_id_data_t *
 639 stmf_lookup_group_for_target(uint8_t *ident, uint16_t ident_size)
 640 {
 641         stmf_id_data_t *tgid;
 642         stmf_id_data_t *target;
 643 
 644         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 645 
 646         for (tgid = stmf_state.stmf_tg_list.idl_head; tgid;
 647             tgid = tgid->id_next) {
 648                 target = stmf_lookup_id(
 649                     (stmf_id_list_t *)tgid->id_impl_specific,
 650                     ident_size, ident);
 651                 if (target)
 652                         return (tgid);
 653         }
 654         return (NULL);
 655 }
 656 /* Return the host group which a host belong to */
 657 stmf_id_data_t *
 658 stmf_lookup_group_for_host(uint8_t *ident, uint16_t ident_size)
 659 {
 660         stmf_id_data_t *hgid;
 661         stmf_id_data_t *host;
 662 
 663         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 664 
 665         for (hgid = stmf_state.stmf_hg_list.idl_head; hgid;
 666             hgid = hgid->id_next) {
 667                 host = stmf_lookup_id(
 668                     (stmf_id_list_t *)hgid->id_impl_specific,
 669                     ident_size, ident);
 670                 if (host)
 671                         return (hgid);
 672         }
 673         return (NULL);
 674 }
 675 
 676 void
 677 stmf_append_id(stmf_id_list_t *idlist, stmf_id_data_t *id)
 678 {
 679         id->id_next = NULL;
 680 
 681         if ((id->id_prev = idlist->idl_tail) == NULL) {
 682                 idlist->idl_head = idlist->idl_tail = id;
 683         } else {
 684                 idlist->idl_tail->id_next = id;
 685                 idlist->idl_tail = id;
 686         }
 687         atomic_inc_32(&idlist->id_count);
 688 }
 689 
 690 void
 691 stmf_remove_id(stmf_id_list_t *idlist, stmf_id_data_t *id)
 692 {
 693         if (id->id_next) {
 694                 id->id_next->id_prev = id->id_prev;
 695         } else {
 696                 idlist->idl_tail = id->id_prev;
 697         }
 698 
 699         if (id->id_prev) {
 700                 id->id_prev->id_next = id->id_next;
 701         } else {
 702                 idlist->idl_head = id->id_next;
 703         }
 704         atomic_dec_32(&idlist->id_count);
 705 }
 706 
 707 
 708 /*
 709  * The refcnts of objects in a view entry are updated when then entry
 710  * is successfully added. ve_map is just another representation of the
 711  * view enrtries in a LU. Duplicating or merging a ve map does not
 712  * affect any refcnts.
 713  */
 714 stmf_lun_map_t *
 715 stmf_duplicate_ve_map(stmf_lun_map_t *src)
 716 {
 717         stmf_lun_map_t *dst;
 718         int i;
 719 
 720         dst = (stmf_lun_map_t *)kmem_zalloc(sizeof (*dst), KM_SLEEP);
 721 
 722         if (src == NULL)
 723                 return (dst);
 724 
 725         if (src->lm_nentries) {
 726                 dst->lm_plus = kmem_zalloc(dst->lm_nentries *
 727                     sizeof (void *), KM_SLEEP);
 728                 for (i = 0; i < dst->lm_nentries; i++) {
 729                         dst->lm_plus[i] = src->lm_plus[i];
 730                 }
 731         }
 732 
 733         return (dst);
 734 }
 735 
 736 void
 737 stmf_destroy_ve_map(stmf_lun_map_t *dst)
 738 {
 739         if (dst->lm_nentries) {
 740                 kmem_free(dst->lm_plus, dst->lm_nentries * sizeof (void *));
 741         }
 742         kmem_free(dst, sizeof (*dst));
 743 }
 744 
 745 int
 746 stmf_merge_ve_map(stmf_lun_map_t *src, stmf_lun_map_t *dst,
 747                 stmf_lun_map_t **pp_ret_map, stmf_merge_flags_t mf)
 748 {
 749         int i;
 750         int nentries;
 751         int to_create_space = 0;
 752 
 753         if (dst == NULL) {
 754                 *pp_ret_map = stmf_duplicate_ve_map(src);
 755                 return (1);
 756         }
 757 
 758         if (src == NULL || src->lm_nluns == 0) {
 759                 if (mf & MERGE_FLAG_RETURN_NEW_MAP)
 760                         *pp_ret_map = stmf_duplicate_ve_map(dst);
 761                 else
 762                         *pp_ret_map = dst;
 763                 return (1);
 764         }
 765 
 766         if (mf & MERGE_FLAG_RETURN_NEW_MAP) {
 767                 *pp_ret_map = stmf_duplicate_ve_map(NULL);
 768                 nentries = max(dst->lm_nentries, src->lm_nentries);
 769                 to_create_space = 1;
 770         } else {
 771                 *pp_ret_map = dst;
 772                 /* If there is not enough space in dst map */
 773                 if (dst->lm_nentries < src->lm_nentries) {
 774                         nentries = src->lm_nentries;
 775                         to_create_space = 1;
 776                 }
 777         }
 778         if (to_create_space) {
 779                 void **p;
 780                 p = (void **)kmem_zalloc(nentries * sizeof (void *), KM_SLEEP);
 781                 if (dst->lm_nentries) {
 782                         bcopy(dst->lm_plus, p,
 783                             dst->lm_nentries * sizeof (void *));
 784                 }
 785                 if (mf & (MERGE_FLAG_RETURN_NEW_MAP == 0))
 786                         kmem_free(dst->lm_plus,
 787                             dst->lm_nentries * sizeof (void *));
 788                 (*pp_ret_map)->lm_plus = p;
 789                 (*pp_ret_map)->lm_nentries = nentries;
 790         }
 791 
 792         for (i = 0; i < src->lm_nentries; i++) {
 793                 if (src->lm_plus[i] == NULL)
 794                         continue;
 795                 if (dst->lm_plus[i] != NULL) {
 796                         if (mf & MERGE_FLAG_NO_DUPLICATE) {
 797                                 if (mf & MERGE_FLAG_RETURN_NEW_MAP) {
 798                                         stmf_destroy_ve_map(*pp_ret_map);
 799                                         *pp_ret_map = NULL;
 800                                 }
 801                                 return (0);
 802                         }
 803                 } else {
 804                         dst->lm_plus[i] = src->lm_plus[i];
 805                         dst->lm_nluns++;
 806                 }
 807         }
 808 
 809         return (1);
 810 }
 811 
 812 /*
 813  * add host group, id_impl_specific point to a list of hosts,
 814  * on return, if error happened, err_detail may be assigned if
 815  * the pointer is not NULL
 816  */
 817 stmf_status_t
 818 stmf_add_hg(uint8_t *hg_name, uint16_t hg_name_size,
 819                 int allow_special, uint32_t *err_detail)
 820 {
 821         stmf_id_data_t *id;
 822 
 823         if (!allow_special) {
 824                 if (hg_name[0] == '*')
 825                         return (STMF_INVALID_ARG);
 826         }
 827 
 828         if (stmf_lookup_id(&stmf_state.stmf_hg_list,
 829             hg_name_size, (uint8_t *)hg_name)) {
 830                 if (err_detail)
 831                         *err_detail = STMF_IOCERR_HG_EXISTS;
 832                 return (STMF_ALREADY);
 833         }
 834         id = stmf_alloc_id(hg_name_size, STMF_ID_TYPE_HOST_GROUP,
 835             (uint8_t *)hg_name, sizeof (stmf_id_list_t));
 836         stmf_append_id(&stmf_state.stmf_hg_list, id);
 837 
 838         return (STMF_SUCCESS);
 839 }
 840 
 841 /* add target group */
 842 stmf_status_t
 843 stmf_add_tg(uint8_t *tg_name, uint16_t tg_name_size,
 844                 int allow_special, uint32_t *err_detail)
 845 {
 846         stmf_id_data_t *id;
 847 
 848         if (!allow_special) {
 849                 if (tg_name[0] == '*')
 850                         return (STMF_INVALID_ARG);
 851         }
 852 
 853 
 854         if (stmf_lookup_id(&stmf_state.stmf_tg_list, tg_name_size,
 855             (uint8_t *)tg_name)) {
 856                 if (err_detail)
 857                         *err_detail = STMF_IOCERR_TG_EXISTS;
 858                 return (STMF_ALREADY);
 859         }
 860         id = stmf_alloc_id(tg_name_size, STMF_ID_TYPE_TARGET_GROUP,
 861             (uint8_t *)tg_name, sizeof (stmf_id_list_t));
 862         stmf_append_id(&stmf_state.stmf_tg_list, id);
 863 
 864         return (STMF_SUCCESS);
 865 }
 866 
 867 /*
 868  * insert view entry into list for a luid, if ve->ve_id is 0xffffffff,
 869  * pick up a smallest available veid for it, and return the veid in ve->ve_id.
 870  * The view entries list is sorted based on veid.
 871  */
 872 stmf_status_t
 873 stmf_add_ve_to_luid(stmf_id_data_t *luid, stmf_view_entry_t *ve)
 874 {
 875         stmf_view_entry_t *ve_tmp = NULL;
 876         stmf_view_entry_t *ve_prev = NULL;
 877 
 878         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 879 
 880         ve_tmp = (stmf_view_entry_t *)luid->id_impl_specific;
 881 
 882         if (ve->ve_id != 0xffffffff) {
 883                 for (; ve_tmp; ve_tmp = ve_tmp->ve_next) {
 884                         if (ve_tmp->ve_id > ve->ve_id) {
 885                                 break;
 886                         } else if (ve_tmp->ve_id == ve->ve_id) {
 887                                 return (STMF_ALREADY);
 888                         }
 889                         ve_prev = ve_tmp;
 890                 }
 891         } else {
 892                 uint32_t veid = 0;
 893                 /* search the smallest available veid */
 894                 for (; ve_tmp; ve_tmp = ve_tmp->ve_next) {
 895                         ASSERT(ve_tmp->ve_id >= veid);
 896                         if (ve_tmp->ve_id != veid)
 897                                 break;
 898                         veid++;
 899                         if (veid == 0xffffffff)
 900                                 return (STMF_NOT_SUPPORTED);
 901                         ve_prev = ve_tmp;
 902                 }
 903                 ve->ve_id = veid;
 904         }
 905 
 906         /* insert before ve_tmp if it exist */
 907         ve->ve_next = ve_tmp;
 908         ve->ve_prev = ve_prev;
 909         if (ve_tmp) {
 910                 ve_tmp->ve_prev = ve;
 911         }
 912         if (ve_prev) {
 913                 ve_prev->ve_next = ve;
 914         } else {
 915                 luid->id_impl_specific = (void *)ve;
 916         }
 917         return (STMF_SUCCESS);
 918 }
 919 
 920 /* stmf_lock is already held, err_detail may be assigned if error happens */
 921 stmf_status_t
 922 stmf_add_view_entry(stmf_id_data_t *hg, stmf_id_data_t *tg,
 923                 uint8_t *lu_guid, uint32_t *ve_id, uint8_t *lun,
 924                 stmf_view_entry_t **conflicting, uint32_t *err_detail)
 925 {
 926         stmf_id_data_t *luid;
 927         stmf_view_entry_t *ve;
 928         char *phg, *ptg;
 929         stmf_lun_map_t *ve_map = NULL;
 930         stmf_ver_hg_t *verhg = NULL, *verhg_ex = NULL;
 931         stmf_ver_tg_t *vertg = NULL, *vertg_ex = NULL;
 932         char luid_new;
 933         uint16_t lun_num;
 934         stmf_i_lu_t *ilu;
 935         stmf_status_t ret;
 936 
 937         ASSERT(mutex_owned(&stmf_state.stmf_lock));
 938 
 939         lun_num = ((uint16_t)lun[1] | (((uint16_t)(lun[0] & 0x3F)) << 8));
 940 
 941         luid = stmf_lookup_id(&stmf_state.stmf_luid_list, 16, lu_guid);
 942         if (luid == NULL) {
 943                 luid = stmf_alloc_id(16, STMF_ID_TYPE_LU_GUID, lu_guid, 0);
 944                 ilu = stmf_luident_to_ilu(lu_guid);
 945                 if (ilu) {
 946                         ilu->ilu_luid = luid;
 947                         luid->id_pt_to_object = (void *)ilu;
 948                 }
 949                 luid_new = 1;
 950         } else {
 951                 luid_new = 0;
 952                 ilu = (stmf_i_lu_t *)luid->id_pt_to_object;
 953         }
 954 
 955         /* The view entry won't be added if there is any confilict */
 956         phg = (char *)hg->id_data; ptg = (char *)tg->id_data;
 957         for (ve = (stmf_view_entry_t *)luid->id_impl_specific; ve != NULL;
 958             ve = ve->ve_next) {
 959                 if (((phg[0] == '*') || (ve->ve_hg->id_data[0] == '*') ||
 960                     (hg == ve->ve_hg)) && ((ptg[0] == '*') ||
 961                     (ve->ve_tg->id_data[0] == '*') || (tg == ve->ve_tg))) {
 962                         *conflicting = ve;
 963                         *err_detail = STMF_IOCERR_VIEW_ENTRY_CONFLICT;
 964                         ret = STMF_ALREADY;
 965                         goto add_ve_err_ret;
 966                 }
 967         }
 968 
 969         ve_map = stmf_duplicate_ve_map(0);
 970         for (vertg = stmf_state.stmf_ver_tg_head; vertg != NULL;
 971             vertg = vertg->vert_next) {
 972                 ptg = (char *)vertg->vert_tg_ref->id_data;
 973                 if ((ptg[0] != '*') && (tg->id_data[0] != '*') &&
 974                     (vertg->vert_tg_ref != tg)) {
 975                         continue;
 976                 }
 977                 if (vertg->vert_tg_ref == tg)
 978                         vertg_ex = vertg;
 979                 for (verhg = vertg->vert_verh_list; verhg != NULL;
 980                     verhg = verhg->verh_next) {
 981                         phg = (char *)verhg->verh_hg_ref->id_data;
 982                         if ((phg[0] != '*') && (hg->id_data[0] != '*') &&
 983                             (verhg->verh_hg_ref != hg)) {
 984                                 continue;
 985                         }
 986                         if ((vertg_ex == vertg) && (verhg->verh_hg_ref == hg))
 987                                 verhg_ex = verhg;
 988                         (void) stmf_merge_ve_map(&verhg->verh_ve_map, ve_map,
 989                             &ve_map, 0);
 990                 }
 991         }
 992 
 993         if (lun[2] == 0xFF) {
 994                 /* Pick a LUN number */
 995                 lun_num = stmf_get_next_free_lun(ve_map, lun);
 996                 if (lun_num > 0x3FFF) {
 997                         stmf_destroy_ve_map(ve_map);
 998                         ret = STMF_NOT_SUPPORTED;
 999                         goto add_ve_err_ret;
1000                 }
1001         } else {
1002                 if ((*conflicting = stmf_get_ent_from_map(ve_map, lun_num))
1003                     != NULL) {
1004                         stmf_destroy_ve_map(ve_map);
1005                         *err_detail = STMF_IOCERR_LU_NUMBER_IN_USE;
1006                         ret = STMF_LUN_TAKEN;
1007                         goto add_ve_err_ret;
1008                 }
1009         }
1010         stmf_destroy_ve_map(ve_map);
1011 
1012         /* All is well, do the actual addition now */
1013         ve = (stmf_view_entry_t *)kmem_zalloc(sizeof (*ve), KM_SLEEP);
1014         ve->ve_id = *ve_id;
1015         ve->ve_lun[0] = lun[0];
1016         ve->ve_lun[1] = lun[1];
1017 
1018         if ((ret = stmf_add_ve_to_luid(luid, ve)) != STMF_SUCCESS) {
1019                 kmem_free(ve, sizeof (stmf_view_entry_t));
1020                 goto add_ve_err_ret;
1021         }
1022         ve->ve_hg = hg; hg->id_refcnt++;
1023         ve->ve_tg = tg; tg->id_refcnt++;
1024         ve->ve_luid = luid; luid->id_refcnt++;
1025 
1026         *ve_id = ve->ve_id;
1027 
1028         if (luid_new) {
1029                 stmf_append_id(&stmf_state.stmf_luid_list, luid);
1030         }
1031 
1032         if (vertg_ex == NULL) {
1033                 vertg_ex = (stmf_ver_tg_t *)kmem_zalloc(sizeof (stmf_ver_tg_t),
1034                     KM_SLEEP);
1035                 vertg_ex->vert_next = stmf_state.stmf_ver_tg_head;
1036                 stmf_state.stmf_ver_tg_head = vertg_ex;
1037                 vertg_ex->vert_tg_ref = tg;
1038                 verhg_ex = vertg_ex->vert_verh_list =
1039                     (stmf_ver_hg_t *)kmem_zalloc(sizeof (stmf_ver_hg_t),
1040                     KM_SLEEP);
1041                 verhg_ex->verh_hg_ref = hg;
1042         }
1043         if (verhg_ex == NULL) {
1044                 verhg_ex = (stmf_ver_hg_t *)kmem_zalloc(sizeof (stmf_ver_hg_t),
1045                     KM_SLEEP);
1046                 verhg_ex->verh_next = vertg_ex->vert_verh_list;
1047                 vertg_ex->vert_verh_list = verhg_ex;
1048                 verhg_ex->verh_hg_ref = hg;
1049         }
1050         ret = stmf_add_ent_to_map(&verhg_ex->verh_ve_map, ve, ve->ve_lun);
1051         ASSERT(ret == STMF_SUCCESS);
1052 
1053         /* we need to update the affected session */
1054         if (stmf_state.stmf_service_running) {
1055                 if (ilu && ilu->ilu_state == STMF_STATE_ONLINE)
1056                         stmf_update_sessions_per_ve(ve, ilu->ilu_lu, 1);
1057         }
1058 
1059         return (STMF_SUCCESS);
1060 add_ve_err_ret:
1061         if (luid_new) {
1062                 if (ilu)
1063                         ilu->ilu_luid = NULL;
1064                 stmf_free_id(luid);
1065         }
1066         return (ret);
1067 }
1068 
1069 stmf_status_t
1070 stmf_add_ent_to_map(stmf_lun_map_t *lm, void *ent, uint8_t *lun)
1071 {
1072         uint16_t n;
1073         if (((lun[0] & 0xc0) >> 6) != 0)
1074                 return (STMF_FAILURE);
1075 
1076         n = (uint16_t)lun[1] | (((uint16_t)(lun[0] & 0x3F)) << 8);
1077 try_again_to_add:
1078         if (lm->lm_nentries && (n < lm->lm_nentries)) {
1079                 if (lm->lm_plus[n] == NULL) {
1080                         lm->lm_plus[n] = ent;
1081                         lm->lm_nluns++;
1082                         return (STMF_SUCCESS);
1083                 } else {
1084                         return (STMF_LUN_TAKEN);
1085                 }
1086         } else {
1087                 void **pplu;
1088                 uint16_t m = n + 1;
1089                 m = ((m + 7) & ~7) & 0x7FFF;
1090                 pplu = (void **)kmem_zalloc(m * sizeof (void *), KM_SLEEP);
1091                 bcopy(lm->lm_plus, pplu,
1092                     lm->lm_nentries * sizeof (void *));
1093                 kmem_free(lm->lm_plus, lm->lm_nentries * sizeof (void *));
1094                 lm->lm_plus = pplu;
1095                 lm->lm_nentries = m;
1096                 goto try_again_to_add;
1097         }
1098 }
1099 
1100 
1101 stmf_status_t
1102 stmf_remove_ent_from_map(stmf_lun_map_t *lm, uint8_t *lun)
1103 {
1104         uint16_t n, i;
1105         uint8_t lutype = (lun[0] & 0xc0) >> 6;
1106         if (lutype != 0)
1107                 return (STMF_FAILURE);
1108 
1109         n = (uint16_t)lun[1] | (((uint16_t)(lun[0] & 0x3F)) << 8);
1110 
1111         if (n >= lm->lm_nentries)
1112                 return (STMF_NOT_FOUND);
1113         if (lm->lm_plus[n] == NULL)
1114                 return (STMF_NOT_FOUND);
1115 
1116         lm->lm_plus[n] = NULL;
1117         lm->lm_nluns--;
1118 
1119         for (i = 0; i < lm->lm_nentries; i++) {
1120                 if (lm->lm_plus[lm->lm_nentries - 1 - i] != NULL)
1121                         break;
1122         }
1123         i &= ~15;
1124         if (i >= 16) {
1125                 void **pplu;
1126                 uint16_t m;
1127                 m = lm->lm_nentries - i;
1128                 pplu = (void **)kmem_zalloc(m * sizeof (void *), KM_SLEEP);
1129                 bcopy(lm->lm_plus, pplu, m * sizeof (void *));
1130                 kmem_free(lm->lm_plus, lm->lm_nentries * sizeof (void *));
1131                 lm->lm_plus = pplu;
1132                 lm->lm_nentries = m;
1133         }
1134 
1135         return (STMF_SUCCESS);
1136 }
1137 
1138 uint16_t
1139 stmf_get_next_free_lun(stmf_lun_map_t *sm, uint8_t *lun)
1140 {
1141         uint16_t luNbr;
1142 
1143 
1144         if (sm->lm_nluns < 0x4000) {
1145                 for (luNbr = 0; luNbr < sm->lm_nentries; luNbr++) {
1146                         if (sm->lm_plus[luNbr] == NULL)
1147                                 break;
1148                 }
1149         } else {
1150                 return (0xFFFF);
1151         }
1152         if (lun) {
1153                 bzero(lun, 8);
1154                 lun[1] = luNbr & 0xff;
1155                 lun[0] = (luNbr >> 8) & 0xff;
1156         }
1157 
1158         return (luNbr);
1159 }
1160 
1161 void *
1162 stmf_get_ent_from_map(stmf_lun_map_t *sm, uint16_t lun_num)
1163 {
1164         if ((lun_num & 0xC000) == 0) {
1165                 if (sm->lm_nentries > lun_num)
1166                         return (sm->lm_plus[lun_num & 0x3FFF]);
1167                 else
1168                         return (NULL);
1169         }
1170 
1171         return (NULL);
1172 }
1173 
1174 int
1175 stmf_add_ve(uint8_t *hgname, uint16_t hgname_size,
1176                 uint8_t *tgname, uint16_t tgname_size,
1177                 uint8_t *lu_guid, uint32_t *ve_id,
1178                 uint8_t *luNbr, uint32_t *err_detail)
1179 {
1180         stmf_id_data_t *hg;
1181         stmf_id_data_t *tg;
1182         stmf_view_entry_t *conflictve;
1183         stmf_status_t ret;
1184 
1185         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1186 
1187         hg = stmf_lookup_id(&stmf_state.stmf_hg_list, hgname_size,
1188             (uint8_t *)hgname);
1189         if (!hg) {
1190                 *err_detail = STMF_IOCERR_INVALID_HG;
1191                 return (ENOENT); /* could not find group */
1192         }
1193         tg = stmf_lookup_id(&stmf_state.stmf_tg_list, tgname_size,
1194             (uint8_t *)tgname);
1195         if (!tg) {
1196                 *err_detail = STMF_IOCERR_INVALID_TG;
1197                 return (ENOENT); /* could not find group */
1198         }
1199         ret = stmf_add_view_entry(hg, tg, lu_guid, ve_id, luNbr,
1200             &conflictve, err_detail);
1201 
1202         if (ret == STMF_ALREADY) {
1203                 return (EALREADY);
1204         } else if (ret == STMF_LUN_TAKEN) {
1205                 return (EEXIST);
1206         } else if (ret == STMF_NOT_SUPPORTED) {
1207                 return (E2BIG);
1208         } else if (ret != STMF_SUCCESS) {
1209                 return (EINVAL);
1210         }
1211         return (0);
1212 }
1213 
1214 int
1215 stmf_remove_ve_by_id(uint8_t *guid, uint32_t veid, uint32_t *err_detail)
1216 {
1217         stmf_id_data_t *luid;
1218         stmf_view_entry_t       *ve;
1219         stmf_ver_tg_t *vtg;
1220         stmf_ver_hg_t *vhg;
1221         stmf_ver_tg_t *prev_vtg = NULL;
1222         stmf_ver_hg_t *prev_vhg = NULL;
1223         int found = 0;
1224         stmf_i_lu_t *ilu;
1225 
1226         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1227         luid = stmf_lookup_id(&stmf_state.stmf_luid_list, 16, guid);
1228         if (luid == NULL) {
1229                 *err_detail = STMF_IOCERR_INVALID_LU_ID;
1230                 return (ENODEV);
1231         }
1232         ilu = (stmf_i_lu_t *)luid->id_pt_to_object;
1233 
1234         for (ve = (stmf_view_entry_t *)luid->id_impl_specific;
1235             ve; ve = ve->ve_next) {
1236                 if (ve->ve_id == veid) {
1237                         break;
1238                 }
1239         }
1240         if (!ve) {
1241                 *err_detail = STMF_IOCERR_INVALID_VE_ID;
1242                 return (ENODEV);
1243         }
1244         /* remove the ve */
1245         if (ve->ve_next)
1246                 ve->ve_next->ve_prev = ve->ve_prev;
1247         if (ve->ve_prev)
1248                 ve->ve_prev->ve_next = ve->ve_next;
1249         else {
1250                 luid->id_impl_specific = (void *)ve->ve_next;
1251                 if (!luid->id_impl_specific) {
1252                         /* don't have any view entries related to this lu */
1253                         stmf_remove_id(&stmf_state.stmf_luid_list, luid);
1254                         if (ilu)
1255                                 ilu->ilu_luid = NULL;
1256                         stmf_free_id(luid);
1257                 }
1258         }
1259 
1260         /* we need to update ver_hg->verh_ve_map */
1261         for (vtg = stmf_state.stmf_ver_tg_head; vtg; vtg = vtg->vert_next) {
1262                 if (vtg->vert_tg_ref == ve->ve_tg) {
1263                         found = 1;
1264                         break;
1265                 }
1266                 prev_vtg = vtg;
1267         }
1268         ASSERT(found);
1269         found = 0;
1270         for (vhg = vtg->vert_verh_list; vhg; vhg = vhg->verh_next) {
1271                 if (vhg->verh_hg_ref == ve->ve_hg) {
1272                         found = 1;
1273                         break;
1274                 }
1275                 prev_vhg = vhg;
1276         }
1277         ASSERT(found);
1278 
1279         (void) stmf_remove_ent_from_map(&vhg->verh_ve_map, ve->ve_lun);
1280 
1281         /* free verhg if it don't have any ve entries related */
1282         if (!vhg->verh_ve_map.lm_nluns) {
1283                 /* we don't have any view entry related */
1284                 if (prev_vhg)
1285                         prev_vhg->verh_next = vhg->verh_next;
1286                 else
1287                         vtg->vert_verh_list = vhg->verh_next;
1288 
1289                 /* Free entries in case the map still has memory */
1290                 if (vhg->verh_ve_map.lm_nentries) {
1291                         kmem_free(vhg->verh_ve_map.lm_plus,
1292                             vhg->verh_ve_map.lm_nentries *
1293                             sizeof (void *));
1294                 }
1295                 kmem_free(vhg, sizeof (stmf_ver_hg_t));
1296                 if (!vtg->vert_verh_list) {
1297                         /* we don't have any ve related */
1298                         if (prev_vtg)
1299                                 prev_vtg->vert_next = vtg->vert_next;
1300                         else
1301                                 stmf_state.stmf_ver_tg_head = vtg->vert_next;
1302                         kmem_free(vtg, sizeof (stmf_ver_tg_t));
1303                 }
1304         }
1305 
1306         if (stmf_state.stmf_service_running && ilu &&
1307             ilu->ilu_state == STMF_STATE_ONLINE) {
1308                 stmf_update_sessions_per_ve(ve, ilu->ilu_lu, 0);
1309         }
1310 
1311         ve->ve_hg->id_refcnt--;
1312         ve->ve_tg->id_refcnt--;
1313 
1314         kmem_free(ve, sizeof (stmf_view_entry_t));
1315         return (0);
1316 }
1317 
1318 int
1319 stmf_add_group(uint8_t *grpname, uint16_t grpname_size,
1320                 stmf_id_type_t group_type, uint32_t *err_detail)
1321 {
1322         stmf_status_t status;
1323 
1324         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1325 
1326         if (group_type == STMF_ID_TYPE_HOST_GROUP)
1327                 status = stmf_add_hg(grpname, grpname_size, 0, err_detail);
1328         else if (group_type == STMF_ID_TYPE_TARGET_GROUP)
1329                 status = stmf_add_tg(grpname, grpname_size, 0, err_detail);
1330         else {
1331                 return (EINVAL);
1332         }
1333         switch (status) {
1334         case STMF_SUCCESS:
1335                 return (0);
1336         case STMF_INVALID_ARG:
1337                 return (EINVAL);
1338         case STMF_ALREADY:
1339                 return (EEXIST);
1340         default:
1341                 return (EIO);
1342         }
1343 }
1344 
1345 /*
1346  * Group can only be removed only when it does not have
1347  * any view entry related
1348  */
1349 int
1350 stmf_remove_group(uint8_t *grpname, uint16_t grpname_size,
1351                 stmf_id_type_t group_type, uint32_t *err_detail)
1352 {
1353         stmf_id_data_t *id;
1354         stmf_id_data_t *idmemb;
1355         stmf_id_list_t *grp_memblist;
1356         stmf_i_scsi_session_t *iss;
1357         stmf_i_local_port_t *ilport;
1358 
1359         if (grpname[0] == '*')
1360                 return (EINVAL);
1361 
1362         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1363 
1364         if (group_type == STMF_ID_TYPE_HOST_GROUP)
1365                 id = stmf_lookup_id(&stmf_state.stmf_hg_list,
1366                     grpname_size, grpname);
1367         else if (group_type == STMF_ID_TYPE_TARGET_GROUP)
1368                 id = stmf_lookup_id(&stmf_state.stmf_tg_list,
1369                     grpname_size, grpname);
1370         if (!id) {
1371                 *err_detail = (group_type == STMF_ID_TYPE_HOST_GROUP)?
1372                     STMF_IOCERR_INVALID_HG:STMF_IOCERR_INVALID_TG;
1373                 return (ENODEV); /* no such grp */
1374         }
1375         if (id->id_refcnt) {
1376                 /* fail, still have viewentry related to it */
1377                 *err_detail = (group_type == STMF_ID_TYPE_HOST_GROUP)?
1378                     STMF_IOCERR_HG_IN_USE:STMF_IOCERR_TG_IN_USE;
1379                 return (EBUSY);
1380         }
1381         grp_memblist = (stmf_id_list_t *)id->id_impl_specific;
1382         while ((idmemb = grp_memblist->idl_head) != NULL) {
1383                 stmf_remove_id(grp_memblist, idmemb);
1384                 stmf_free_id(idmemb);
1385         }
1386 
1387         ASSERT(!grp_memblist->id_count);
1388         if (id->id_type == STMF_ID_TYPE_TARGET_GROUP) {
1389                 for (ilport = stmf_state.stmf_ilportlist; ilport;
1390                     ilport = ilport->ilport_next) {
1391                         if (ilport->ilport_tg == (void *)id) {
1392                                 ilport->ilport_tg = NULL;
1393                         }
1394                 }
1395                 stmf_remove_id(&stmf_state.stmf_tg_list, id);
1396         } else {
1397                 for (ilport = stmf_state.stmf_ilportlist; ilport;
1398                     ilport = ilport->ilport_next) {
1399                         for (iss = ilport->ilport_ss_list; iss;
1400                             iss = iss->iss_next) {
1401                                 if (iss->iss_hg == (void *)id)
1402                                         iss->iss_hg = NULL;
1403                         }
1404                 }
1405                 stmf_remove_id(&stmf_state.stmf_hg_list, id);
1406         }
1407         stmf_free_id(id);
1408         return (0);
1409 
1410 }
1411 
1412 int
1413 stmf_add_group_member(uint8_t *grpname, uint16_t grpname_size,
1414                 uint8_t *entry_ident, uint16_t entry_size,
1415                 stmf_id_type_t entry_type, uint32_t *err_detail)
1416 {
1417         stmf_id_data_t  *id_grp, *id_alltgt;
1418         stmf_id_data_t  *id_member;
1419         stmf_id_data_t  *id_grp_tmp;
1420         stmf_i_scsi_session_t *iss;
1421         stmf_i_local_port_t *ilport;
1422         stmf_lun_map_t *vemap, *vemap_alltgt;
1423         uint8_t grpname_forall = '*';
1424 
1425         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1426         ASSERT(grpname[0] != '*');
1427 
1428         if (entry_type == STMF_ID_TYPE_HOST) {
1429                 id_grp = stmf_lookup_id(&stmf_state.stmf_hg_list,
1430                     grpname_size, grpname);
1431                 id_grp_tmp = stmf_lookup_group_for_host(entry_ident,
1432                     entry_size);
1433         } else {
1434                 id_grp = stmf_lookup_id(&stmf_state.stmf_tg_list,
1435                     grpname_size, grpname);
1436                 id_grp_tmp = stmf_lookup_group_for_target(entry_ident,
1437                     entry_size);
1438         }
1439         if (id_grp == NULL) {
1440                 *err_detail = (entry_type == STMF_ID_TYPE_HOST)?
1441                     STMF_IOCERR_INVALID_HG:STMF_IOCERR_INVALID_TG;
1442                 return (ENODEV); /* not found */
1443         }
1444 
1445         /* Check whether this member already bound to a group */
1446         if (id_grp_tmp) {
1447                 if (id_grp_tmp != id_grp) {
1448                         *err_detail = (entry_type == STMF_ID_TYPE_HOST)?
1449                             STMF_IOCERR_HG_ENTRY_EXISTS:
1450                             STMF_IOCERR_TG_ENTRY_EXISTS;
1451                         return (EEXIST); /* already added into another grp */
1452                 }
1453                 else
1454                         return (0);
1455         }
1456 
1457         /* verify target is offline */
1458         if (entry_type == STMF_ID_TYPE_TARGET) {
1459                 ilport = stmf_targetident_to_ilport(entry_ident, entry_size);
1460                 if (ilport && ilport->ilport_state != STMF_STATE_OFFLINE) {
1461                         *err_detail = STMF_IOCERR_TG_NEED_TG_OFFLINE;
1462                         return (EBUSY);
1463                 }
1464         }
1465 
1466         id_member = stmf_alloc_id(entry_size, entry_type,
1467             entry_ident, 0);
1468         stmf_append_id((stmf_id_list_t *)id_grp->id_impl_specific, id_member);
1469 
1470         if (entry_type == STMF_ID_TYPE_TARGET) {
1471                 ilport = stmf_targetident_to_ilport(entry_ident, entry_size);
1472                 if (ilport)
1473                         ilport->ilport_tg = (void *)id_grp;
1474                 return (0);
1475         }
1476         /* For host group member, update the session if needed */
1477         if (!stmf_state.stmf_service_running)
1478                 return (0);
1479         /* Need to consider all target group + this host group */
1480         id_alltgt = stmf_lookup_id(&stmf_state.stmf_tg_list,
1481             1, &grpname_forall);
1482         vemap_alltgt = stmf_get_ve_map_per_ids(id_alltgt, id_grp);
1483 
1484         /* check whether there are sessions may be affected */
1485         for (ilport = stmf_state.stmf_ilportlist; ilport;
1486             ilport = ilport->ilport_next) {
1487                 if (ilport->ilport_state != STMF_STATE_ONLINE)
1488                         continue;
1489                 iss = stmf_lookup_session_for_hostident(ilport,
1490                     entry_ident, entry_size);
1491                 if (iss) {
1492                         stmf_id_data_t *tgid;
1493                         iss->iss_hg = (void *)id_grp;
1494                         tgid = ilport->ilport_tg;
1495                         if (tgid) {
1496                                 vemap = stmf_get_ve_map_per_ids(tgid, id_grp);
1497                                 if (vemap)
1498                                         stmf_add_lus_to_session_per_vemap(
1499                                             ilport, iss, vemap);
1500                         }
1501                         if (vemap_alltgt)
1502                                 stmf_add_lus_to_session_per_vemap(ilport,
1503                                     iss, vemap_alltgt);
1504                 }
1505         }
1506 
1507         return (0);
1508 }
1509 
1510 int
1511 stmf_remove_group_member(uint8_t *grpname, uint16_t grpname_size,
1512                 uint8_t *entry_ident, uint16_t entry_size,
1513                 stmf_id_type_t entry_type, uint32_t *err_detail)
1514 {
1515         stmf_id_data_t  *id_grp, *id_alltgt;
1516         stmf_id_data_t  *id_member;
1517         stmf_lun_map_t *vemap,  *vemap_alltgt;
1518         uint8_t grpname_forall = '*';
1519         stmf_i_local_port_t *ilport;
1520         stmf_i_scsi_session_t *iss;
1521 
1522         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1523         ASSERT(grpname[0] != '*');
1524 
1525         if (entry_type == STMF_ID_TYPE_HOST) {
1526                 id_grp = stmf_lookup_id(&stmf_state.stmf_hg_list,
1527                     grpname_size, grpname);
1528         } else {
1529                 id_grp = stmf_lookup_id(&stmf_state.stmf_tg_list,
1530                     grpname_size, grpname);
1531         }
1532         if (id_grp == NULL) {
1533                 *err_detail = (entry_type == STMF_ID_TYPE_HOST)?
1534                     STMF_IOCERR_INVALID_HG:STMF_IOCERR_INVALID_TG;
1535                 return (ENODEV); /* no such group */
1536         }
1537         id_member = stmf_lookup_id((stmf_id_list_t *)id_grp->id_impl_specific,
1538             entry_size, entry_ident);
1539         if (!id_member) {
1540                 *err_detail = (entry_type == STMF_ID_TYPE_HOST)?
1541                     STMF_IOCERR_INVALID_HG_ENTRY:STMF_IOCERR_INVALID_TG_ENTRY;
1542                 return (ENODEV); /* no such member */
1543         }
1544         /* verify target is offline */
1545         if (entry_type == STMF_ID_TYPE_TARGET) {
1546                 ilport = stmf_targetident_to_ilport(entry_ident, entry_size);
1547                 if (ilport && ilport->ilport_state != STMF_STATE_OFFLINE) {
1548                         *err_detail = STMF_IOCERR_TG_NEED_TG_OFFLINE;
1549                         return (EBUSY);
1550                 }
1551         }
1552 
1553         stmf_remove_id((stmf_id_list_t *)id_grp->id_impl_specific, id_member);
1554         stmf_free_id(id_member);
1555 
1556         if (entry_type == STMF_ID_TYPE_TARGET) {
1557                 ilport = stmf_targetident_to_ilport(entry_ident, entry_size);
1558                 if (ilport)
1559                         ilport->ilport_tg = NULL;
1560                 return (0);
1561         }
1562         /* For host group member, update the session */
1563         if (!stmf_state.stmf_service_running)
1564                 return (0);
1565 
1566         /* Need to consider all target group + this host group */
1567         id_alltgt = stmf_lookup_id(&stmf_state.stmf_tg_list,
1568             1, &grpname_forall);
1569         vemap_alltgt = stmf_get_ve_map_per_ids(id_alltgt, id_grp);
1570 
1571         /* check if there are session related, if so, update it */
1572         for (ilport = stmf_state.stmf_ilportlist; ilport;
1573             ilport = ilport->ilport_next) {
1574                 if (ilport->ilport_state != STMF_STATE_ONLINE)
1575                         continue;
1576                 iss = stmf_lookup_session_for_hostident(ilport,
1577                     entry_ident, entry_size);
1578                 if (iss) {
1579                         stmf_id_data_t *tgid;
1580                         iss->iss_hg = NULL;
1581                         tgid = ilport->ilport_tg;
1582                         if (tgid) {
1583                                 vemap = stmf_get_ve_map_per_ids(tgid, id_grp);
1584                                 if (vemap)
1585                                         stmf_remove_lus_from_session_per_vemap(
1586                                             ilport, iss, vemap);
1587                         }
1588                         if (vemap_alltgt)
1589                                 stmf_remove_lus_from_session_per_vemap(ilport,
1590                                     iss, vemap_alltgt);
1591                 }
1592         }
1593 
1594         return (0);
1595 }
1596 
1597 /* Assert stmf_lock is already held */
1598 stmf_i_local_port_t *
1599 stmf_targetident_to_ilport(uint8_t *target_ident, uint16_t ident_size)
1600 {
1601         stmf_i_local_port_t *ilport;
1602         uint8_t *id;
1603 
1604         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1605 
1606         for (ilport = stmf_state.stmf_ilportlist; ilport;
1607             ilport = ilport->ilport_next) {
1608                 id = (uint8_t *)ilport->ilport_lport->lport_id;
1609                 if ((id[3] == ident_size) &&
1610                     bcmp(id + 4, target_ident, ident_size) == 0) {
1611                         return (ilport);
1612                 }
1613         }
1614         return (NULL);
1615 }
1616 
1617 stmf_i_scsi_session_t *
1618 stmf_lookup_session_for_hostident(stmf_i_local_port_t *ilport,
1619                 uint8_t *host_ident, uint16_t ident_size)
1620 {
1621         stmf_i_scsi_session_t *iss;
1622         uint8_t *id;
1623 
1624         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1625 
1626         for (iss = ilport->ilport_ss_list; iss; iss = iss->iss_next) {
1627                 id = (uint8_t *)iss->iss_ss->ss_rport_id;
1628                 if ((id[3] == ident_size) &&
1629                     bcmp(id + 4, host_ident, ident_size) == 0) {
1630                         return (iss);
1631                 }
1632         }
1633         return (NULL);
1634 }
1635 
1636 stmf_i_lu_t *
1637 stmf_luident_to_ilu(uint8_t *lu_ident)
1638 {
1639         stmf_i_lu_t *ilu;
1640 
1641         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1642 
1643         for (ilu = stmf_state.stmf_ilulist; ilu; ilu = ilu->ilu_next) {
1644                 if (bcmp(&ilu->ilu_lu->lu_id->ident[0], lu_ident, 16) == 0)
1645                         return (ilu);
1646         }
1647 
1648         return (NULL);
1649 }
1650 
1651 /*
1652  * Assert stmf_lock is already held,
1653  * Just get the view map for the specific target group and host group
1654  * tgid and hgid can not be NULL
1655  */
1656 stmf_lun_map_t *
1657 stmf_get_ve_map_per_ids(stmf_id_data_t *tgid, stmf_id_data_t *hgid)
1658 {
1659         int found = 0;
1660         stmf_ver_tg_t *vertg;
1661         stmf_ver_hg_t *verhg;
1662 
1663         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1664 
1665         for (vertg = stmf_state.stmf_ver_tg_head;
1666             vertg; vertg = vertg->vert_next) {
1667                 if (vertg->vert_tg_ref == tgid) {
1668                         found = 1;
1669                         break;
1670                 }
1671         }
1672         if (!found)
1673                 return (NULL);
1674 
1675         for (verhg = vertg->vert_verh_list; verhg; verhg = verhg->verh_next) {
1676                 if (verhg->verh_hg_ref == hgid) {
1677                         return (&verhg->verh_ve_map);
1678                 }
1679         }
1680         return (NULL);
1681 }
1682 
1683 stmf_status_t
1684 stmf_validate_lun_view_entry(stmf_id_data_t *hg, stmf_id_data_t *tg,
1685     uint8_t *lun, uint32_t *err_detail)
1686 {
1687         char                    *phg, *ptg;
1688         stmf_lun_map_t          *ve_map = NULL;
1689         stmf_ver_hg_t           *verhg = NULL;
1690         stmf_ver_tg_t           *vertg = NULL;
1691         uint16_t                lun_num;
1692         stmf_status_t           ret = STMF_SUCCESS;
1693 
1694         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1695 
1696         ve_map = stmf_duplicate_ve_map(0);
1697         for (vertg = stmf_state.stmf_ver_tg_head; vertg != NULL;
1698             vertg = vertg->vert_next) {
1699                 ptg = (char *)vertg->vert_tg_ref->id_data;
1700                 if ((ptg[0] != '*') && (tg->id_data[0] != '*') &&
1701                     (vertg->vert_tg_ref != tg)) {
1702                         continue;
1703                 }
1704                 for (verhg = vertg->vert_verh_list; verhg != NULL;
1705                     verhg = verhg->verh_next) {
1706                         phg = (char *)verhg->verh_hg_ref->id_data;
1707                         if ((phg[0] != '*') && (hg->id_data[0] != '*') &&
1708                             (verhg->verh_hg_ref != hg)) {
1709                                 continue;
1710                         }
1711                         (void) stmf_merge_ve_map(&verhg->verh_ve_map, ve_map,
1712                             &ve_map, 0);
1713                 }
1714         }
1715 
1716         ret = STMF_SUCCESS;
1717         /* Return an available lun number */
1718         if (lun[2] == 0xFF) {
1719                 /* Pick a LUN number */
1720                 lun_num = stmf_get_next_free_lun(ve_map, lun);
1721                 if (lun_num > 0x3FFF)
1722                         ret = STMF_NOT_SUPPORTED;
1723         } else {
1724                 lun_num = (uint16_t)lun[1] | (((uint16_t)(lun[0] & 0x3F)) << 8);
1725                 if (stmf_get_ent_from_map(ve_map, lun_num) != NULL) {
1726                         *err_detail = STMF_IOCERR_LU_NUMBER_IN_USE;
1727                         ret = STMF_LUN_TAKEN;
1728                 }
1729         }
1730         stmf_destroy_ve_map(ve_map);
1731 
1732         return (ret);
1733 }
1734 
1735 int
1736 stmf_validate_lun_ve(uint8_t *hgname, uint16_t hgname_size,
1737                 uint8_t *tgname, uint16_t tgname_size,
1738                 uint8_t *luNbr, uint32_t *err_detail)
1739 {
1740         stmf_id_data_t          *hg;
1741         stmf_id_data_t          *tg;
1742         stmf_status_t           ret;
1743 
1744         ASSERT(mutex_owned(&stmf_state.stmf_lock));
1745 
1746         hg = stmf_lookup_id(&stmf_state.stmf_hg_list, hgname_size,
1747             (uint8_t *)hgname);
1748         if (!hg) {
1749                 *err_detail = STMF_IOCERR_INVALID_HG;
1750                 return (ENOENT); /* could not find group */
1751         }
1752         tg = stmf_lookup_id(&stmf_state.stmf_tg_list, tgname_size,
1753             (uint8_t *)tgname);
1754         if (!tg) {
1755                 *err_detail = STMF_IOCERR_INVALID_TG;
1756                 return (ENOENT); /* could not find group */
1757         }
1758         ret = stmf_validate_lun_view_entry(hg, tg, luNbr, err_detail);
1759 
1760         if (ret == STMF_LUN_TAKEN) {
1761                 return (EEXIST);
1762         } else if (ret == STMF_NOT_SUPPORTED) {
1763                 return (E2BIG);
1764         } else if (ret != STMF_SUCCESS) {
1765                 return (EINVAL);
1766         }
1767         return (0);
1768 }
--- EOF ---