contrib/ofed/opensm/opensm/osm_sa_service_record.c

   1 /*
   2  * Copyright (c) 2004-2009 Voltaire, Inc. All rights reserved.
   3  * Copyright (c) 2002-2011 Mellanox Technologies LTD. All rights reserved.
   4  * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.
   5  * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.
   6  *
   7  * This software is available to you under a choice of one of two
   8  * licenses.  You may choose to be licensed under the terms of the GNU
   9  * General Public License (GPL) Version 2, available from the file
  10  * COPYING in the main directory of this source tree, or the
  11  * OpenIB.org BSD license below:
  12  *
  13  *     Redistribution and use in source and binary forms, with or
  14  *     without modification, are permitted provided that the following
  15  *     conditions are met:
  16  *
  17  *      - Redistributions of source code must retain the above
  18  *        copyright notice, this list of conditions and the following
  19  *        disclaimer.
  20  *
  21  *      - Redistributions in binary form must reproduce the above
  22  *        copyright notice, this list of conditions and the following
  23  *        disclaimer in the documentation and/or other materials
  24  *        provided with the distribution.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  30  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  31  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  32  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  33  * SOFTWARE.
  34  *
  35  */
  36
  37 /*
  38  * Abstract:
  39  *    Implementation of osm_sr_rcv_t.
  40  * This object represents the ServiceRecord Receiver object.
  41  * This object is part of the opensm family of objects.
  42  */
  43
  44 #if HAVE_CONFIG_H
  45 #  include <config.h>
  46 #endif                          /* HAVE_CONFIG_H */
  47
  48 #include <string.h>
  49 #include <iba/ib_types.h>
  50 #include <complib/cl_qmap.h>
  51 #include <complib/cl_passivelock.h>
  52 #include <complib/cl_debug.h>
  53 #include <complib/cl_qlist.h>
  54 #include <opensm/osm_file_ids.h>
  55 #define FILE_ID OSM_FILE_SA_SERVICE_RECORD_C
  56 #include <vendor/osm_vendor_api.h>
  57 #include <opensm/osm_port.h>
  58 #include <opensm/osm_node.h>
  59 #include <opensm/osm_switch.h>
  60 #include <opensm/osm_helper.h>
  61 #include <opensm/osm_sa.h>
  62 #include <opensm/osm_service.h>
  63 #include <opensm/osm_pkey.h>
  64
  65 #define SA_SR_RESP_SIZE SA_ITEM_RESP_SIZE(service_rec)
  66
  67 typedef struct osm_sr_match_item {
  68         cl_qlist_t sr_list;
  69         ib_service_record_t *p_service_rec;
  70         ib_net64_t comp_mask;
  71         osm_sa_t *sa;
  72 } osm_sr_match_item_t;
  73
  74 typedef struct osm_sr_search_ctxt {
  75         osm_sr_match_item_t *p_sr_item;
  76         const osm_physp_t *p_req_physp;
  77 } osm_sr_search_ctxt_t;
  78
  79 static boolean_t
  80 match_service_pkey_with_ports_pkey(IN osm_sa_t * sa,
  81                                    IN const osm_madw_t * p_madw,
  82                                    ib_service_record_t * p_service_rec,
  83                                    ib_net64_t const comp_mask)
  84 {
  85         boolean_t valid = TRUE;
  86         osm_physp_t *p_req_physp;
  87         ib_net64_t service_guid;
  88         osm_port_t *service_port;
  89
  90         /* update the requester physical port */
  91         p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
  92                                                 osm_madw_get_mad_addr_ptr
  93                                                 (p_madw));
  94         if (p_req_physp == NULL) {
  95                 OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2404: "
  96                         "Cannot find requester physical port\n");
  97                 valid = FALSE;
  98                 goto Exit;
  99         }
 100         OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 101                 "Requester port GUID 0x%" PRIx64 "\n",
 102                 cl_ntoh64(osm_physp_get_port_guid(p_req_physp)));
 103
 104         if ((comp_mask & IB_SR_COMPMASK_SPKEY) == IB_SR_COMPMASK_SPKEY) {
 105                 /* We have a ServiceP_Key - check matching on requester port,
 106                    and ServiceGid port (if such exists) */
 107                 /* Make sure it matches the p_req_physp */
 108                 if (!osm_physp_has_pkey
 109                     (sa->p_log, p_service_rec->service_pkey, p_req_physp)) {
 110                         valid = FALSE;
 111                         goto Exit;
 112                 }
 113
 114                 /* If unicast, make sure it matches the port of the ServiceGid */
 115                 if (comp_mask & IB_SR_COMPMASK_SGID &&
 116                     !ib_gid_is_multicast(&p_service_rec->service_gid)) {
 117                         service_guid =
 118                             p_service_rec->service_gid.unicast.interface_id;
 119                         service_port =
 120                             osm_get_port_by_alias_guid(sa->p_subn, service_guid);
 121                         if (!service_port) {
 122                                 OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2405: "
 123                                         "No port object for port 0x%016" PRIx64
 124                                         "\n", cl_ntoh64(service_guid));
 125                                 valid = FALSE;
 126                                 goto Exit;
 127                         }
 128                         /* check on the table of the default physical port of the service port */
 129                         if (!osm_physp_has_pkey(sa->p_log,
 130                                                 p_service_rec->service_pkey,
 131                                                 service_port->p_physp)) {
 132                                 valid = FALSE;
 133                                 goto Exit;
 134                         }
 135                 }
 136         }
 137
 138 Exit:
 139         return valid;
 140 }
 141
 142 static boolean_t
 143 match_name_to_key_association(IN osm_sa_t * sa,
 144                               ib_service_record_t * p_service_rec,
 145                               ib_net64_t comp_mask)
 146 {
 147         UNUSED_PARAM(p_service_rec);
 148         UNUSED_PARAM(sa);
 149
 150         if ((comp_mask & (IB_SR_COMPMASK_SKEY | IB_SR_COMPMASK_SNAME)) ==
 151             (IB_SR_COMPMASK_SKEY | IB_SR_COMPMASK_SNAME)) {
 152                 /* For now, we are not maintaining the ServiceAssociation record
 153                  * so just return TRUE
 154                  */
 155                 return TRUE;
 156         }
 157
 158         return TRUE;
 159 }
 160
 161 static boolean_t validate_sr(IN osm_sa_t * sa, IN const osm_madw_t * p_madw)
 162 {
 163         boolean_t valid = TRUE;
 164         ib_sa_mad_t *p_sa_mad;
 165         ib_service_record_t *p_recvd_service_rec;
 166
 167         OSM_LOG_ENTER(sa->p_log);
 168
 169         p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
 170         p_recvd_service_rec =
 171             (ib_service_record_t *) ib_sa_mad_get_payload_ptr(p_sa_mad);
 172
 173         valid = match_service_pkey_with_ports_pkey(sa, p_madw,
 174                                                    p_recvd_service_rec,
 175                                                    p_sa_mad->comp_mask);
 176         if (!valid) {
 177                 OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 178                         "No Match for Service Pkey\n");
 179                 valid = FALSE;
 180                 goto Exit;
 181         }
 182
 183         valid = match_name_to_key_association(sa, p_recvd_service_rec,
 184                                               p_sa_mad->comp_mask);
 185         if (!valid) {
 186                 OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 187                         "Service Record Name to key matching failed\n");
 188                 valid = FALSE;
 189                 goto Exit;
 190         }
 191
 192 Exit:
 193         OSM_LOG_EXIT(sa->p_log);
 194         return valid;
 195 }
 196
 197 static void sr_rcv_respond(IN osm_sa_t * sa, IN osm_madw_t * p_madw,
 198                            IN cl_qlist_t * p_list)
 199 {
 200         /* p923 - The ServiceKey shall be set to 0, except in the case of
 201            a trusted request.
 202            Note: In the mad controller we check that the SM_Key received on
 203            the mad is valid. Meaning - is either zero or equal to the local
 204            sm_key.
 205          */
 206         if (!osm_madw_get_sa_mad_ptr(p_madw)->sm_key) {
 207                 osm_sa_item_t *item;
 208                 for (item = (osm_sa_item_t *) cl_qlist_head(p_list);
 209                      item != (osm_sa_item_t *) cl_qlist_end(p_list);
 210                      item = (osm_sa_item_t *) cl_qlist_next(&item->list_item))
 211                         memset(item->resp.service_rec.service_key, 0,
 212                                sizeof(item->resp.service_rec.service_key));
 213         }
 214
 215         osm_sa_respond(sa, p_madw, sizeof(ib_service_record_t), p_list);
 216 }
 217
 218 static void get_matching_sr(IN cl_list_item_t * p_list_item, IN void *context)
 219 {
 220         osm_sr_search_ctxt_t *p_ctxt = context;
 221         osm_svcr_t *p_svcr = (osm_svcr_t *) p_list_item;
 222         osm_sa_item_t *p_sr_pool_item;
 223         osm_sr_match_item_t *p_sr_item = p_ctxt->p_sr_item;
 224         ib_net64_t comp_mask = p_sr_item->comp_mask;
 225         const osm_physp_t *p_req_physp = p_ctxt->p_req_physp;
 226
 227         if (comp_mask & IB_SR_COMPMASK_SID) {
 228                 if (p_sr_item->p_service_rec->service_id !=
 229                     p_svcr->service_record.service_id)
 230                         return;
 231         }
 232         if (comp_mask & IB_SR_COMPMASK_SGID) {
 233                 if (memcmp(&p_sr_item->p_service_rec->service_gid,
 234                            &p_svcr->service_record.service_gid,
 235                            sizeof(p_svcr->service_record.service_gid)) != 0)
 236                         return;
 237         }
 238         if (comp_mask & IB_SR_COMPMASK_SPKEY) {
 239                 if (p_sr_item->p_service_rec->service_pkey !=
 240                     p_svcr->service_record.service_pkey)
 241                         return;
 242         }
 243
 244         if (comp_mask & IB_SR_COMPMASK_SKEY) {
 245                 if (memcmp(p_sr_item->p_service_rec->service_key,
 246                            p_svcr->service_record.service_key,
 247                            16 * sizeof(uint8_t)))
 248                         return;
 249         }
 250         if (comp_mask & IB_SR_COMPMASK_SNAME) {
 251                 if (memcmp(p_sr_item->p_service_rec->service_name,
 252                            p_svcr->service_record.service_name,
 253                            sizeof(p_svcr->service_record.service_name)) != 0)
 254                         return;
 255         }
 256         if (comp_mask & IB_SR_COMPMASK_SDATA8_0) {
 257                 if (p_sr_item->p_service_rec->service_data8[0] !=
 258                     p_svcr->service_record.service_data8[0])
 259                         return;
 260         }
 261
 262         if (comp_mask & IB_SR_COMPMASK_SDATA8_1) {
 263                 if (p_sr_item->p_service_rec->service_data8[1] !=
 264                     p_svcr->service_record.service_data8[1])
 265                         return;
 266         }
 267         if (comp_mask & IB_SR_COMPMASK_SDATA8_2) {
 268                 if (p_sr_item->p_service_rec->service_data8[2] !=
 269                     p_svcr->service_record.service_data8[2])
 270                         return;
 271         }
 272         if (comp_mask & IB_SR_COMPMASK_SDATA8_3) {
 273                 if (p_sr_item->p_service_rec->service_data8[3] !=
 274                     p_svcr->service_record.service_data8[3])
 275                         return;
 276         }
 277         if (comp_mask & IB_SR_COMPMASK_SDATA8_4) {
 278                 if (p_sr_item->p_service_rec->service_data8[4] !=
 279                     p_svcr->service_record.service_data8[4])
 280                         return;
 281         }
 282         if (comp_mask & IB_SR_COMPMASK_SDATA8_5) {
 283                 if (p_sr_item->p_service_rec->service_data8[5] !=
 284                     p_svcr->service_record.service_data8[5])
 285                         return;
 286         }
 287         if (comp_mask & IB_SR_COMPMASK_SDATA8_6) {
 288                 if (p_sr_item->p_service_rec->service_data8[6] !=
 289                     p_svcr->service_record.service_data8[6])
 290                         return;
 291         }
 292
 293         if (comp_mask & IB_SR_COMPMASK_SDATA8_7) {
 294                 if (p_sr_item->p_service_rec->service_data8[7] !=
 295                     p_svcr->service_record.service_data8[7])
 296                         return;
 297         }
 298
 299         if (comp_mask & IB_SR_COMPMASK_SDATA8_8) {
 300                 if (p_sr_item->p_service_rec->service_data8[8] !=
 301                     p_svcr->service_record.service_data8[8])
 302                         return;
 303         }
 304
 305         if (comp_mask & IB_SR_COMPMASK_SDATA8_9) {
 306                 if (p_sr_item->p_service_rec->service_data8[9] !=
 307                     p_svcr->service_record.service_data8[9])
 308                         return;
 309         }
 310
 311         if (comp_mask & IB_SR_COMPMASK_SDATA8_10) {
 312                 if (p_sr_item->p_service_rec->service_data8[10] !=
 313                     p_svcr->service_record.service_data8[10])
 314                         return;
 315         }
 316
 317         if (comp_mask & IB_SR_COMPMASK_SDATA8_11) {
 318                 if (p_sr_item->p_service_rec->service_data8[11] !=
 319                     p_svcr->service_record.service_data8[11])
 320                         return;
 321         }
 322
 323         if (comp_mask & IB_SR_COMPMASK_SDATA8_12) {
 324                 if (p_sr_item->p_service_rec->service_data8[12] !=
 325                     p_svcr->service_record.service_data8[12])
 326                         return;
 327         }
 328         if (comp_mask & IB_SR_COMPMASK_SDATA8_13) {
 329                 if (p_sr_item->p_service_rec->service_data8[13] !=
 330                     p_svcr->service_record.service_data8[13])
 331                         return;
 332         }
 333         if (comp_mask & IB_SR_COMPMASK_SDATA8_14) {
 334                 if (p_sr_item->p_service_rec->service_data8[14] !=
 335                     p_svcr->service_record.service_data8[14])
 336                         return;
 337         }
 338         if (comp_mask & IB_SR_COMPMASK_SDATA8_15) {
 339                 if (p_sr_item->p_service_rec->service_data8[15] !=
 340                     p_svcr->service_record.service_data8[15])
 341                         return;
 342         }
 343         if (comp_mask & IB_SR_COMPMASK_SDATA16_0) {
 344                 if (p_sr_item->p_service_rec->service_data16[0] !=
 345                     p_svcr->service_record.service_data16[0])
 346                         return;
 347         }
 348         if (comp_mask & IB_SR_COMPMASK_SDATA16_1) {
 349                 if (p_sr_item->p_service_rec->service_data16[1] !=
 350                     p_svcr->service_record.service_data16[1])
 351                         return;
 352         }
 353         if (comp_mask & IB_SR_COMPMASK_SDATA16_2) {
 354                 if (p_sr_item->p_service_rec->service_data16[2] !=
 355                     p_svcr->service_record.service_data16[2])
 356                         return;
 357         }
 358         if (comp_mask & IB_SR_COMPMASK_SDATA16_3) {
 359                 if (p_sr_item->p_service_rec->service_data16[3] !=
 360                     p_svcr->service_record.service_data16[3])
 361                         return;
 362         }
 363         if (comp_mask & IB_SR_COMPMASK_SDATA16_4) {
 364                 if (p_sr_item->p_service_rec->service_data16[4] !=
 365                     p_svcr->service_record.service_data16[4])
 366                         return;
 367         }
 368         if (comp_mask & IB_SR_COMPMASK_SDATA16_5) {
 369                 if (p_sr_item->p_service_rec->service_data16[5] !=
 370                     p_svcr->service_record.service_data16[5])
 371                         return;
 372         }
 373         if (comp_mask & IB_SR_COMPMASK_SDATA16_6) {
 374                 if (p_sr_item->p_service_rec->service_data16[6] !=
 375                     p_svcr->service_record.service_data16[6])
 376                         return;
 377         }
 378         if (comp_mask & IB_SR_COMPMASK_SDATA16_7) {
 379                 if (p_sr_item->p_service_rec->service_data16[7] !=
 380                     p_svcr->service_record.service_data16[7])
 381                         return;
 382         }
 383         if (comp_mask & IB_SR_COMPMASK_SDATA32_0) {
 384                 if (p_sr_item->p_service_rec->service_data32[0] !=
 385                     p_svcr->service_record.service_data32[0])
 386                         return;
 387         }
 388         if (comp_mask & IB_SR_COMPMASK_SDATA32_1) {
 389                 if (p_sr_item->p_service_rec->service_data32[1] !=
 390                     p_svcr->service_record.service_data32[1])
 391                         return;
 392         }
 393         if (comp_mask & IB_SR_COMPMASK_SDATA32_2) {
 394                 if (p_sr_item->p_service_rec->service_data32[2] !=
 395                     p_svcr->service_record.service_data32[2])
 396                         return;
 397         }
 398         if (comp_mask & IB_SR_COMPMASK_SDATA32_3) {
 399                 if (p_sr_item->p_service_rec->service_data32[3] !=
 400                     p_svcr->service_record.service_data32[3])
 401                         return;
 402         }
 403
 404         if (comp_mask & IB_SR_COMPMASK_SDATA64_0) {
 405                 if (p_sr_item->p_service_rec->service_data64[0] !=
 406                     p_svcr->service_record.service_data64[0])
 407                         return;
 408         }
 409         if (comp_mask & IB_SR_COMPMASK_SDATA64_1) {
 410                 if (p_sr_item->p_service_rec->service_data64[1] !=
 411                     p_svcr->service_record.service_data64[1])
 412                         return;
 413         }
 414
 415         /* Check that the requester port has the pkey which is the service_pkey.
 416            If not - then it cannot receive this ServiceRecord. */
 417         /* The check is relevant only if the service_pkey is valid */
 418         if (!ib_pkey_is_invalid(p_svcr->service_record.service_pkey)) {
 419                 if (!osm_physp_has_pkey(p_sr_item->sa->p_log,
 420                                         p_svcr->service_record.service_pkey,
 421                                         p_req_physp)) {
 422                         OSM_LOG(p_sr_item->sa->p_log, OSM_LOG_VERBOSE,
 423                                 "requester port doesn't have the service_pkey: 0x%X\n",
 424                                 cl_ntoh16(p_svcr->service_record.service_pkey));
 425                         return;
 426                 }
 427         }
 428
 429         p_sr_pool_item = malloc(SA_SR_RESP_SIZE);
 430         if (p_sr_pool_item == NULL) {
 431                 OSM_LOG(p_sr_item->sa->p_log, OSM_LOG_ERROR, "ERR 2408: "
 432                         "Unable to acquire Service Record from pool\n");
 433                 goto Exit;
 434         }
 435
 436         p_sr_pool_item->resp.service_rec = p_svcr->service_record;
 437
 438         cl_qlist_insert_tail(&p_sr_item->sr_list, &p_sr_pool_item->list_item);
 439
 440 Exit:
 441         return;
 442 }
 443
 444 static void sr_rcv_process_get_method(osm_sa_t * sa, IN osm_madw_t * p_madw)
 445 {
 446         ib_sa_mad_t *p_sa_mad;
 447         ib_service_record_t *p_recvd_service_rec;
 448         osm_sr_match_item_t sr_match_item;
 449         osm_sr_search_ctxt_t context;
 450         osm_physp_t *p_req_physp;
 451
 452         OSM_LOG_ENTER(sa->p_log);
 453
 454         CL_ASSERT(p_madw);
 455
 456         /* Grab the lock */
 457         cl_plock_acquire(sa->p_lock);
 458
 459         /* update the requester physical port */
 460         p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
 461                                                 osm_madw_get_mad_addr_ptr
 462                                                 (p_madw));
 463         if (p_req_physp == NULL) {
 464                 cl_plock_release(sa->p_lock);
 465                 OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2409: "
 466                         "Cannot find requester physical port\n");
 467                 goto Exit;
 468         }
 469
 470         p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
 471         p_recvd_service_rec =
 472             (ib_service_record_t *) ib_sa_mad_get_payload_ptr(p_sa_mad);
 473
 474         if (OSM_LOG_IS_ACTIVE_V2(sa->p_log, OSM_LOG_DEBUG)) {
 475                 OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 476                         "Requester port GUID 0x%" PRIx64 "\n",
 477                         cl_ntoh64(osm_physp_get_port_guid(p_req_physp)));
 478                 osm_dump_service_record_v2(sa->p_log, p_recvd_service_rec,
 479                                            FILE_ID, OSM_LOG_DEBUG);
 480         }
 481
 482         cl_qlist_init(&sr_match_item.sr_list);
 483         sr_match_item.p_service_rec = p_recvd_service_rec;
 484         sr_match_item.comp_mask = p_sa_mad->comp_mask;
 485         sr_match_item.sa = sa;
 486
 487         context.p_sr_item = &sr_match_item;
 488         context.p_req_physp = p_req_physp;
 489
 490         cl_qlist_apply_func(&sa->p_subn->sa_sr_list, get_matching_sr, &context);
 491
 492         cl_plock_release(sa->p_lock);
 493
 494         if (p_sa_mad->method == IB_MAD_METHOD_GET &&
 495             cl_qlist_count(&sr_match_item.sr_list) == 0) {
 496                 OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 497                         "No records matched the Service Record query\n");
 498                 osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_NO_RECORDS);
 499                 goto Exit;
 500         }
 501
 502         sr_rcv_respond(sa, p_madw, &sr_match_item.sr_list);
 503
 504 Exit:
 505         OSM_LOG_EXIT(sa->p_log);
 506         return;
 507 }
 508
 509 static void sr_rcv_process_set_method(osm_sa_t * sa, IN osm_madw_t * p_madw)
 510 {
 511         ib_sa_mad_t *p_sa_mad;
 512         ib_service_record_t *p_recvd_service_rec;
 513         ib_net64_t comp_mask;
 514         osm_svcr_t *p_svcr;
 515         osm_sa_item_t *p_sr_item;
 516         cl_qlist_t sr_list;
 517
 518         OSM_LOG_ENTER(sa->p_log);
 519
 520         CL_ASSERT(p_madw);
 521
 522         p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
 523         p_recvd_service_rec =
 524             (ib_service_record_t *) ib_sa_mad_get_payload_ptr(p_sa_mad);
 525
 526         comp_mask = p_sa_mad->comp_mask;
 527
 528         if (OSM_LOG_IS_ACTIVE_V2(sa->p_log, OSM_LOG_DEBUG))
 529                 osm_dump_service_record_v2(sa->p_log, p_recvd_service_rec,
 530                                            FILE_ID, OSM_LOG_DEBUG);
 531
 532         if ((comp_mask & (IB_SR_COMPMASK_SID | IB_SR_COMPMASK_SGID)) !=
 533             (IB_SR_COMPMASK_SID | IB_SR_COMPMASK_SGID)) {
 534                 cl_plock_release(sa->p_lock);
 535                 OSM_LOG(sa->p_log, OSM_LOG_VERBOSE,
 536                         "Component Mask RID check failed for METHOD_SET\n");
 537                 osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_REQ_INVALID);
 538                 goto Exit;
 539         }
 540
 541         /* if we were not provided with a service lease make it infinite */
 542         if (!(comp_mask & IB_SR_COMPMASK_SLEASE)) {
 543                 OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 544                         "ServiceLease Component Mask not set - using infinite lease\n");
 545                 p_recvd_service_rec->service_lease = 0xFFFFFFFF;
 546         }
 547
 548         /* If Record exists with matching RID */
 549         p_svcr = osm_svcr_get_by_rid(sa->p_subn, sa->p_log,
 550                                      p_recvd_service_rec);
 551
 552         if (p_svcr == NULL) {
 553                 /* Create the instance of the osm_svcr_t object */
 554                 p_svcr = osm_svcr_new(p_recvd_service_rec);
 555                 if (p_svcr == NULL) {
 556                         cl_plock_release(sa->p_lock);
 557                         OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2411: "
 558                                 "Failed to create new service record\n");
 559
 560                         osm_sa_send_error(sa, p_madw,
 561                                           IB_SA_MAD_STATUS_NO_RESOURCES);
 562                         goto Exit;
 563                 }
 564
 565                 /* Add this new osm_svcr_t object to subnet object */
 566                 osm_svcr_insert_to_db(sa->p_subn, sa->p_log, p_svcr);
 567
 568         } else                  /* Update the old instance of the osm_svcr_t object */
 569                 osm_svcr_init(p_svcr, p_recvd_service_rec);
 570
 571         cl_plock_release(sa->p_lock);
 572
 573         if (p_recvd_service_rec->service_lease != 0xFFFFFFFF) {
 574 #if 0
 575                 cl_timer_trim(&sa->sr_timer,
 576                               p_recvd_service_rec->service_lease * 1000);
 577 #endif
 578                 /*  This was a bug since no check was made to see if too long */
 579                 /*  just make sure the timer works - get a call back within a second */
 580                 cl_timer_trim(&sa->sr_timer, 1000);
 581                 p_svcr->modified_time = cl_get_time_stamp_sec();
 582         }
 583
 584         p_sr_item = malloc(SA_SR_RESP_SIZE);
 585         if (p_sr_item == NULL) {
 586                 OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2412: "
 587                         "Unable to acquire Service record\n");
 588                 osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_NO_RESOURCES);
 589                 goto Exit;
 590         }
 591
 592         if ((comp_mask & IB_SR_COMPMASK_SPKEY) != IB_SR_COMPMASK_SPKEY)
 593                 /* Set the Default Service P_Key in the response */
 594                 p_recvd_service_rec->service_pkey = IB_DEFAULT_PKEY;
 595
 596         p_sr_item->resp.service_rec = *p_recvd_service_rec;
 597         cl_qlist_init(&sr_list);
 598
 599         cl_qlist_insert_tail(&sr_list, &p_sr_item->list_item);
 600
 601         sr_rcv_respond(sa, p_madw, &sr_list);
 602
 603 Exit:
 604         OSM_LOG_EXIT(sa->p_log);
 605 }
 606
 607 static void sr_rcv_process_delete_method(osm_sa_t * sa, IN osm_madw_t * p_madw)
 608 {
 609         ib_sa_mad_t *p_sa_mad;
 610         ib_service_record_t *p_recvd_service_rec;
 611         osm_svcr_t *p_svcr;
 612         osm_sa_item_t *p_sr_item;
 613         cl_qlist_t sr_list;
 614
 615         OSM_LOG_ENTER(sa->p_log);
 616
 617         CL_ASSERT(p_madw);
 618
 619         p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
 620         p_recvd_service_rec =
 621             (ib_service_record_t *) ib_sa_mad_get_payload_ptr(p_sa_mad);
 622
 623         if (OSM_LOG_IS_ACTIVE_V2(sa->p_log, OSM_LOG_DEBUG))
 624                 osm_dump_service_record_v2(sa->p_log, p_recvd_service_rec,
 625                                            FILE_ID, OSM_LOG_DEBUG);
 626
 627         /* If Record exists with matching RID */
 628         p_svcr = osm_svcr_get_by_rid(sa->p_subn, sa->p_log,
 629                                      p_recvd_service_rec);
 630
 631         if (p_svcr == NULL) {
 632                 cl_plock_release(sa->p_lock);
 633                 OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 634                         "No records matched the RID\n");
 635                 osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_NO_RECORDS);
 636                 goto Exit;
 637         }
 638
 639         osm_svcr_remove_from_db(sa->p_subn, sa->p_log, p_svcr);
 640         cl_plock_release(sa->p_lock);
 641
 642         p_sr_item = malloc(SA_SR_RESP_SIZE);
 643         if (p_sr_item == NULL) {
 644                 OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2413: "
 645                         "Unable to acquire Service record\n");
 646                 osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_NO_RESOURCES);
 647                 osm_svcr_delete(p_svcr);
 648                 goto Exit;
 649         }
 650
 651         /* provide back the copy of the record */
 652         p_sr_item->resp.service_rec = p_svcr->service_record;
 653         cl_qlist_init(&sr_list);
 654
 655         cl_qlist_insert_tail(&sr_list, &p_sr_item->list_item);
 656
 657         osm_svcr_delete(p_svcr);
 658
 659         sr_rcv_respond(sa, p_madw, &sr_list);
 660
 661 Exit:
 662         OSM_LOG_EXIT(sa->p_log);
 663         return;
 664 }
 665
 666 void osm_sr_rcv_process(IN void *context, IN void *data)
 667 {
 668         osm_sa_t *sa = context;
 669         osm_madw_t *p_madw = data;
 670         ib_sa_mad_t *p_sa_mad;
 671         boolean_t valid;
 672
 673         OSM_LOG_ENTER(sa->p_log);
 674
 675         CL_ASSERT(p_madw);
 676
 677         p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
 678
 679         CL_ASSERT(p_sa_mad->attr_id == IB_MAD_ATTR_SERVICE_RECORD);
 680
 681         switch (p_sa_mad->method) {
 682         case IB_MAD_METHOD_SET:
 683                 cl_plock_excl_acquire(sa->p_lock);
 684                 valid = validate_sr(sa, p_madw);
 685                 if (!valid) {
 686                         cl_plock_release(sa->p_lock);
 687                         OSM_LOG(sa->p_log, OSM_LOG_VERBOSE,
 688                                 "Component Mask check failed for set request\n");
 689                         osm_sa_send_error(sa, p_madw,
 690                                           IB_SA_MAD_STATUS_REQ_INVALID);
 691                         goto Exit;
 692                 }
 693                 sr_rcv_process_set_method(sa, p_madw);
 694                 break;
 695         case IB_MAD_METHOD_DELETE:
 696                 cl_plock_excl_acquire(sa->p_lock);
 697                 valid = validate_sr(sa, p_madw);
 698                 if (!valid) {
 699                         cl_plock_release(sa->p_lock);
 700                         OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 701                                 "Component Mask check failed for delete request\n");
 702                         osm_sa_send_error(sa, p_madw,
 703                                           IB_SA_MAD_STATUS_REQ_INVALID);
 704                         goto Exit;
 705                 }
 706                 sr_rcv_process_delete_method(sa, p_madw);
 707                 break;
 708         case IB_MAD_METHOD_GET:
 709         case IB_MAD_METHOD_GETTABLE:
 710                 sr_rcv_process_get_method(sa, p_madw);
 711                 break;
 712         default:
 713                 OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 714                         "Unsupported Method (%s) for ServiceRecord request\n",
 715                         ib_get_sa_method_str(p_sa_mad->method));
 716                 osm_sa_send_error(sa, p_madw, IB_MAD_STATUS_UNSUP_METHOD_ATTR);
 717                 break;
 718         }
 719
 720 Exit:
 721         OSM_LOG_EXIT(sa->p_log);
 722 }
 723
 724 void osm_sr_rcv_lease_cb(IN void *context)
 725 {
 726         osm_sa_t *sa = context;
 727         cl_list_item_t *p_list_item;
 728         cl_list_item_t *p_next_list_item;
 729         osm_svcr_t *p_svcr;
 730         uint32_t curr_time;
 731         uint32_t elapsed_time;
 732         uint32_t trim_time = 20;        /*  maxiaml timer refresh is 20 seconds */
 733
 734         OSM_LOG_ENTER(sa->p_log);
 735
 736         cl_plock_excl_acquire(sa->p_lock);
 737
 738         p_list_item = cl_qlist_head(&sa->p_subn->sa_sr_list);
 739
 740         while (p_list_item != cl_qlist_end(&sa->p_subn->sa_sr_list)) {
 741                 p_svcr = (osm_svcr_t *) p_list_item;
 742
 743                 if (p_svcr->service_record.service_lease == 0xFFFFFFFF) {
 744                         p_list_item = cl_qlist_next(p_list_item);
 745                         continue;
 746                 }
 747
 748                 /* current time in seconds */
 749                 curr_time = cl_get_time_stamp_sec();
 750                 /* elapsed time from last modify */
 751                 elapsed_time = curr_time - p_svcr->modified_time;
 752                 /* but it can not be less then 1 */
 753                 if (elapsed_time < 1)
 754                         elapsed_time = 1;
 755
 756                 if (elapsed_time < p_svcr->lease_period) {
 757                         /*
 758                            Just update the service lease period
 759                            note: for simplicity we work with a uint32_t field
 760                            external to the network order lease_period of the MAD
 761                          */
 762                         p_svcr->lease_period -= elapsed_time;
 763
 764                         OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
 765                                 "Remaining time for Service Name:%s is:0x%X\n",
 766                                 p_svcr->service_record.service_name,
 767                                 p_svcr->lease_period);
 768
 769                         p_svcr->modified_time = curr_time;
 770
 771                         /* Update the trim timer */
 772                         if (trim_time > p_svcr->lease_period) {
 773                                 trim_time = p_svcr->lease_period;
 774                                 if (trim_time < 1)
 775                                         trim_time = 1;
 776                         }
 777
 778                         p_list_item = cl_qlist_next(p_list_item);
 779                         continue;
 780
 781                 } else {
 782                         p_next_list_item = cl_qlist_next(p_list_item);
 783
 784                         /* Remove the service Record */
 785                         osm_svcr_remove_from_db(sa->p_subn, sa->p_log, p_svcr);
 786
 787                         osm_svcr_delete(p_svcr);
 788
 789                         p_list_item = p_next_list_item;
 790                         continue;
 791                 }
 792         }
 793
 794         /* Release the Lock */
 795         cl_plock_release(sa->p_lock);
 796
 797         if (trim_time != 0xFFFFFFFF) {
 798                 cl_timer_trim(&sa->sr_timer, trim_time * 1000); /* Convert to milli seconds */
 799         }
 800
 801         OSM_LOG_EXIT(sa->p_log);
 802 }