bool dn_cache_init_fan_tray(void) { uint_t slot, n; cps_api_key_t key[1]; pas_entity_t *parent; pas_fan_tray_t *data; for (slot = 1, n = sdi_entity_count_get(SDI_ENTITY_FAN_TRAY); n; --n, ++slot ) { cps_api_key_init(key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_ENTITY_OBJ, 2, PLATFORM_ENTITY_TYPE_FAN_TRAY, slot ); parent = dn_pas_res_get(key); if (parent == 0) { return (false); } cps_api_key_init(key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_FAN_TRAY_OBJ, 1, slot ); data = CALLOC_T(pas_fan_tray_t, 1); if (data == 0) { return (false); } data->parent = parent; if (!dn_pas_res_insert(key, data)) { free(data); return (false); } } return (true); }
void dn_led_res_key_name( char *buf, unsigned bufsize, uint_t entity_type, uint_t slot, char *led_name, unsigned led_name_len ) { cps_api_key_t key[1]; uint_t n; cps_api_key_init(key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_LED_OBJ, 2, entity_type, slot ); cps_api_key_print(key, buf, bufsize); n = strlen(buf); memcpy(buf + n, led_name, led_name_len); buf[n + led_name_len] = 0; }
void dn_cache_del_led(pas_entity_t *parent) { char ckey[PAS_CPS_KEY_STR_LEN]; cps_api_key_t cps_key[1]; uint_t led_idx; pas_led_t *rec; for (led_idx = 1; led_idx <= parent->num_leds; ++led_idx) { cps_api_key_init(cps_key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_LED_OBJ, 3, parent->entity_type, parent->slot, led_idx ); rec = dn_pas_res_remove(cps_key); dn_led_res_key_name(ckey, sizeof(ckey), parent->entity_type, parent->slot, rec->name, rec->name_len ); dn_pas_res_removec(ckey); free(rec); } }
t_std_error ds_api_linux_route_init(cps_api_operation_handle_t handle) { cps_api_registration_functions_t f; memset(&f,0,sizeof(f)); f.handle = handle; f._read_function = db_read_function; f._write_function = _write_function; cps_api_key_init(&f.key,cps_api_qualifier_TARGET,cps_api_obj_cat_ROUTE,cps_api_route_obj_ROUTE,0); cps_api_return_code_t rc = cps_api_register(&f); if (rc!=cps_api_ret_code_OK) { return STD_ERR(INTERFACE,FAIL,rc); } f._read_function = NULL; cps_api_key_init(&f.key,cps_api_qualifier_TARGET,cps_api_obj_cat_ROUTE,cps_api_route_obj_EVENT,0); rc = cps_api_register(&f); return STD_ERR_OK_IF_TRUE(rc==cps_api_ret_code_OK,STD_ERR(INTERFACE,FAIL,rc)); }
t_std_error ds_api_linux_interface_init(cps_api_operation_handle_t handle) { cps_api_registration_functions_t f; memset(&f,0,sizeof(f)); f.handle = handle; f._read_function = ds_api_linux_interface_get_function; f._write_function = ds_api_linux_interface_set_function; cps_api_key_init(&f.key,cps_api_qualifier_TARGET,cps_api_obj_cat_INTERFACE,0,0); cps_api_return_code_t rc = cps_api_register(&f); return STD_ERR_OK_IF_TRUE(rc==cps_api_ret_code_OK,STD_ERR(INTERFACE,FAIL,rc)); }
void key_add(size_t *_k_data, size_t pos, size_t mx) { if (pos >= 5) return; for (int a = 0, _a = 10; a < _a ; ++a ) { _k_data[pos] = a; key_add(_k_data,pos+1,mx); if ((pos+1) == 4) { cps_api_key_t *key = (cps_api_key_t*)calloc(1,sizeof(cps_api_key_t)); cps_api_key_init(key,(cps_api_qualifier_t)(_k_data[0]+1),_k_data[1]+1,_k_data[2]+1,2,_k_data[3],_k_data[4]); char b1[100]; printf("Adding for test.. %s\n",cps_api_key_print(key,b1,sizeof(b1))); lst.push_back(key); } } }
static cps_api_return_code_t db_read_function (void * context, cps_api_get_params_t * param, size_t key_ix) { cps_api_return_code_t rc = cps_api_ret_code_OK; cps_api_key_t key; cps_api_key_init(&key,cps_api_qualifier_TARGET, cps_api_obj_cat_ROUTE, cps_api_route_obj_ROUTE, 0); if (cps_api_key_matches(¶m->keys[key_ix], &key,false)!=0) { return cps_api_ret_code_OK; } route_filter_t rf; memset(&rf,0,sizeof(rf)); //!TODO need to handle the filter requests (using the received key) read_all_routes(param->list,&rf); return rc; }
pas_led_t *dn_pas_led_rec_get_idx( uint_t entity_type, uint_t slot, uint_t led_idx ) { cps_api_key_t rec_key[1]; cps_api_key_init(rec_key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_LED_OBJ, 3, entity_type, slot, led_idx ); return ((pas_led_t *) dn_pas_res_get(rec_key)); }
static cps_api_return_code_t _write_function(void * context, cps_api_transaction_params_t * param,size_t ix) { cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix); if (obj==NULL) return cps_api_ret_code_ERR; cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj)); cps_api_object_t prev = cps_api_object_create(); if (prev==NULL) return cps_api_ret_code_ERR; if (!cps_api_object_list_append(param->prev,prev)) { cps_api_object_delete(prev); return cps_api_ret_code_ERR; } cps_api_key_t _local_key; cps_api_key_init(&_local_key,cps_api_qualifier_TARGET,cps_api_obj_cat_ROUTE,cps_api_route_obj_EVENT,0); if (cps_api_key_matches(&_local_key,cps_api_object_key(obj),true)) { os_send_refresh(nas_nl_sock_T_ROUTE); } else { return _op(op,context,obj,prev); } return cps_api_ret_code_OK; }
static t_std_error _cps_init () { cps_api_operation_handle_t handle; cps_api_return_code_t rc; cps_api_registration_functions_t f; rc = cps_api_operation_subsystem_init (&handle,1); if (rc != cps_api_ret_code_OK) { NAS_ACL_LOG_ERR ("NAS ACL CPS Subsystem Init failed"); return STD_ERR(QOS, FAIL, rc); } memset (&f, 0, sizeof(f)); f.handle = handle; f._read_function = nas_acl_cps_api_read; f._write_function = nas_acl_cps_api_write; f._rollback_function = nas_acl_cps_api_rollback; /* * Register all ACL objects * TODO: Need to check with CPS app teams, if ACL needs to register for * OBSERVED state. */ cps_api_key_init (&f.key, cps_api_qualifier_TARGET, cps_api_obj_CAT_BASE_ACL, 0, /* register all sub-categories */ 0); rc = cps_api_register (&f); if (rc != cps_api_ret_code_OK) { NAS_ACL_LOG_ERR ("NAS ACL CPS object Register failed"); return STD_ERR(QOS, FAIL, rc); } return STD_ERR_OK; }
static t_std_error dn_pas_psu_get1( cps_api_get_params_t *param, cps_api_qualifier_t qual, uint_t slot ) { cps_api_key_t rec_key[1]; pas_psu_t *rec; cps_api_object_t resp_obj; /* Look up object in cache */ cps_api_key_init(rec_key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_PSU_OBJ, 1, slot ); rec = (pas_psu_t *) dn_pas_res_get(rec_key); if (rec == 0) { /* Not found */ return (STD_ERR(PAS, NEXIST, 0)); } /* Compose respose object */ resp_obj = cps_api_object_create(); if (resp_obj == CPS_API_OBJECT_NULL) { EV_LOG_ERR(ev_log_t_PAS, 3, "PAS", "%s, allocate response object failed\n", __FUNCTION__); return (STD_ERR(PAS, NOMEM, 0)); } dn_pas_obj_key_psu_set(resp_obj, qual, true, slot); dn_pas_lock(); if ((!rec->valid || qual == cps_api_qualifier_REALTIME) && !dn_pald_diag_mode_get()) { /* Cache not valid or realtime object requested => Update cache from hardware */ dn_entity_poll(rec->parent, true); } if (rec->parent->present) { /* Add result attributes to response object */ cps_api_object_attr_add_u8(resp_obj, BASE_PAS_PSU_INPUT_TYPE, rec->input_type ); cps_api_object_attr_add_u8(resp_obj, BASE_PAS_PSU_FAN_AIRFLOW_TYPE, rec->fan_airflow_type ); } dn_pas_unlock(); /* Add response object to get response */ if (!cps_api_object_list_append(param->list, resp_obj)) { cps_api_object_delete(resp_obj); return (STD_ERR(PAS, FAIL, 0)); } return (STD_ERR_OK); }
static t_std_error nas_os_publish_route(int rt_msg_type, cps_api_object_t obj) { static char buff[MAX_CPS_MSG_SIZE]; cps_api_object_t new_obj = cps_api_object_init(buff,sizeof(buff)); cps_api_key_init(cps_api_object_key(new_obj),cps_api_qualifier_TARGET, cps_api_obj_cat_ROUTE,cps_api_route_obj_ROUTE,0 ); cps_api_object_attr_t prefix = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_ROUTE_PREFIX); cps_api_object_attr_t af = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_AF); cps_api_object_attr_t pref_len = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_PREFIX_LEN); cps_api_object_attr_t nh_count = cps_api_object_attr_get(obj, BASE_ROUTE_OBJ_ENTRY_NH_COUNT); if(rt_msg_type == RTM_NEWROUTE) { cps_api_object_attr_add_u32(new_obj, cps_api_if_ROUTE_A_MSG_TYPE,ROUTE_ADD); } else if(rt_msg_type == RTM_DELROUTE) { cps_api_object_attr_add_u32(new_obj, cps_api_if_ROUTE_A_MSG_TYPE,ROUTE_DEL); } else { return false; } cps_api_object_attr_add_u32(new_obj,cps_api_if_ROUTE_A_FAMILY, cps_api_object_attr_data_u32(af)); uint32_t addr_len; hal_ip_addr_t ip; if(cps_api_object_attr_data_u32(af) == AF_INET) { struct in_addr *inp = (struct in_addr *) cps_api_object_attr_data_bin(prefix); std_ip_from_inet(&ip,inp); addr_len = HAL_INET4_LEN; } else { struct in6_addr *inp6 = (struct in6_addr *) cps_api_object_attr_data_bin(prefix); std_ip_from_inet6(&ip,inp6); addr_len = HAL_INET6_LEN; } cps_api_attr_id_t attr = cps_api_if_ROUTE_A_PREFIX; cps_api_object_e_add(new_obj, &attr, 1, cps_api_object_ATTR_T_BIN, &ip, sizeof(ip)); cps_api_object_attr_add_u32(new_obj,cps_api_if_ROUTE_A_PREFIX_LEN, cps_api_object_attr_data_u32(pref_len)); uint32_t nhc = 0; if (nh_count != CPS_API_ATTR_NULL) nhc = cps_api_object_attr_data_u32(nh_count); if (nhc == 1) { cps_api_object_attr_add_u32(new_obj,cps_api_if_ROUTE_A_HOP_COUNT,nhc); cps_api_attr_id_t ids[3] = { BASE_ROUTE_OBJ_ENTRY_NH_LIST, 0, BASE_ROUTE_OBJ_ENTRY_NH_LIST_NH_ADDR}; const int ids_len = sizeof(ids)/sizeof(*ids); cps_api_object_attr_t gw = cps_api_object_e_get(obj,ids,ids_len); ids[2] = BASE_ROUTE_OBJ_ENTRY_NH_LIST_IFINDEX; cps_api_object_attr_t gwix = cps_api_object_e_get(obj,ids,ids_len); cps_api_attr_id_t new_ids[3]; new_ids[0] = cps_api_if_ROUTE_A_NH; new_ids[1] = 0; if (gw != CPS_API_ATTR_NULL) { new_ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_ADDR; hal_ip_addr_t ip; if(addr_len == HAL_INET4_LEN) { ip.af_index = AF_INET; memcpy(&(ip.u.v4_addr), cps_api_object_attr_data_bin(gw),addr_len); } else { ip.af_index = AF_INET6; memcpy(&(ip.u.v6_addr), cps_api_object_attr_data_bin(gw),addr_len); } cps_api_object_e_add(new_obj, new_ids, ids_len, cps_api_object_ATTR_T_BIN, &ip,sizeof(ip)); } if (gwix != CPS_API_ATTR_NULL) { new_ids[2] = cps_api_if_ROUTE_A_NH_IFINDEX; uint32_t gw_idx = cps_api_object_attr_data_u32(gwix); cps_api_object_e_add(new_obj,new_ids,ids_len,cps_api_object_ATTR_T_U32, (void *)&gw_idx, sizeof(uint32_t)); } } EV_LOG(INFO, NAS_OS, 2,"ROUTE-UPD","Publishing object"); net_publish_event(new_obj); return STD_ERR_OK; }
void dn_cache_init_led( sdi_resource_hdl_t sdi_resource_hdl, void *data ) { pas_entity_t *parent = (pas_entity_t *) data; const char *led_name; char ckey[PAS_CPS_KEY_STR_LEN]; cps_api_key_t cps_key[1]; pas_led_t *rec; ++parent->num_leds; rec = CALLOC_T(pas_led_t, 1); if (rec == 0) return; led_name = sdi_resource_alias_get(sdi_resource_hdl); rec->parent = parent; rec->led_idx = parent->num_leds; STRLCPY(rec->name, led_name); rec->name_len = strlen(rec->name); rec->sdi_resource_hdl = sdi_resource_hdl; dn_pas_oper_fault_state_init(rec->oper_fault_state); dn_led_res_key_name(ckey, sizeof(ckey), parent->entity_type, parent->slot, rec->name, rec->name_len ); if (!dn_pas_res_insertc(ckey, rec)) { free(rec); return; } cps_api_key_init(cps_key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_LED_OBJ, 3, parent->entity_type, parent->slot, rec->led_idx ); if (!dn_pas_res_insert(cps_key, rec)) { dn_pas_res_removec(ckey); free(rec); return; } /* Set LED to default */ struct pas_config_led *cfg = dn_pas_config_led_get(parent->entity_type, rec->name); (*(cfg != 0 && cfg->deflt ? sdi_led_on : sdi_led_off))(sdi_resource_hdl); }
//db_route_t bool nl_to_route_info(int rt_msg_type, struct nlmsghdr *hdr, cps_api_object_t obj) { struct rtmsg *rtmsg = (struct rtmsg *)NLMSG_DATA(hdr); char addr_str[INET6_ADDRSTRLEN]; if(hdr->nlmsg_len < NLMSG_LENGTH(sizeof(*rtmsg))) return false; if(rt_msg_type == RTM_NEWROUTE) { cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_MSG_TYPE,ROUTE_ADD); } else if(rt_msg_type == RTM_DELROUTE) { cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_MSG_TYPE,ROUTE_DEL); } else { return false; } cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_PROTOCOL,rtmsg->rtm_protocol); cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_FAMILY,rtmsg->rtm_family); int attr_len = nlmsg_attrlen(hdr,sizeof(*rtmsg)); struct nlattr *head = nlmsg_attrdata(hdr, sizeof(struct rtmsg)); struct nlattr *attrs[__IFLA_MAX]; memset(attrs,0,sizeof(attrs)); if (nla_parse(attrs,__IFLA_MAX,head,attr_len)!=0) { EV_LOG(ERR,ROUTE,0,"NL-ROUTE-PARSE","Failed to parse attributes"); return false; } cps_api_key_init(cps_api_object_key(obj),cps_api_qualifier_TARGET, cps_api_obj_cat_ROUTE,cps_api_route_obj_ROUTE,0 ); if(attrs[RTA_DST]!=NULL) { rta_add_ip((struct nlattr*)attrs[RTA_DST],rtmsg->rtm_family, obj,cps_api_if_ROUTE_A_PREFIX); } if((rtmsg->rtm_flags & RTM_F_CLONED) && (rtmsg->rtm_family == AF_INET6)) { // Skip cloned route updates char addr_str[INET6_ADDRSTRLEN]; EV_LOG(INFO, NETLINK,3,"ROUTE-EVENT","Cache entry %s", (attrs[RTA_DST]!=NULL)?(inet_ntop(rtmsg->rtm_family, ((struct in6_addr *) nla_data((struct nlattr*)attrs[RTA_DST])), addr_str, INET6_ADDRSTRLEN)):""); return false; } cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_PREFIX_LEN,rtmsg->rtm_dst_len); size_t hop_count = 0; cps_api_attr_id_t ids[3]; const int ids_len = sizeof(ids)/sizeof(*ids); ids[0] = cps_api_if_ROUTE_A_NH; ids[1] = hop_count; if (attrs[RTA_GATEWAY]!=NULL) { ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_ADDR; rta_add_e_ip((struct nlattr*)attrs[RTA_GATEWAY], rtmsg->rtm_family,obj, ids,ids_len); rta_add_ip((struct nlattr*)attrs[RTA_GATEWAY],rtmsg->rtm_family,obj, cps_api_if_ROUTE_A_NEXT_HOP_ADDR); } if (attrs[RTA_OIF]!=NULL) { ids[2] = cps_api_if_ROUTE_A_NH_IFINDEX; unsigned int *x = (unsigned int *) nla_data(attrs[RTA_OIF]); cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32, nla_data(attrs[RTA_OIF]),sizeof(uint32_t)); cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_NH_IFINDEX,*x); } nas_os_log_route_info(rt_msg_type, rtmsg, attrs); if (attrs[RTA_MULTIPATH]) { //array of next hops struct rtnexthop * rtnh = (struct rtnexthop * )nla_data(attrs[RTA_MULTIPATH]); int remaining = nla_len(attrs[RTA_MULTIPATH]); while (RTNH_OK(rtnh, remaining)) { ids[1] = hop_count; ids[2] = cps_api_if_ROUTE_A_NH_IFINDEX; uint32_t _int = rtnh->rtnh_ifindex; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32, &rtnh->rtnh_ifindex,sizeof(uint32_t)); _int = rtnh->rtnh_flags; ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_FLAGS; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32, &_int,sizeof(uint32_t)); ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_WEIGHT; _int = rtnh->rtnh_hops; cps_api_object_e_add(obj,ids,ids_len,cps_api_object_ATTR_T_U32, &_int,sizeof(uint32_t)); struct nlattr *nhattr[__RTA_MAX]; memset(nhattr,0,sizeof(nhattr)); nhrt_parse(nhattr,__IFLA_MAX,rtnh); if (nhattr[RTA_GATEWAY]) { ids[2] = cps_api_if_ROUTE_A_NEXT_HOP_ADDR; rta_add_e_ip((struct nlattr*)nhattr[RTA_GATEWAY], rtmsg->rtm_family,obj, ids,ids_len); EV_LOG(INFO, NETLINK,3,"ROUTE-EVENT","MultiPath nh-cnt:%d gateway:%s ifIndex:%d nh-flags:0x%x weight:%d", hop_count, ((rtmsg->rtm_family == AF_INET) ? (inet_ntop(rtmsg->rtm_family, ((struct in_addr *) nla_data((struct nlattr*)nhattr[RTA_GATEWAY])), addr_str, INET_ADDRSTRLEN)) : (inet_ntop(rtmsg->rtm_family, ((struct in6_addr *) nla_data((struct nlattr*)nhattr[RTA_GATEWAY])), addr_str, INET6_ADDRSTRLEN))), rtnh->rtnh_ifindex, rtnh->rtnh_flags, rtnh->rtnh_hops); } else { EV_LOG(INFO, NETLINK,3,"ROUTE-EVENT","MultiPath nh-cnt:%d ifIndex:%d nh-flags:0x%x weight:%d", hop_count, rtnh->rtnh_ifindex, rtnh->rtnh_flags, rtnh->rtnh_hops); } rtnh = rtnh_next(rtnh,&remaining); ++hop_count; } } else { ++hop_count; } cps_api_object_attr_add_u32(obj,cps_api_if_ROUTE_A_HOP_COUNT,hop_count); return true; }
static t_std_error dn_pas_fan_get1( cps_api_get_params_t *param, cps_api_qualifier_t qual, uint_t entity_type, uint_t slot, uint_t fan_idx ) { cps_api_key_t rec_key[1]; pas_fan_t *rec; cps_api_object_t resp_obj; /* Look up object in cache */ cps_api_key_init(rec_key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_FAN_OBJ, 3, entity_type, slot, fan_idx ); rec = (pas_fan_t *) dn_pas_res_get(rec_key); if (rec == 0) { /* Not found */ return (STD_ERR(PAS, NEXIST, 0)); } /* Compose respose object */ resp_obj = cps_api_object_create(); if (resp_obj == CPS_API_OBJECT_NULL) { EV_LOG_ERR(ev_log_t_PAS, 3, "PAS", "%s, allocate response object failed\n", __FUNCTION__); return (STD_ERR(PAS, NOMEM, 0)); } dn_pas_obj_key_fan_set(resp_obj, qual, true, entity_type, true, slot, true, fan_idx ); dn_pas_lock(); if ((!rec->valid || qual == cps_api_qualifier_REALTIME) && !dn_pald_diag_mode_get()) { /* Cache not valid or realtime object requested => Update cache from hardware */ dn_entity_poll(rec->parent, true); } if (rec->parent->present) { /* Add result attributes to response object */ if (qual == cps_api_qualifier_TARGET) { cps_api_object_attr_add_u16(resp_obj, BASE_PAS_FAN_SPEED, rec->targ_speed ); } else { cps_api_object_attr_add_u8(resp_obj, BASE_PAS_FAN_OPER_STATUS, rec->oper_fault_state->oper_status ); cps_api_object_attr_add_u8(resp_obj, BASE_PAS_FAN_FAULT_TYPE, rec->oper_fault_state->fault_type ); cps_api_object_attr_add_u16(resp_obj, BASE_PAS_FAN_SPEED, rec->obs_speed ); cps_api_object_attr_add_u8(resp_obj, BASE_PAS_FAN_SPEED_PCT, rec->max_speed != 0 ? (100 * rec->obs_speed) / rec->max_speed : 0 ); cps_api_object_attr_add_u16(resp_obj, BASE_PAS_FAN_MAX_SPEED, rec->max_speed ); } } dn_pas_unlock(); /* Add response object to get response */ if (!cps_api_object_list_append(param->list, resp_obj)) { cps_api_object_delete(resp_obj); return (STD_ERR(PAS, FAIL, 0)); } return (STD_ERR_OK); }
static t_std_error dn_pas_fan_set1( cps_api_transaction_params_t *param, cps_api_qualifier_t qual, uint_t entity_type, uint_t slot, uint_t fan_idx, bool speed_valid, uint_t speed, bool speed_pct_valid, uint_t speed_pct ) { cps_api_key_t rec_key[1]; pas_fan_t *rec; cps_api_object_t old_obj; pas_oper_fault_state_t prev_oper_fault_state[1]; t_std_error rc = STD_ERR_OK; uint_t targ_speed = 0; bool notif = false; /* Look up object in cache */ cps_api_key_init(rec_key, cps_api_qualifier_OBSERVED, cps_api_obj_CAT_BASE_PAS, BASE_PAS_FAN_OBJ, 3, entity_type, slot, fan_idx ); rec = (pas_fan_t *) dn_pas_res_get(rec_key); if (rec == 0) { /* Not found */ return (STD_ERR(PAS, NEXIST, 0)); } *prev_oper_fault_state = *rec->oper_fault_state; old_obj = cps_api_object_create(); if (old_obj == CPS_API_OBJECT_NULL) return (STD_ERR(PAS, NOMEM, 0)); dn_pas_obj_key_fan_set(old_obj, qual, true, entity_type, true, slot, true, fan_idx ); cps_api_object_attr_add_u16(old_obj, BASE_PAS_FAN_SPEED, rec->targ_speed ); if (!cps_api_object_list_append(param->prev, old_obj)) { cps_api_object_delete(old_obj); return (STD_ERR(PAS, FAIL, 0)); } old_obj = CPS_API_OBJECT_NULL; /* No longer owned */ targ_speed = rec->targ_speed; if (speed_pct_valid) { targ_speed = (speed_pct * rec->max_speed) / 100; } if (speed_valid) targ_speed = speed; if (targ_speed == rec->targ_speed) return rc; dn_pas_lock(); if(!dn_pald_diag_mode_get()) { rc = sdi_fan_speed_set(rec->sdi_resource_hdl, targ_speed); } dn_pas_unlock(); if (STD_IS_ERR(rc)) { dn_pas_oper_fault_state_update(rec->oper_fault_state, PLATFORM_FAULT_TYPE_EHW ); } else { rec->targ_speed = targ_speed; } if (rec->oper_fault_state->oper_status != prev_oper_fault_state->oper_status) { notif = true; } if (notif) dn_fan_notify(rec); return (rc); }