Hi Minh Ack, sorry for beeing a bit unclear
Thanks Lennart > -----Original Message----- > From: minh chau [mailto:minh.c...@dektech.com.au] > Sent: den 18 mars 2016 07:36 > To: Lennart Lund; praveen.malv...@oracle.com; Vu Minh Nguyen > Cc: opensaf-devel@lists.sourceforge.net; Anders Widell > Subject: Re: [PATCH 2 of 5] NTF: Add support cloud resilience for NTF Agent > [#1180] V3 > > Hi Lennart, > > I guess it's an ACK from you? Vu and Praveen gave ACK on V2 and if don't > have any comment on V3, can you please push it? > > Thanks, > Minh > > On 17/03/16 23:09, Lennart Lund wrote: > > Hi Minh > > > > See my comments inline [Lennart] > > > > Thanks > > Lennart > > > >> -----Original Message----- > >> From: Minh Chau H > >> Sent: den 16 mars 2016 15:58 > >> To: Lennart Lund; praveen.malv...@oracle.com; Vu Minh Nguyen > >> Cc: opensaf-devel@lists.sourceforge.net; Anders Widell; Minh Chau H > >> Subject: Re: [PATCH 2 of 5] NTF: Add support cloud resilience for NTF > Agent > >> [#1180] V3 > >> > >> Hi Lennart, > >> > >> Please see my comment in line with [Minh] > >> > >> Thanks, > >> Minh > >> > >> On 15/03/16 21:05, Lennart Lund wrote: > >>> Hi Minh, > >>> > >>> I still think it is better to have all the mutex handling in the API > >>> function. > >> Mutex handling is actually not taken away from the API function by doing > it in > >> a function called from the API function it's only hidden and the risk of > >> creating deadlocks increase. However in this case it is under control and > >> anyway the usage of global variables within the function is hidden as well. > I > >> give it to you to decide. > >> [Minh] The reason I suggest that handling cb_lock mutex in separate > >> function, because I have seen the deadlock reported in #1521, it should > >> be generalized as below: > >> saNtfFinalize() in thread 1 Unsubscribe() in thread 2 > >> // take handle > >> > >> // lock cb_lock > >> > >> // give handle > >> // take handle > >> > >> // lock cb_lock > >> -> I'm locked > >> // destroy handle > >> -> I'm locked too > >> > >> I think the similar deadlock scenarios still there in other APIs > >> (readFinalize vs readNext , ...), the reason is when locking cb (or take > >> handle), the next is not unlocking cb (or give handle) respectively. And > >> the fact that in current APIs code, a mix of cb_lock/handle usage where > >> a lot of "go to" in the middle of function would increase the risk of > >> running into the above scenario. Separating cb_lock in function should > >> be helpful. > >> The cb_lock is used to protect cb resource, > >> subscriptionListAdd()/subscriberListItemRemove() are example of this. > >> However, the code is not using cb_lock in consistent way to protect cb > >> resource, ntfa_reader_hdl_rec_add/ntfa_reader_hdl_rec_del for > instance, > >> which increases the risk of above deadlock. > >> The hidden deadlock you mentioned I guess, it happens because *cb_lock > - > >> separate - function* called after locking cb. But this case should not > >> happen given that it's *glanced* over in advance, like locking cb should > >> not be called just before calling subscriptionListAdd() > >> > >> So I think that protects cb variables of #1180 in separate function is > >> not ideal to fit with current APIs code but it's acceptable in the scope > >> of cloud resilience. > >> > > [Lennart] I am OK with your decision > >>> I don't think handling a cb_lock in functions called from the API > >>> functions > is > >> a solution for the future. Instead the global cb structure and other global > >> structures e.g. client structure , reader structure etc. should be removed > as > >> global variables. > >>> Instead all variables should be owned by the functionality that actually > use > >> them cf. private variables in C++. > >>> E.g. Client handles and client structures shall be owned by a client > handler > >> that can do all needed operations related to a client. If this handler must > use > >> locks it shall own its own mutex. > >>> There is no need to lock a whole cb structure with a lot of unrelated > >> variables if one client variable is read or changed. The client handler has > no > >> interest in how MDS is initiated and what handles needed for that > purpose > >> etc... > >>> When writing C-code, variables that must be shared by several functions > >> within a handler, can be isolated within that handler by giving the handler > its > >> own file and not exposing the variables in any .h file. The handler .h file > shall > >> only expose its interface which consists of functions but no variables. > >>> This will make the API functions clean from any handling of mutexes. > >> [Minh] This raises a good idea that how to make API functions stay clean > >> from mutexes handling. So we may need some sort of cb handler (or > >> manager) that only exposes interfaces to be called in API functions. > >> These interfaces give access (add/remove/...) to each specific cb > >> resource (client_rec, filters, ...) , and has cb_lock protection at > >> entry/exit point. The body of interfaces consist of actual functions > >> that performing activities on cb resource. > >> > >> Another refactoring I think it would be useful that the data structure > >> relates to client_rec/reader_rec/subscriber_rec should reflect the > >> object orientation as mentioned in specification, where client could be > >> producer/reader/subscriber. Currently a client_rec contains a list of > >> reader, but a list of subscriber is declared globally outside > >> client_rec. Also, the reader_list declared in ntfa_cb_t structure seems > >> not being used at all. I think refactoring object orientation would give > >> a support to the idea of implementation of cb handler as above. > >> > >> If this sounds right to you, there seems to be some things to do > > [Lennart] Yes it would be nice to do some refactoring to fix this kind of > problems. We should try to get rid of all system global variables e.g. the cb > structure. The cb structure tends to be some sort of "all purpose" collection > of globals that are used for different things (not related). This means that > we > may end up in situations where one thread wants to handle some variables > and at the same time another thread wants to handle other variables > unrelated but still protected by the same mutex. > > Another thing we can do is to start using C++ also for the agent except for > > a > thin C wrapper for the external API. This will make it much easier to create > clean code and we can also get rid of some complicated things like Patricia > trees via ncs API (not a very good API). Yes, this will work. It has been > tested > in AMF but has not yet been contributed. It is likely that it will be > contributed. > > > >>> Thanks > >>> Lennart > >>> > >>>> -----Original Message----- > >>>> From: minh chau [mailto:minh.c...@dektech.com.au] > >>>> Sent: den 15 mars 2016 02:05 > >>>> To: Lennart Lund; praveen.malv...@oracle.com; Vu Minh Nguyen > >>>> Cc: opensaf-devel@lists.sourceforge.net; Anders Widell; Minh Chau H > >>>> Subject: Re: [PATCH 2 of 5] NTF: Add support cloud resilience for NTF > >> Agent > >>>> [#1180] V3 > >>>> > >>>> Hi Lennart, > >>>> > >>>> The current code in agent now is using both protection of ncshm > handle > >>>> and global cb_lock mutex, and this happens in most of APIs with below > >>>> patterns > >>>> > >>>> // take lock > >>>> // doing something > >>>> // if not success > >>>> // unlock > >>>> // goto done > >>>> // unlock > >>>> // continue doing something > >>>> // done: > >>>> > >>>> // take lock > >>>> // doing something > >>>> // if not success > >>>> // goto done > >>>> // done: > >>>> // unlock > >>>> > >>>> These two patterns are now used in mix of both ncshm handle and > >> cb_lock > >>>> as well. Because of this, a lot of release locking at the end of > >>>> function, and it becomes harder to maintain and easy to makes mistake > >>>> that leads to deadlock. > >>>> In this case for cloud resilience, if ntfa_ntfsv_state is protected by > >>>> cb_lock inside of calling functions which are APIs, that also introduces > >>>> more duplicated above patterns, not only checkNtfServerState() but > also > >>>> somewhere just ntfa_ntfsv_state to be checked (Finalize, > Unsubscribed, > >>>> ReadFinalize). > >>>> Your comment is right also, there would be a risk that overlapping > >>>> protection and this should be avoided in normal cases. > >>>> But I think in NTF API function it'd better: > >>>> - cb_lock is taken away from API function, accessing cb resource > >>>> should be written in separate function in which the cb_lock is used > >>>> - Only ncshm handle protection is used in API, don't worry about > >>>> cb_lock > >>>> > >>>> Doing this way, I think the API code would look clear and reduce > >>>> duplicated pattern. > >>>> > >>>> I think we had a quick discussion and agreed that a ticket should be > >>>> raised for this matter, but haven't come up a generic solution. The > >>>> above is not final solution but I hope it makes the code a bit clearer. > >>>> And that's the way I was trying to thread safe the cloud resilience > >>>> variables. If it sounds right to you I think we can leave the rest for > >>>> another ticket. Otherwise, I can also change back to the way that > >>>> cb_lock has being used in above patterns so far. Then we may have > >>>> further discussion on this. > >>>> > >>>> Thanks, > >>>> Minh > >>>> > >>>> > >>>> > >>>> On 14/03/16 22:59, Lennart Lund wrote: > >>>>> Hi Minh, > >>>>> > >>>>> I see that you are using mutexes inside the checkNtfServerState(). I > >> don't > >>>> think this is a good solution since the same mutex is used directly in > >>>> the > >>>> function calling checkNtfServerState(). The mutex usage in the > >>>> checkNtfServerState() is hidden and there is a risk that this function > may > >> be > >>>> placed within a protected area in the calling function. It is better to > write a > >>>> note in the checkNtfServerState() function head clearly telling that this > >>>> function is not thread safe and has to be protected with the cb_lock > >> mutex > >>>> and then use the mutex in the calling function. > >>>>> Also I found a lot more unprotected usage of the global ntfa_cb > >> structure > >>>> but that is not directly related to the resilience update e.g a lot of > >> functions > >>>> taking a pointer to this structure. I think a ticket for this should be > written > >>>> now. The fix for checkNtfServerState() will just make sure that the > >> resilience > >>>> patch don't add even more thread related issues. > >>>>> Thanks > >>>>> Lennart > >>>>> > >>>>>> -----Original Message----- > >>>>>> From: Minh Hon Chau [mailto:minh.c...@dektech.com.au] > >>>>>> Sent: den 14 mars 2016 03:08 > >>>>>> To: Lennart Lund; praveen.malv...@oracle.com; Vu Minh Nguyen; > >> Minh > >>>>>> Chau H > >>>>>> Cc: opensaf-devel@lists.sourceforge.net > >>>>>> Subject: [PATCH 2 of 5] NTF: Add support cloud resilience for NTF > Agent > >>>>>> [#1180] V3 > >>>>>> > >>>>>> osaf/libs/agents/saf/ntfa/ntfa.h | 31 +- > >>>>>> osaf/libs/agents/saf/ntfa/ntfa_api.c | 702 > >>>>>> +++++++++++++++++++++++++++------ > >>>>>> osaf/libs/agents/saf/ntfa/ntfa_mds.c | 14 +- > >>>>>> osaf/libs/agents/saf/ntfa/ntfa_util.c | 465 > >> +++++++++++++++++++++- > >>>>>> 4 files changed, 1057 insertions(+), 155 deletions(-) > >>>>>> > >>>>>> > >>>>>> The patch contains support for cloud resilience feature > >>>>>> in NTF Agent code. Please refer README.HYDRA for content > >>>>>> of the changes > >>>>>> > >>>>>> diff --git a/osaf/libs/agents/saf/ntfa/ntfa.h > >>>>>> b/osaf/libs/agents/saf/ntfa/ntfa.h > >>>>>> --- a/osaf/libs/agents/saf/ntfa/ntfa.h > >>>>>> +++ b/osaf/libs/agents/saf/ntfa/ntfa.h > >>>>>> @@ -91,6 +91,7 @@ typedef struct ntfa_filter_hdl_rec { > >>>>>> typedef struct subscriberList { > >>>>>> SaNtfHandleT subscriberListNtfHandle; > >>>>>> SaNtfSubscriptionIdT subscriberListSubscriptionId; > >>>>>> + ntfsv_filter_ptrs_t filters; /* remember the filters used by > >>>>>> this > >>>>>> subscriber */ > >>>>>> struct subscriberList *prev; > >>>>>> struct subscriberList *next; > >>>>>> } ntfa_subscriber_list_t; > >>>>>> @@ -100,6 +101,10 @@ typedef struct ntfa_reader_hdl_rec { > >>>>>> unsigned int reader_id; /* handle value returned by NTFS > >>>>>> for this client */ > >>>>>> SaNtfHandleT ntfHandle; > >>>>>> unsigned int reader_hdl; /* READER handle from handle > >>>>>> mgr */ > >>>>>> + > >>>>>> + ntfsv_filter_ptrs_t filters; /* remember the filters used by > >>>>>> this > >>>>>> reader */ > >>>>>> + SaNtfSearchCriteriaT searchCriteria; /* remember the > >>>>>> searchCriteria for recovery */ > >>>>>> + > >>>>>> struct ntfa_reader_hdl_rec *next; /* next pointer for > >>>>>> the list in ntfa_cb_t */ > >>>>>> struct ntfa_client_hdl_rec *parent_hdl; /* Back Pointer to > >>>>>> the client instantiation */ > >>>>>> } ntfa_reader_hdl_rec_t; > >>>>>> @@ -114,24 +119,35 @@ typedef struct ntfa_client_hdl_rec { > >>>>>> ntfa_reader_hdl_rec_t *reader_list; > >>>>>> SYSF_MBX mbx; /* priority q mbx > >>>>>> b/w MDS & Library */ > >>>>>> struct ntfa_client_hdl_rec *next; /* next pointer for > >>>>>> the list in ntfa_cb_t */ > >>>>>> + bool valid; /* handle is valid if it's known by > >>>>>> NTF server, used for headless hydra */ > >>>>>> + SaVersionT version; /* the API version is being used by client, > >>>>>> used for recover after headless */ > >>>>>> } ntfa_client_hdl_rec_t; > >>>>>> > >>>>>> /* > >>>>>> * The NTFA control block is the master anchor structure for all > NTFA > >>>>>> * instantiations within a process. > >>>>>> */ > >>>>>> +typedef enum { > >>>>>> + NTFA_NTFSV_NONE = 0, > >>>>>> + NTFA_NTFSV_DOWN, > >>>>>> + NTFA_NTFSV_NO_ACTIVE, > >>>>>> + NTFA_NTFSV_NEW_ACTIVE, > >>>>>> + NTFA_NTFSV_UP > >>>>>> +}ntfa_ntfsv_state_t; > >>>>>> + > >>>>>> typedef struct { > >>>>>> pthread_mutex_t cb_lock; /* CB lock */ > >>>>>> ntfa_client_hdl_rec_t *client_list; /* NTFA client > >>>>>> handle database */ > >>>>>> ntfa_reader_hdl_rec_t *reader_list; > >>>>>> MDS_HDL mds_hdl; /* MDS handle */ > >>>>>> MDS_DEST ntfs_mds_dest; /* NTFS absolute/virtual address > >>>>>> */ > >>>>>> - int ntfs_up; /* Indicate that MDS subscription > >>>>>> - * is complete */ > >>>>>> + > >>>>>> /* NTFS NTFA sync params */ > >>>>>> int ntfs_sync_awaited; > >>>>>> NCS_SEL_OBJ ntfs_sync_sel; > >>>>>> SaUint32T ntf_var_data_limit; /* max allowed > >>>>>> variableDataSize */ > >>>>>> + /* NTF Server state */ > >>>>>> + ntfa_ntfsv_state_t ntfa_ntfsv_state; > >>>>>> } ntfa_cb_t; > >>>>>> > >>>>>> /* ntfa_saf_api.c */ > >>>>>> @@ -149,7 +165,7 @@ extern void ntfsv_ntfa_evt_free(struct n > >>>>>> > >>>>>> /* ntfa_init.c */ > >>>>>> extern unsigned int ntfa_startup(void); > >>>>>> -extern unsigned int ntfa_shutdown(void); > >>>>>> +extern unsigned int ntfa_shutdown(bool forced); > >>>>>> > >>>>>> /* ntfa_hdl.c */ > >>>>>> extern SaAisErrorT ntfa_hdl_cbk_dispatch(ntfa_cb_t *, > >>>>>> ntfa_client_hdl_rec_t *, SaDispatchFlagsT); > >>>>>> @@ -159,6 +175,7 @@ extern ntfa_notification_hdl_rec_t *ntfa > >>>>>> extern ntfa_filter_hdl_rec_t > >>>>>> *ntfa_filter_hdl_rec_add(ntfa_client_hdl_rec_t **hdl_rec); > >>>>>> extern void ntfa_hdl_list_del(ntfa_client_hdl_rec_t **); > >>>>>> extern uint32_t ntfa_hdl_rec_del(ntfa_client_hdl_rec_t **, > >>>>>> ntfa_client_hdl_rec_t *); > >>>>>> +extern void ntfa_hdl_rec_force_del(ntfa_client_hdl_rec_t **, > >>>>>> ntfa_client_hdl_rec_t *); > >>>>>> extern uint32_t > >>>> ntfa_notification_hdl_rec_del(ntfa_notification_hdl_rec_t > >>>>>> **, ntfa_notification_hdl_rec_t *); > >>>>>> extern uint32_t ntfa_filter_hdl_rec_del(ntfa_filter_hdl_rec_t **, > >>>>>> ntfa_filter_hdl_rec_t *); > >>>>>> extern bool ntfa_validate_ntfa_client_hdl(ntfa_cb_t *ntfa_cb, > >>>>>> ntfa_client_hdl_rec_t *find_hdl_rec); > >>>>>> @@ -166,11 +183,15 @@ extern bool ntfa_validate_ntfa_client_hd > >>>>>> /* ntfa_util.c */ > >>>>>> extern ntfa_client_hdl_rec_t > >>>> *ntfa_find_hdl_rec_by_client_id(ntfa_cb_t > >>>>>> *ntfa_cb, uint32_t client_id); > >>>>>> extern void ntfa_msg_destroy(ntfsv_msg_t *msg); > >>>>>> -extern void ntfa_hdl_rec_destructor(ntfa_notification_hdl_rec_t > >>>>>> *instance); > >>>>>> -extern void ntfa_filter_hdl_rec_destructor(ntfa_filter_hdl_rec_t > >>>>>> +extern void > ntfa_notification_destructor(ntfa_notification_hdl_rec_t > >>>>>> *instance); > >>>>>> +extern void ntfa_filter_destructor(ntfa_filter_hdl_rec_t > >>>>>> > >>>>>> *notificationFilterInstance); > >>>>>> extern ntfa_reader_hdl_rec_t > >>>>>> *ntfa_reader_hdl_rec_add(ntfa_client_hdl_rec_t **hdl_rec); > >>>>>> extern uint32_t ntfa_reader_hdl_rec_del(ntfa_reader_hdl_rec_t > **, > >>>>>> ntfa_reader_hdl_rec_t *); > >>>>>> extern void ntfa_add_to_async_cbk_msg_list(ntfsv_msg_t ** > head, > >>>>>> ntfsv_msg_t * new_node); > >>>>>> extern uint32_t ntfa_ntfs_msg_proc(ntfa_cb_t *cb, ntfsv_msg_t > >>>>>> *ntfsv_msg, MDS_SEND_PRIORITY_TYPE prio); > >>>>>> +extern void ntfa_update_ntfsv_state(ntfa_ntfsv_state_t > >>>> changedState); > >>>>>> +extern SaAisErrorT ntfa_copy_ntf_filter_ptrs(ntfsv_filter_ptrs_t* > >> pDes, > >>>>>> + > >>>>>> const ntfsv_filter_ptrs_t* pSrc); > >>>>>> +extern SaAisErrorT ntfa_del_ntf_filter_ptrs(ntfsv_filter_ptrs_t* > >>>> filter_ptrs); > >>>>>> #endif /* !NTFA_H */ > >>>>>> diff --git a/osaf/libs/agents/saf/ntfa/ntfa_api.c > >>>>>> b/osaf/libs/agents/saf/ntfa/ntfa_api.c > >>>>>> --- a/osaf/libs/agents/saf/ntfa/ntfa_api.c > >>>>>> +++ b/osaf/libs/agents/saf/ntfa/ntfa_api.c > >>>>>> @@ -34,11 +34,61 @@ > >>>>>> /* The main controle block */ > >>>>>> ntfa_cb_t ntfa_cb = { > >>>>>> .cb_lock = PTHREAD_MUTEX_INITIALIZER, > >>>>>> + .ntfa_ntfsv_state = NTFA_NTFSV_NONE, > >>>>>> }; > >>>>>> > >>>>>> /* list of subscriptions for this process */ > >>>>>> ntfa_subscriber_list_t *subscriberNoList = NULL; > >>>>>> > >>>>>> +/* > >>>>>> + * @Brief: Determine the common "availability" of API, which > >> depends > >>>> on > >>>>>> the > >>>>>> + * NTF Server state > >>>>>> + * @Param: None > >>>>>> + * @Return: OK - If Server state is UP > >>>>>> + * TRY_AGAIN - If Server state is Down and No Active > (temporary > >> no > >>>>>> active) > >>>>>> + */ > >>>>>> +static SaAisErrorT checkNtfServerState() > >>>>>> +{ > >>>>>> + SaAisErrorT rc = SA_AIS_ERR_NOT_SUPPORTED; > >>>>>> + > >>>>>> + osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> + /* Check NTF server availability */ > >>>>>> + if (ntfa_cb.ntfa_ntfsv_state == NTFA_NTFSV_UP) { > >>>>>> + rc = SA_AIS_OK; > >>>>>> + } else if (ntfa_cb.ntfa_ntfsv_state == NTFA_NTFSV_DOWN) { > >>>>>> + TRACE("NTFS server is down"); > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + } else if (ntfa_cb.ntfa_ntfsv_state == > >>>>>> NTFA_NTFSV_NO_ACTIVE) { > >>>>>> + TRACE("NTFS server is unavailable"); > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + } else if (ntfa_cb.ntfa_ntfsv_state == NTFA_NTFSV_NONE) { > >>>>>> + TRACE("No NTF server is detected, or API is > >>>>>> called during headless"); > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + } else > >>>>>> + TRACE("Not supported API call under NTF Server > >>>>>> state (%u)", > >>>>>> + > >>>>>> ntfa_cb.ntfa_ntfsv_state); > >>>>>> + > >>>>>> + osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> + return rc; > >>>>>> +} > >>>>>> + > >>>>>> +/* > >>>>>> + * @Brief: Return ntf server state in thread safe manner > >>>>>> + * @Param: None > >>>>>> + * @Return: Server state > >>>>>> + */ > >>>>>> +static ntfa_ntfsv_state_t getServerState() > >>>>>> +{ > >>>>>> + osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> + ntfa_ntfsv_state_t state = ntfa_cb.ntfa_ntfsv_state; > >>>>>> + > >>>>>> + osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + return state; > >>>>>> +} > >>>>>> + > >>>>>> static SaAisErrorT checkNtfValueTypeRange(SaNtfValueTypeT > type) > >>>>>> { > >>>>>> return (type < SA_NTF_VALUE_UINT8 || type > > >>>>>> SA_NTF_VALUE_ARRAY)? SA_AIS_ERR_INVALID_PARAM > >>>>>> @@ -871,7 +921,271 @@ SaAisErrorT getFilters(const SaNtfNotifi > >>>>>> } > >>>>>> > >>>>>> /* end help functions */ > >>>>>> - > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : reinitializeClient > >>>>>> + > >>>>>> + Description : This routine sends initialize messages to NTF Server > in > >>>>>> + order to obtain new client id > >>>>>> + > >>>>>> + Arguments : client_hdl* [IN]: client handle > >>>>>> + > >>>>>> + Return Values : SA_AIS_OK if success, others are failure > >>>>>> + > >>>>>> + Notes : None > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +SaAisErrorT reinitializeClient(ntfa_client_hdl_rec_t* client_hdl) { > >>>>>> + uint32_t mds_rc; > >>>>>> + SaAisErrorT rc = SA_AIS_OK; > >>>>>> + ntfsv_msg_t i_msg, *o_msg = NULL; > >>>>>> + > >>>>>> + TRACE_ENTER(); > >>>>>> + > >>>>>> + memset(&i_msg, 0, sizeof(ntfsv_msg_t)); > >>>>>> + i_msg.type = NTFSV_NTFA_API_MSG; > >>>>>> + i_msg.info.api_info.type = NTFSV_INITIALIZE_REQ; > >>>>>> + i_msg.info.api_info.param.init.version = client_hdl->version; > >>>>>> + > >>>>>> + mds_rc = ntfa_mds_msg_sync_send(&ntfa_cb, &i_msg, > >>>>>> &o_msg, NTFS_WAIT_TIME); > >>>>>> + switch (mds_rc) { > >>>>>> + case NCSCC_RC_SUCCESS: > >>>>>> + break; > >>>>>> + case NCSCC_RC_REQ_TIMOUT: > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + goto done; > >>>>>> + default: > >>>>>> + rc = SA_AIS_ERR_BAD_HANDLE; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + osafassert(o_msg != NULL); > >>>>>> + /* Check response msg: type, rc */ > >>>>>> + if (o_msg->info.api_resp_info.type != NTFSV_INITIALIZE_RSP) > >>>>>> { > >>>>>> + TRACE("info.api_resp_info.type:%u", o_msg- > >>>>>>> info.api_resp_info.type); > >>>>>> + rc = SA_AIS_ERR_LIBRARY; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + if ((rc = o_msg->info.api_resp_info.rc) != SA_AIS_OK) { > >>>>>> + TRACE("info.api_resp_info.rc:%u", o_msg- > >>>>>>> info.api_resp_info.rc); > >>>>>> + rc = SA_AIS_ERR_BAD_HANDLE; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + client_hdl->ntfs_client_id = o_msg- > >>>>>>> info.api_resp_info.param.init_rsp.client_id; > >>>>>> + TRACE("Successfully recover client_id, new client_id:%u", > >>>>>> + client_hdl->ntfs_client_id); > >>>>>> + > >>>>>> +done: > >>>>>> + if (o_msg) > >>>>>> + ntfa_msg_destroy(o_msg); > >>>>>> + TRACE_LEAVE(); > >>>>>> + return rc; > >>>>>> +} > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : recoverReader > >>>>>> + > >>>>>> + Description : This routine sends read_initialize messages to NTF > >> Server > >>>> in > >>>>>> + order to reintroduce this reader to NTF Server > >>>>>> + > >>>>>> + Arguments : client_hdl* [IN]: client handle > >>>>>> + reader_hdl* [IN]: reader handle > >>>>>> + > >>>>>> + Return Values : SA_AIS_OK if success, others are failure > >>>>>> + > >>>>>> + Notes : None > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +SaAisErrorT recoverReader(ntfa_client_hdl_rec_t* client_hdl, > >>>>>> ntfa_reader_hdl_rec_t* reader_hdl) { > >>>>>> + uint32_t mds_rc; > >>>>>> + SaAisErrorT rc = SA_AIS_OK; > >>>>>> + ntfsv_msg_t i_msg, *o_msg = NULL; > >>>>>> + ntfsv_reader_init_req_2_t *send_param; > >>>>>> + > >>>>>> + TRACE_ENTER(); > >>>>>> + > >>>>>> + /* Make sure the filters have not been deleted */ > >>>>>> + if (reader_hdl->filters.alarm_filter == NULL && > >>>>>> + reader_hdl->filters.att_ch_filter == NULL && > >>>>>> + reader_hdl->filters.obj_cr_del_filter == NULL > >>>>>> && > >>>>>> + reader_hdl->filters.sec_al_filter == NULL && > >>>>>> + reader_hdl->filters.sta_ch_filter == NULL) > >>>>>> + return SA_AIS_ERR_BAD_HANDLE; > >>>>>> + > >>>>>> + memset(&i_msg, 0, sizeof(ntfsv_msg_t)); > >>>>>> + i_msg.type = NTFSV_NTFA_API_MSG; > >>>>>> + i_msg.info.api_info.type = NTFSV_READER_INITIALIZE_REQ_2; > >>>>>> + send_param = &i_msg.info.api_info.param.reader_init_2; > >>>>>> + send_param->head.client_id = client_hdl->ntfs_client_id; > >>>>>> + send_param->head.searchCriteria = reader_hdl- > >>>>>>> searchCriteria; > >>>>>> + send_param->f_rec = reader_hdl->filters; > >>>>>> + > >>>>>> + mds_rc = ntfa_mds_msg_sync_send(&ntfa_cb, &i_msg, > >>>>>> &o_msg, NTFS_WAIT_TIME); > >>>>>> + > >>>>>> + switch (mds_rc) { > >>>>>> + case NCSCC_RC_SUCCESS: > >>>>>> + break; > >>>>>> + case NCSCC_RC_REQ_TIMOUT: > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + goto done; > >>>>>> + default: > >>>>>> + rc = SA_AIS_ERR_BAD_HANDLE; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + osafassert(o_msg != NULL); > >>>>>> + if ((rc = o_msg->info.api_resp_info.rc) != SA_AIS_OK) { > >>>>>> + TRACE("o_msg->info.api_resp_info.rc:%u", > >>>>>> o_msg->info.api_resp_info.rc); > >>>>>> + rc = SA_AIS_ERR_BAD_HANDLE; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + if (o_msg->info.api_resp_info.type != > >>>>>> NTFSV_READER_INITIALIZE_RSP) { > >>>>>> + TRACE("msg type (%d) failed", (int)o_msg- > >>>>>>> info.api_resp_info.type); > >>>>>> + rc = SA_AIS_ERR_LIBRARY; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + /* Update reader_id since it may be changed */ > >>>>>> + reader_hdl->reader_id = o_msg- > >>>>>>> info.api_resp_info.param.reader_init_rsp.readerId; > >>>>>> + > >>>>>> + TRACE("Recover reader successfully"); > >>>>>> +done: > >>>>>> + if (o_msg) > >>>>>> + ntfa_msg_destroy(o_msg); > >>>>>> + TRACE_LEAVE(); > >>>>>> + return rc; > >>>>>> +} > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : recoverSubscriber > >>>>>> + > >>>>>> + Description : This routine sends subscribe messages to NTF > Server in > >>>>>> + order to reintroduce this subscriber to NTF > >>>>>> Server > >>>>>> + > >>>>>> + Arguments : client_hdl* [IN]: client handle > >>>>>> + subscriber_hdl* [IN]: subscriber handle > >>>>>> + > >>>>>> + Return Values : SA_AIS_OK if success, others are failure > >>>>>> + > >>>>>> + Notes : None > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +SaAisErrorT recoverSubscriber(ntfa_client_hdl_rec_t* client_hdl, > >>>>>> + > >>>>>> > >>>>>> ntfa_subscriber_list_t* subscriber_hdl) { > >>>>>> + uint32_t mds_rc; > >>>>>> + SaAisErrorT rc = SA_AIS_OK; > >>>>>> + ntfsv_msg_t i_msg, *o_msg = NULL; > >>>>>> + ntfsv_subscribe_req_t *send_param; > >>>>>> + > >>>>>> + TRACE_ENTER(); > >>>>>> + > >>>>>> + /* Make sure the filters have not been deleted */ > >>>>>> + if (subscriber_hdl->filters.alarm_filter == NULL && > >>>>>> + subscriber_hdl->filters.att_ch_filter == NULL && > >>>>>> + subscriber_hdl->filters.obj_cr_del_filter == > >>>>>> NULL && > >>>>>> + subscriber_hdl->filters.sec_al_filter == NULL && > >>>>>> + subscriber_hdl->filters.sta_ch_filter == NULL) > >>>>>> + return SA_AIS_ERR_BAD_HANDLE; > >>>>>> + > >>>>>> + memset(&i_msg, 0, sizeof(ntfsv_msg_t)); > >>>>>> + i_msg.type = NTFSV_NTFA_API_MSG; > >>>>>> + i_msg.info.api_info.type = NTFSV_SUBSCRIBE_REQ; > >>>>>> + send_param = &i_msg.info.api_info.param.subscribe; > >>>>>> + > >>>>>> + send_param->client_id = client_hdl->ntfs_client_id; > >>>>>> + send_param->subscriptionId = subscriber_hdl- > >>>>>>> subscriberListSubscriptionId; > >>>>>> + send_param->f_rec = subscriber_hdl->filters; > >>>>>> + > >>>>>> + mds_rc = ntfa_mds_msg_sync_send(&ntfa_cb, &i_msg, > >>>>>> &o_msg, NTFS_WAIT_TIME); > >>>>>> + > >>>>>> + switch (mds_rc) { > >>>>>> + case NCSCC_RC_SUCCESS: > >>>>>> + break; > >>>>>> + case NCSCC_RC_REQ_TIMOUT: > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + goto done; > >>>>>> + default: > >>>>>> + rc = SA_AIS_ERR_BAD_HANDLE; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + osafassert(o_msg != NULL); > >>>>>> + > >>>>>> + if ((rc = o_msg->info.api_resp_info.rc) != SA_AIS_OK) { > >>>>>> + TRACE("o_msg->info.api_resp_info.rc:%u", > >>>>>> o_msg->info.api_resp_info.rc); > >>>>>> + rc = SA_AIS_ERR_BAD_HANDLE; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + if (o_msg->info.api_resp_info.type != > >>>>>> NTFSV_SUBSCRIBE_RSP) { > >>>>>> + TRACE("msg type (%d) failed", (int)o_msg- > >>>>>>> info.api_resp_info.type); > >>>>>> + rc = SA_AIS_ERR_LIBRARY; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + TRACE("Recover subscriber successfully"); > >>>>>> +done: > >>>>>> + if (o_msg) > >>>>>> + ntfa_msg_destroy(o_msg); > >>>>>> + > >>>>>> + TRACE_LEAVE(); > >>>>>> + return rc; > >>>>>> +} > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : recoverClient > >>>>>> + > >>>>>> + Description : In NTF-A.03.01, section 2.1.2. A client can be > producer, > >>>>>> + subscriber, and reader at the same time. > >>>>>> + This routine will recovery: > >>>>>> + (1) client_id > >>>>>> + (2) Then it will continue the recovery if this > >>>>>> client also > >>>>>> + has instance of subscriber or reader. > >>>>>> + Arguments : client_hdl* [IN]: client handle > >>>>>> + > >>>>>> + Return Values : SA_AIS_OK if success, others are failure > >>>>>> + > >>>>>> + Notes : None > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +SaAisErrorT recoverClient(ntfa_client_hdl_rec_t *client_hdl) { > >>>>>> + > >>>>>> + TRACE_ENTER(); > >>>>>> + SaAisErrorT rc = SA_AIS_OK; > >>>>>> + > >>>>>> + osafassert(client_hdl); > >>>>>> + osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> + if (client_hdl->valid == true) > >>>>>> + goto done; > >>>>>> + > >>>>>> + if ((rc = reinitializeClient(client_hdl)) == SA_AIS_OK) { > >>>>>> + /* Restore reader */ > >>>>>> + ntfa_reader_hdl_rec_t* reader_hdl = > >>>>>> client_hdl->reader_list; > >>>>>> + while (reader_hdl != NULL && rc == SA_AIS_OK) > >>>>>> { > >>>>>> + rc = recoverReader(client_hdl, > >>>>>> reader_hdl); > >>>>>> + reader_hdl = reader_hdl->next; > >>>>>> + } > >>>>>> + if (rc != SA_AIS_OK) { > >>>>>> + TRACE("Failed to restore reader > >>>>>> (readerId:%d)", > >>>>>> + > >>>>>> reader_hdl->reader_id); > >>>>>> + goto done; > >>>>>> + } > >>>>>> + /* Restore subscriber */ > >>>>>> + ntfa_subscriber_list_t* subscriber_hdl = > >>>>>> subscriberNoList; > >>>>>> + while (subscriber_hdl != NULL && rc == > >>>>>> SA_AIS_OK) { > >>>>>> + if (client_hdl->local_hdl == > >>>>>> subscriber_hdl->subscriberListNtfHandle) > >>>>>> + rc = > >>>>>> recoverSubscriber(client_hdl, subscriber_hdl); > >>>>>> + subscriber_hdl = subscriber_hdl- > >>>>>>> next; > >>>>>> + } > >>>>>> + if (rc != SA_AIS_OK) { > >>>>>> + TRACE("Failed to restore > >>>>>> subscriber (subscriptionId:%d)", > >>>>>> + > >>>>>> subscriber_hdl->subscriberListSubscriptionId); > >>>>>> + goto done; > >>>>>> + } > >>>>>> + client_hdl->valid = true; > >>>>>> + } else { > >>>>>> + TRACE("Failed to restore client (id:%d)", > >>>>>> client_hdl->ntfs_client_id); > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> +done: > >>>>>> + osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + TRACE_LEAVE(); > >>>>>> + return rc; > >>>>>> +} > >>>>>> > >>>>>> > >> > /********************************************************** > >>>>>> ***************** > >>>>>> * 8.4.1 > >>>>>> * > >>>>>> @@ -923,15 +1237,14 @@ SaAisErrorT saNtfInitialize(SaNtfHandleT > >>>>>> version->releaseCode = NTF_RELEASE_CODE; > >>>>>> version->majorVersion = > >>>>>> NTF_MAJOR_VERSION; > >>>>>> version->minorVersion = > >>>>>> NTF_MINOR_VERSION; > >>>>>> - ntfa_shutdown(); > >>>>>> + ntfa_shutdown(false); > >>>>>> rc = SA_AIS_ERR_VERSION; > >>>>>> goto done; > >>>>>> } > >>>>>> > >>>>>> - if (!ntfa_cb.ntfs_up) { > >>>>>> - ntfa_shutdown(); > >>>>>> - TRACE("NTFS server is down"); > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + /* Check NTF server availability */ > >>>>>> + if ((rc = checkNtfServerState()) != SA_AIS_OK) { > >>>>>> + ntfa_shutdown(false); > >>>>>> goto done; > >>>>>> } > >>>>>> > >>>>>> @@ -977,7 +1290,7 @@ SaAisErrorT saNtfInitialize(SaNtfHandleT > >>>>>> rc = SA_AIS_ERR_NO_MEMORY; > >>>>>> goto err; > >>>>>> } > >>>>>> - > >>>>>> + ntfa_hdl_rec->version = *version; > >>>>>> /* pass the handle value to the appl */ > >>>>>> if (SA_AIS_OK == rc) > >>>>>> *ntfHandle = ntfa_hdl_rec->local_hdl; > >>>>>> @@ -990,7 +1303,7 @@ SaAisErrorT saNtfInitialize(SaNtfHandleT > >>>>>> > >>>>>> if (rc != SA_AIS_OK) { > >>>>>> TRACE_2("NTFA INIT FAILED\n"); > >>>>>> - ntfa_shutdown(); > >>>>>> + ntfa_shutdown(false); > >>>>>> } > >>>>>> > >>>>>> done: > >>>>>> @@ -1101,6 +1414,28 @@ SaAisErrorT saNtfDispatch(SaNtfHandleT n > >>>>>> goto done; > >>>>>> } > >>>>>> > >>>>>> + /* Need to check NTF server availability here > >>>>>> + * Because if the notificationCallback just comes after > >>>>>> MDS_DOWN > >>>>>> + * it will go to recovery then result in failure due to no > >>>>>> director > >>>>>> + */ > >>>>>> + if ((rc = checkNtfServerState()) != SA_AIS_OK) { > >>>>>> + ncshm_give_hdl(ntfHandle); > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + if (!hdl_rec->valid) { > >>>>>> + /* recovery */ > >>>>>> + if ((rc = recoverClient(hdl_rec)) != SA_AIS_OK) { > >>>>>> + if (rc == > >>>>>> SA_AIS_ERR_BAD_HANDLE) { > >>>>>> + > >>>>>> ncshm_give_hdl(ntfHandle); > >>>>>> + > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_hdl_rec_force_del(&ntfa_cb.client_list, hdl_rec); > >>>>>> + > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_shutdown(false); > >>>>>> + goto done; > >>>>>> + } > >>>>>> + } > >>>>>> + } > >>>>>> if ((rc = ntfa_hdl_cbk_dispatch(&ntfa_cb, hdl_rec, > >>>>>> dispatchFlags)) != SA_AIS_OK) > >>>>>> TRACE("NTFA_DISPATCH_FAILURE"); > >>>>>> > >>>>>> @@ -1145,6 +1480,13 @@ SaAisErrorT saNtfFinalize(SaNtfHandleT n > >>>>>> > >>>>>> TRACE_ENTER(); > >>>>>> > >>>>>> + /* Check NTF server availability */ > >>>>>> + if (getServerState() == NTFA_NTFSV_NO_ACTIVE) { > >>>>>> + TRACE("NTFS server is temporarily unavailable"); > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> /* retrieve hdl rec */ > >>>>>> hdl_rec = ncshm_take_hdl(NCS_SERVICE_ID_NTFA, > >>>>>> ntfHandle); > >>>>>> if (hdl_rec == NULL) { > >>>>>> @@ -1152,43 +1494,37 @@ SaAisErrorT saNtfFinalize(SaNtfHandleT n > >>>>>> rc = SA_AIS_ERR_BAD_HANDLE; > >>>>>> goto done; > >>>>>> } > >>>>>> - > >>>>>> - /* Check Whether NTFS is up or not */ > >>>>>> - if (!ntfa_cb.ntfs_up) { > >>>>>> - TRACE("NTFS down"); > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> - goto done_give_hdl; > >>>>>> + if (hdl_rec->valid) { > >>>>>> + /** populate & send the finalize message > >>>>>> + ** and make sure the finalize from the server > >>>>>> + ** end returned before deleting the local > >>>>>> records. > >>>>>> + **/ > >>>>>> + memset(&msg, 0, sizeof(ntfsv_msg_t)); > >>>>>> + msg.type = NTFSV_NTFA_API_MSG; > >>>>>> + msg.info.api_info.type = NTFSV_FINALIZE_REQ; > >>>>>> + msg.info.api_info.param.finalize.client_id = > >>>>>> hdl_rec->ntfs_client_id; > >>>>>> + > >>>>>> + mds_rc = ntfa_mds_msg_sync_send(&ntfa_cb, > >>>>>> &msg, &o_msg, NTFS_WAIT_TIME); > >>>>>> + switch (mds_rc) { > >>>>>> + case NCSCC_RC_SUCCESS: > >>>>>> + break; > >>>>>> + case NCSCC_RC_REQ_TIMOUT: > >>>>>> + rc = SA_AIS_ERR_TIMEOUT; > >>>>>> + > >>>>>> TRACE("ntfa_mds_msg_sync_send FAILED: %u", rc); > >>>>>> + goto done_give_hdl; > >>>>>> + default: > >>>>>> + > >>>>>> TRACE("ntfa_mds_msg_sync_send FAILED: %u", rc); > >>>>>> + rc = > >>>>>> SA_AIS_ERR_NO_RESOURCES; > >>>>>> + goto done_give_hdl; > >>>>>> + } > >>>>>> + > >>>>>> + if (o_msg != NULL) { > >>>>>> + rc = o_msg- > >>>>>>> info.api_resp_info.rc; > >>>>>> + ntfa_msg_destroy(o_msg); > >>>>>> + } else > >>>>>> + rc = > >>>>>> SA_AIS_ERR_NO_RESOURCES; > >>>>>> } > >>>>>> > >>>>>> - /** populate & send the finalize message > >>>>>> - ** and make sure the finalize from the server > >>>>>> - ** end returned before deleting the local records. > >>>>>> - **/ > >>>>>> - memset(&msg, 0, sizeof(ntfsv_msg_t)); > >>>>>> - msg.type = NTFSV_NTFA_API_MSG; > >>>>>> - msg.info.api_info.type = NTFSV_FINALIZE_REQ; > >>>>>> - msg.info.api_info.param.finalize.client_id = hdl_rec- > >>>>>>> ntfs_client_id; > >>>>>> - > >>>>>> - mds_rc = ntfa_mds_msg_sync_send(&ntfa_cb, &msg, > >>>>>> &o_msg, NTFS_WAIT_TIME); > >>>>>> - switch (mds_rc) { > >>>>>> - case NCSCC_RC_SUCCESS: > >>>>>> - break; > >>>>>> - case NCSCC_RC_REQ_TIMOUT: > >>>>>> - rc = SA_AIS_ERR_TIMEOUT; > >>>>>> - TRACE("ntfa_mds_msg_sync_send FAILED: %u", > >>>>>> rc); > >>>>>> - goto done_give_hdl; > >>>>>> - default: > >>>>>> - TRACE("ntfa_mds_msg_sync_send FAILED: %u", > >>>>>> rc); > >>>>>> - rc = SA_AIS_ERR_NO_RESOURCES; > >>>>>> - goto done_give_hdl; > >>>>>> - } > >>>>>> - > >>>>>> - if (o_msg != NULL) { > >>>>>> - rc = o_msg->info.api_resp_info.rc; > >>>>>> - ntfa_msg_destroy(o_msg); > >>>>>> - } else > >>>>>> - rc = SA_AIS_ERR_NO_RESOURCES; > >>>>>> - > >>>>>> if (rc == SA_AIS_OK) { > >>>>>> /** delete the hdl rec > >>>>>> ** including all resources allocated by client if MDS > >>>>>> send is > >>>>>> @@ -1205,7 +1541,7 @@ SaAisErrorT saNtfFinalize(SaNtfHandleT n > >>>>>> ncshm_give_hdl(ntfHandle); > >>>>>> > >>>>>> if (rc == SA_AIS_OK) { > >>>>>> - rc = ntfa_shutdown(); > >>>>>> + rc = ntfa_shutdown(false); > >>>>>> if (rc != NCSCC_RC_SUCCESS) > >>>>>> TRACE_1("ntfa_shutdown > >>>>>> failed"); > >>>>>> } > >>>>>> @@ -1349,7 +1685,7 @@ SaAisErrorT saNtfNotificationFree(SaNtfN > >>>>>> } > >>>>>> > >>>>>> /* free the resources allocated by > >>>>>> saNtf<ntfType>NotificationAllocate */ > >>>>>> - ntfa_hdl_rec_destructor(notification_hdl_rec); > >>>>>> + ntfa_notification_destructor(notification_hdl_rec); > >>>>>> > >>>>>> /** Delete the resources related to the notificationHandle & > >>>>>> * remove reference in the client. > >>>>>> @@ -1419,6 +1755,24 @@ SaAisErrorT saNtfNotificationSend(SaNtfN > >>>>>> } > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> > >>>>>> + /* Check NTF server availability */ > >>>>>> + if ((rc = checkNtfServerState()) != SA_AIS_OK) > >>>>>> + goto done_give_hdls; > >>>>>> + > >>>>>> + /* Recover if this is invalid handle */ > >>>>>> + if (!client_rec->valid) { > >>>>>> + if ((rc = recoverClient(client_rec)) != > >>>>>> SA_AIS_OK) { > >>>>>> + ncshm_give_hdl(client_handle); > >>>>>> + > >>>>>> ncshm_give_hdl(notificationHandle); > >>>>>> + if (rc == > >>>>>> SA_AIS_ERR_BAD_HANDLE) { > >>>>>> + > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_hdl_rec_force_del(&ntfa_cb.client_list, client_rec); > >>>>>> + > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_shutdown(false); > >>>>>> + } > >>>>>> + goto err_free; > >>>>>> + } > >>>>>> + } > >>>>>> /** > >>>>>> ** Populate a sync MDS message > >>>>>> **/ > >>>>>> @@ -1481,13 +1835,6 @@ SaAisErrorT saNtfNotificationSend(SaNtfN > >>>>>> goto done_give_hdls; > >>>>>> } > >>>>>> > >>>>>> - /* Check whether NTFS is up or not */ > >>>>>> - if (!ntfa_cb.ntfs_up) { > >>>>>> - TRACE("NTFS down"); > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> - goto done_give_hdls; > >>>>>> - } > >>>>>> - > >>>>>> /* Send a sync MDS message to obtain a notification id */ > >>>>>> mds_rc = ntfa_mds_msg_sync_send(&ntfa_cb, &msg, > >>>>>> &o_msg, timeout); > >>>>>> switch (mds_rc) { > >>>>>> @@ -1596,7 +1943,8 @@ static SaNtfHandleT ntfHandleGet(SaNtfS > >>>>>> return ntfHandle; > >>>>>> } > >>>>>> > >>>>>> -static SaAisErrorT subscriptionListAdd(SaNtfHandleT ntfHandle, > >>>>>> SaNtfSubscriptionIdT subscriptionId) > >>>>>> +static SaAisErrorT subscriptionListAdd(SaNtfHandleT ntfHandle, > >>>>>> SaNtfSubscriptionIdT subscriptionId, > >>>>>> + > >>>>>> > >>>>>> ntfsv_filter_ptrs_t filters) > >>>>>> { > >>>>>> SaAisErrorT rc = SA_AIS_OK; > >>>>>> ntfa_subscriber_list_t* ntfSubscriberList; > >>>>>> @@ -1610,7 +1958,9 @@ static SaAisErrorT subscriptionListAdd(S > >>>>>> /* Add ntfHandle and subscriptionId into list */ > >>>>>> ntfSubscriberList->subscriberListNtfHandle = ntfHandle; > >>>>>> ntfSubscriberList->subscriberListSubscriptionId = > >>>>>> subscriptionId; > >>>>>> - > >>>>>> + memset(&ntfSubscriberList->filters, 0, > >>>>>> sizeof(ntfsv_filter_ptrs_t)); > >>>>>> + ntfa_copy_ntf_filter_ptrs(&ntfSubscriberList->filters, > >>>>>> &filters); > >>>>>> + > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> if (NULL == subscriberNoList) { > >>>>>> subscriberNoList = ntfSubscriberList; > >>>>>> @@ -1648,6 +1998,7 @@ static void subscriberListItemRemove(SaN > >>>>>> subscriberNoList = NULL; > >>>>>> } > >>>>>> TRACE_1("REMOVE: listPtr->SubscriptionId %d", listPtr- > >>>>>>> subscriberListSubscriptionId); > >>>>>> + ntfa_del_ntf_filter_ptrs(&listPtr->filters); > >>>>>> free(listPtr); > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> } > >>>>>> @@ -1666,20 +2017,33 @@ SaAisErrorT saNtfNotificationSubscribe(c > >>>>>> ntfsv_msg_t msg, *o_msg = NULL; > >>>>>> ntfsv_subscribe_req_t *send_param; > >>>>>> uint32_t timeout = NTFS_WAIT_TIME; > >>>>>> - > >>>>>> + bool recovery_failed = false; > >>>>>> TRACE_ENTER(); > >>>>>> + > >>>>>> rc = getFilters(notificationFilterHandles, &filters, &ntfHandle, > >>>>>> &client_hdl_rec); > >>>>>> if (rc != SA_AIS_OK) { > >>>>>> TRACE("getFilters failed"); > >>>>>> goto done; > >>>>>> } > >>>>>> > >>>>>> + /* Check NTF server availability */ > >>>>>> + if ((rc = checkNtfServerState()) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + > >>>>>> + /* recovery */ > >>>>>> + if (client_hdl_rec != NULL && !client_hdl_rec->valid) { > >>>>>> + if ((rc = recoverClient(client_hdl_rec)) != > >>>>>> SA_AIS_OK) { > >>>>>> + recovery_failed = true; > >>>>>> + goto done; > >>>>>> + } > >>>>>> + } > >>>>>> + > >>>>>> tmpHandle = ntfHandleGet(subscriptionId); > >>>>>> if (tmpHandle != 0) { > >>>>>> rc = SA_AIS_ERR_EXIST; > >>>>>> goto done; > >>>>>> } > >>>>>> - rc = subscriptionListAdd(ntfHandle, subscriptionId); > >>>>>> + rc = subscriptionListAdd(ntfHandle, subscriptionId, filters); > >>>>>> if (rc != SA_AIS_OK) { > >>>>>> goto done; > >>>>>> } > >>>>>> @@ -1693,29 +2057,24 @@ SaAisErrorT saNtfNotificationSubscribe(c > >>>>>> send_param->client_id = client_hdl_rec->ntfs_client_id; > >>>>>> send_param->subscriptionId = subscriptionId; > >>>>>> send_param->f_rec = filters; > >>>>>> - /* Check whether NTFS is up or not */ > >>>>>> - if (ntfa_cb.ntfs_up) { > >>>>>> - uint32_t rv; > >>>>>> - /* Send a sync MDS message to obtain a log > >>>>>> stream id */ > >>>>>> - rv = ntfa_mds_msg_sync_send(&ntfa_cb, > >>>>>> &msg, &o_msg, timeout); > >>>>>> - if (rv == NCSCC_RC_SUCCESS) { > >>>>>> - osafassert(o_msg != NULL); > >>>>>> - if (SA_AIS_OK == o_msg- > >>>>>>> info.api_resp_info.rc) { > >>>>>> - > >>>>>> TRACE_1("subscriptionId from server %u", > >>>>>> - > >>>>>> o_msg- > >>>>>>> info.api_resp_info.param.subscribe_rsp.subscriptionId); > >>>>>> - } else { > >>>>>> - rc = o_msg- > >>>>>>> info.api_resp_info.rc; > >>>>>> - TRACE("Bad return > >>>>>> status!!! rc = %d", rc); > >>>>>> - } > >>>>>> + > >>>>>> + uint32_t rv; > >>>>>> + /* Send a sync MDS message to obtain a log stream id */ > >>>>>> + rv = ntfa_mds_msg_sync_send(&ntfa_cb, &msg, &o_msg, > >>>>>> timeout); > >>>>>> + if (rv == NCSCC_RC_SUCCESS) { > >>>>>> + osafassert(o_msg != NULL); > >>>>>> + if (SA_AIS_OK == o_msg->info.api_resp_info.rc) > >>>>>> { > >>>>>> + TRACE_1("subscriptionId from > >>>>>> server %u", > >>>>>> + o_msg- > >>>>>>> info.api_resp_info.param.subscribe_rsp.subscriptionId); > >>>>>> } else { > >>>>>> - if(rv == > >>>>>> NCSCC_RC_INVALID_INPUT) > >>>>>> - rc = > >>>>>> SA_AIS_ERR_INVALID_PARAM; > >>>>>> - else > >>>>>> - rc = > >>>>>> SA_AIS_ERR_TRY_AGAIN; > >>>>>> + rc = o_msg- > >>>>>>> info.api_resp_info.rc; > >>>>>> + TRACE("Bad return status!!! rc = > >>>>>> %d", rc); > >>>>>> } > >>>>>> } else { > >>>>>> - TRACE_1("NTFS down"); > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + if(rv == NCSCC_RC_INVALID_INPUT) > >>>>>> + rc = > >>>>>> SA_AIS_ERR_INVALID_PARAM; > >>>>>> + else > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> } > >>>>>> > >>>>>> if (rc != SA_AIS_OK) { > >>>>>> @@ -1724,6 +2083,7 @@ SaAisErrorT saNtfNotificationSubscribe(c > >>>>>> if (o_msg) > >>>>>> ntfa_msg_destroy(o_msg); > >>>>>> done: > >>>>>> + > >>>>>> ncshm_give_hdl(ntfHandle); > >>>>>> if (notificationFilterHandles) { > >>>>>> if (notificationFilterHandles- > >>>>>>> attributeChangeFilterHandle) > >>>>>> @@ -1737,6 +2097,13 @@ SaAisErrorT saNtfNotificationSubscribe(c > >>>>>> if (notificationFilterHandles->alarmFilterHandle) > >>>>>> > >>>>>> ncshm_give_hdl(notificationFilterHandles- > >>>>>>> alarmFilterHandle); > >>>>>> } > >>>>>> + if (recovery_failed && rc == SA_AIS_ERR_BAD_HANDLE) { > >>>>>> + > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + ntfa_hdl_rec_force_del(&ntfa_cb.client_list, > >>>>>> client_hdl_rec); > >>>>>> + > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + ntfa_shutdown(false); > >>>>>> + } > >>>>>> + > >>>>>> TRACE_LEAVE(); > >>>>>> return rc; > >>>>>> } > >>>>>> @@ -1995,6 +2362,7 @@ SaAisErrorT saNtfSecurityAlarmNotificati > >>>>>> rc = SA_AIS_ERR_INVALID_PARAM; > >>>>>> goto done; > >>>>>> } > >>>>>> + > >>>>>> /* retrieve hdl rec */ > >>>>>> hdl_rec = ncshm_take_hdl(NCS_SERVICE_ID_NTFA, > >>>>>> ntfHandle); > >>>>>> if (hdl_rec == NULL) { > >>>>>> @@ -2058,6 +2426,7 @@ SaAisErrorT saNtfPtrValAllocate(SaNtfNot > >>>>>> rc = SA_AIS_ERR_INVALID_PARAM; > >>>>>> goto done; > >>>>>> } > >>>>>> + > >>>>>> notification_hdl_rec = > >>>>>> ncshm_take_hdl(NCS_SERVICE_ID_NTFA, notificationHandle); > >>>>>> if (notification_hdl_rec == NULL) { > >>>>>> TRACE("ncshm_take_hdl notificationHandle > >>>>>> failed"); > >>>>>> @@ -2098,6 +2467,7 @@ SaAisErrorT saNtfArrayValAllocate(SaNtfN > >>>>>> rc = SA_AIS_ERR_INVALID_PARAM; > >>>>>> goto done; > >>>>>> } > >>>>>> + > >>>>>> notification_hdl_rec = > >>>>>> ncshm_take_hdl(NCS_SERVICE_ID_NTFA, notificationHandle); > >>>>>> if (notification_hdl_rec == NULL) { > >>>>>> TRACE("ncshm_take_hdl notificationHandle > >>>>>> failed"); > >>>>>> @@ -2228,6 +2598,7 @@ SaAisErrorT saNtfArrayValGet(SaNtfNotifi > >>>>>> rc = SA_AIS_ERR_INVALID_PARAM; > >>>>>> goto done; > >>>>>> } > >>>>>> + > >>>>>> notification_hdl_rec = > >>>>>> ncshm_take_hdl(NCS_SERVICE_ID_NTFA, notificationHandle); > >>>>>> if (notification_hdl_rec == NULL) { > >>>>>> TRACE("ncshm_take_hdl notificationHandle > >>>>>> failed"); > >>>>>> @@ -2695,7 +3066,7 @@ SaAisErrorT saNtfNotificationFilterFree( > >>>>>> } > >>>>>> > >>>>>> /* free the resources allocated by > >>>>>> saNtf<ntfType>FilterAllocate */ > >>>>>> - ntfa_filter_hdl_rec_destructor(filter_hdl_rec); > >>>>>> + ntfa_filter_destructor(filter_hdl_rec); > >>>>>> > >>>>>> /** Delete the resources related to the > >>>>>> notificationFilterHandle > & > >>>>>> * remove reference in the client. > >>>>>> @@ -2727,9 +3098,8 @@ SaAisErrorT saNtfNotificationFilterFree( > >>>>>> SaAisErrorT saNtfNotificationUnsubscribe(SaNtfSubscriptionIdT > >>>>>> subscriptionId) > >>>>>> { > >>>>>> TRACE_ENTER(); > >>>>>> - SaAisErrorT rc = SA_AIS_ERR_NOT_EXIST; > >>>>>> + SaAisErrorT rc = SA_AIS_OK; > >>>>>> SaNtfHandleT ntfHandle; > >>>>>> - > >>>>>> ntfa_client_hdl_rec_t *client_hdl_rec; > >>>>>> > >>>>>> ntfsv_msg_t msg, *o_msg = NULL; > >>>>>> @@ -2737,6 +3107,12 @@ SaAisErrorT saNtfNotificationUnsubscribe > >>>>>> ntfsv_unsubscribe_req_t *send_param; > >>>>>> uint32_t timeout = NTFS_WAIT_TIME; > >>>>>> > >>>>>> + /* Check NTF server availability */ > >>>>>> + if (getServerState() == NTFA_NTFSV_NO_ACTIVE) { > >>>>>> + TRACE("NTFS server is temporarily unavailable"); > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + goto done; > >>>>>> + } > >>>>>> > >>>>>> ntfHandle = ntfHandleGet(subscriptionId); > >>>>>> if (ntfHandle == 0) { > >>>>>> @@ -2753,9 +3129,10 @@ SaAisErrorT saNtfNotificationUnsubscribe > >>>>>> goto done; > >>>>>> } > >>>>>> > >>>>>> - /** > >>>>>> - ** Populate a sync MDS message > >>>>>> - **/ > >>>>>> + if (client_hdl_rec->valid) { > >>>>>> + /** > >>>>>> + ** Populate a sync MDS message > >>>>>> + **/ > >>>>>> memset(&msg, 0, sizeof(ntfsv_msg_t)); > >>>>>> msg.type = NTFSV_NTFA_API_MSG; > >>>>>> msg.info.api_info.type = > >>>>>> NTFSV_UNSUBSCRIBE_REQ; > >>>>>> @@ -2764,13 +3141,6 @@ SaAisErrorT saNtfNotificationUnsubscribe > >>>>>> send_param->client_id = client_hdl_rec- > >>>>>>> ntfs_client_id; > >>>>>> send_param->subscriptionId = subscriptionId; > >>>>>> > >>>>>> - /* Check whether NTFS is up or not */ > >>>>>> - if (!ntfa_cb.ntfs_up) { > >>>>>> - TRACE_1("NTFS down"); > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> - goto done_give_hdl; > >>>>>> - } > >>>>>> - > >>>>>> /* Send a sync MDS message to obtain a log > >>>>>> stream id */ > >>>>>> rc = ntfa_mds_msg_sync_send(&ntfa_cb, > >>>>>> &msg, &o_msg, timeout); > >>>>>> if (rc != NCSCC_RC_SUCCESS) { > >>>>>> @@ -2785,6 +3155,7 @@ SaAisErrorT saNtfNotificationUnsubscribe > >>>>>> TRACE_1("Bad return status! rc = > >>>>>> %d", rc); > >>>>>> goto done_give_hdl; > >>>>>> } > >>>>>> + } > >>>>>> subscriberListItemRemove(subscriptionId); > >>>>>> > >>>>>> /*Remove msg for subscriptionId from > >>>>>> mailbox*/ > >>>>>> @@ -2815,6 +3186,19 @@ SaAisErrorT saNtfNotificationUnsubscribe > >>>>>> done_give_hdl: > >>>>>> if (o_msg) > >>>>>> ntfa_msg_destroy(o_msg); > >>>>>> + > >>>>>> + if (!client_hdl_rec->valid && getServerState() == > >>>>>> NTFA_NTFSV_UP) { > >>>>>> + if ((rc = recoverClient(client_hdl_rec)) != > >>>>>> SA_AIS_OK) { > >>>>>> + if (rc == > >>>>>> SA_AIS_ERR_BAD_HANDLE) { > >>>>>> + > >>>>>> ncshm_give_hdl(ntfHandle); > >>>>>> + > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_hdl_rec_force_del(&ntfa_cb.client_list, client_hdl_rec); > >>>>>> + > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_shutdown(false); > >>>>>> + goto done; > >>>>>> + } > >>>>>> + } > >>>>>> + } > >>>>>> ncshm_give_hdl(ntfHandle); > >>>>>> done: > >>>>>> TRACE_LEAVE(); > >>>>>> @@ -2838,6 +3222,7 @@ SaAisErrorT saNtfNotificationReadInitial > >>>>>> ntfsv_reader_init_req_2_t *send_param; > >>>>>> uint32_t timeout = NTFS_WAIT_TIME; > >>>>>> > >>>>>> + bool recovery_failed = false; > >>>>>> TRACE_ENTER(); > >>>>>> if (notificationFilterHandles == NULL || readHandle == NULL) { > >>>>>> rc = SA_AIS_ERR_INVALID_PARAM; > >>>>>> @@ -2872,6 +3257,18 @@ SaAisErrorT saNtfNotificationReadInitial > >>>>>> goto done_give_client_hdl; > >>>>>> } > >>>>>> > >>>>>> + /* Check NTF server availability */ > >>>>>> + if ((rc = checkNtfServerState()) != SA_AIS_OK) > >>>>>> + goto done_give_client_hdl; > >>>>>> + > >>>>>> + /* recovery */ > >>>>>> + if (client_hdl_rec != NULL && !client_hdl_rec->valid) { > >>>>>> + if ((rc = recoverClient(client_hdl_rec)) != > >>>>>> SA_AIS_OK) { > >>>>>> + recovery_failed = true; > >>>>>> + goto done_give_client_hdl; > >>>>>> + } > >>>>>> + } > >>>>>> + > >>>>>> /** > >>>>>> ** Populate a sync MDS message > >>>>>> **/ > >>>>>> @@ -2884,13 +3281,6 @@ SaAisErrorT saNtfNotificationReadInitial > >>>>>> send_param->head.searchCriteria = searchCriteria; > >>>>>> send_param->f_rec = filters; > >>>>>> > >>>>>> - /* Check whether NTFS is up or not */ > >>>>>> - if (!ntfa_cb.ntfs_up) { > >>>>>> - TRACE("NTFS down"); > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> - goto done_give_client_hdl; > >>>>>> - } > >>>>>> - > >>>>>> /* Send a sync MDS message to obtain a log stream id */ > >>>>>> rc = ntfa_mds_msg_sync_send(&ntfa_cb, &msg, &o_msg, > >>>>>> timeout); > >>>>>> if (rc != NCSCC_RC_SUCCESS) { > >>>>>> @@ -2925,12 +3315,16 @@ SaAisErrorT saNtfNotificationReadInitial > >>>>>> reader_hdl_rec->ntfHandle = ntfHandle; > >>>>>> /* Store the readerId returned from server */ > >>>>>> reader_hdl_rec->reader_id = o_msg- > >>>>>>> info.api_resp_info.param.reader_init_rsp.readerId; > >>>>>> + memset(&reader_hdl_rec->filters, 0, > >>>>>> sizeof(ntfsv_filter_ptrs_t)); > >>>>>> + ntfa_copy_ntf_filter_ptrs(&reader_hdl_rec->filters, &filters); > >>>>>> + reader_hdl_rec->searchCriteria = searchCriteria; > >>>>>> /** UnLock ntfa_CB **/ > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> > >>>>>> done_give_client_hdl: > >>>>>> if (o_msg) > >>>>>> ntfa_msg_destroy(o_msg); > >>>>>> + > >>>>>> if (client_hdl_rec) > >>>>>> ncshm_give_hdl(client_hdl_rec->local_hdl); > >>>>>> if (notificationFilterHandles) { > >>>>>> @@ -2947,6 +3341,12 @@ done_give_client_hdl: > >>>>>> } > >>>>>> > >>>>>> ncshm_give_hdl(notificationFilterHandles- > >>>>>>> alarmFilterHandle); > >>>>>> + if (recovery_failed && rc == SA_AIS_ERR_BAD_HANDLE) { > >>>>>> + > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + ntfa_hdl_rec_force_del(&ntfa_cb.client_list, > >>>>>> client_hdl_rec); > >>>>>> + > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + ntfa_shutdown(false); > >>>>>> + } > >>>>>> done: > >>>>>> TRACE_LEAVE(); > >>>>>> return rc; > >>>>>> @@ -2955,7 +3355,7 @@ done: > >>>>>> /* 3.15.4.2 saNtfNotificationReadFinalize() */ > >>>>>> SaAisErrorT saNtfNotificationReadFinalize(SaNtfReadHandleT > >>>> readhandle) > >>>>>> { > >>>>>> - SaAisErrorT rc = SA_AIS_ERR_NOT_SUPPORTED; > >>>>>> + SaAisErrorT rc = SA_AIS_OK; > >>>>>> uint32_t oas_rc = NCSCC_RC_FAILURE; > >>>>>> > >>>>>> ntfa_client_hdl_rec_t *client_hdl_rec; > >>>>>> @@ -2966,6 +3366,12 @@ SaAisErrorT saNtfNotificationReadFinaliz > >>>>>> uint32_t timeout = NTFS_WAIT_TIME; > >>>>>> > >>>>>> TRACE_ENTER(); > >>>>>> + /* Check NTF server availability */ > >>>>>> + if (getServerState() == NTFA_NTFSV_NO_ACTIVE) { > >>>>>> + TRACE("NTFS server is temporarily unavailable"); > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + goto done; > >>>>>> + } > >>>>>> > >>>>>> /* retrieve notification filter hdl rec */ > >>>>>> reader_hdl_rec = ncshm_take_hdl(NCS_SERVICE_ID_NTFA, > >>>>>> readhandle); > >>>>>> @@ -2983,42 +3389,39 @@ SaAisErrorT saNtfNotificationReadFinaliz > >>>>>> } > >>>>>> TRACE_1("reader_hdl_rec = %u", reader_hdl_rec- > >>>>>>> reader_hdl); > >>>>>> - /** > >>>>>> - ** Populate a sync MDS message > >>>>>> - **/ > >>>>>> - memset(&msg, 0, sizeof(ntfsv_msg_t)); > >>>>>> - msg.type = NTFSV_NTFA_API_MSG; > >>>>>> - msg.info.api_info.type = NTFSV_READER_FINALIZE_REQ; > >>>>>> - send_param = &msg.info.api_info.param.reader_finalize; > >>>>>> - send_param->client_id = client_hdl_rec->ntfs_client_id; > >>>>>> - send_param->readerId = reader_hdl_rec->reader_id; > >>>>>> - > >>>>>> - /* Check whether NTFS is up or not */ > >>>>>> - if (!ntfa_cb.ntfs_up) { > >>>>>> - TRACE("NTFS down"); > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> - goto done_give_hdls; > >>>>>> + if (client_hdl_rec->valid) { > >>>>>> + /** > >>>>>> + ** Populate a sync MDS message > >>>>>> + **/ > >>>>>> + memset(&msg, 0, sizeof(ntfsv_msg_t)); > >>>>>> + msg.type = NTFSV_NTFA_API_MSG; > >>>>>> + msg.info.api_info.type = > >>>>>> NTFSV_READER_FINALIZE_REQ; > >>>>>> + send_param = > >>>>>> &msg.info.api_info.param.reader_finalize; > >>>>>> + send_param->client_id = client_hdl_rec- > >>>>>>> ntfs_client_id; > >>>>>> + send_param->readerId = reader_hdl_rec- > >>>>>>> reader_id; > >>>>>> + > >>>>>> + > >>>>>> + /* Send a sync MDS message */ > >>>>>> + rc = ntfa_mds_msg_sync_send(&ntfa_cb, > >>>>>> &msg, &o_msg, timeout); > >>>>>> + if (rc != NCSCC_RC_SUCCESS) { > >>>>>> + rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> + goto done_give_hdls; > >>>>>> + } > >>>>>> + > >>>>>> + osafassert(o_msg != NULL); > >>>>>> + if (SA_AIS_OK != o_msg->info.api_resp_info.rc) > >>>>>> { > >>>>>> + rc = o_msg- > >>>>>>> info.api_resp_info.rc; > >>>>>> + TRACE("Bad return status!!! rc = > >>>>>> %d", rc); > >>>>>> + goto done_give_hdls; > >>>>>> + } > >>>>>> + > >>>>>> + if (o_msg->info.api_resp_info.type != > >>>>>> NTFSV_READER_FINALIZE_RSP) { > >>>>>> + TRACE("msg type (%d) failed", > >>>>>> (int)o_msg->info.api_resp_info.type); > >>>>>> + rc = SA_AIS_ERR_LIBRARY; > >>>>>> + goto done_give_hdls; > >>>>>> + } > >>>>>> } > >>>>>> > >>>>>> - /* Send a sync MDS message */ > >>>>>> - rc = ntfa_mds_msg_sync_send(&ntfa_cb, &msg, &o_msg, > >>>>>> timeout); > >>>>>> - if (rc != NCSCC_RC_SUCCESS) { > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> - goto done_give_hdls; > >>>>>> - } > >>>>>> - > >>>>>> - osafassert(o_msg != NULL); > >>>>>> - if (SA_AIS_OK != o_msg->info.api_resp_info.rc) { > >>>>>> - rc = o_msg->info.api_resp_info.rc; > >>>>>> - TRACE("Bad return status!!! rc = %d", rc); > >>>>>> - goto done_give_hdls; > >>>>>> - } > >>>>>> - > >>>>>> - if (o_msg->info.api_resp_info.type != > >>>>>> NTFSV_READER_FINALIZE_RSP) { > >>>>>> - TRACE("msg type (%d) failed", (int)o_msg- > >>>>>>> info.api_resp_info.type); > >>>>>> - rc = SA_AIS_ERR_LIBRARY; > >>>>>> - goto done_give_hdls; > >>>>>> - } > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> oas_rc = ntfa_reader_hdl_rec_del(&client_hdl_rec- > >>>>>>> reader_list, reader_hdl_rec); > >>>>>> if (oas_rc != NCSCC_RC_SUCCESS) { > >>>>>> @@ -3029,6 +3432,20 @@ SaAisErrorT saNtfNotificationReadFinaliz > >>>>>> done_give_hdls: > >>>>>> if (o_msg) > >>>>>> ntfa_msg_destroy(o_msg); > >>>>>> + > >>>>>> + if (!client_hdl_rec->valid && getServerState() == > >>>>>> NTFA_NTFSV_UP) { > >>>>>> + if ((rc = recoverClient(client_hdl_rec)) != > >>>>>> SA_AIS_OK) { > >>>>>> + if (rc == > >>>>>> SA_AIS_ERR_BAD_HANDLE) { > >>>>>> + > >>>>>> ncshm_give_hdl(client_hdl_rec->local_hdl); > >>>>>> + > >>>>>> ncshm_give_hdl(readhandle); > >>>>>> + > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_hdl_rec_force_del(&ntfa_cb.client_list, client_hdl_rec); > >>>>>> + > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_shutdown(false); > >>>>>> + goto done; > >>>>>> + } > >>>>>> + } > >>>>>> + } > >>>>>> ncshm_give_hdl(client_hdl_rec->local_hdl); > >>>>>> done_give_read_hdl: > >>>>>> ncshm_give_hdl(readhandle); > >>>>>> @@ -3082,6 +3499,23 @@ SaAisErrorT saNtfNotificationReadNext(Sa > >>>>>> } > >>>>>> TRACE_1("reader_hdl_rec = %u", reader_hdl_rec- > >>>>>>> reader_hdl); > >>>>>> + /* Check NTF server availability */ > >>>>>> + if ((rc = checkNtfServerState()) != SA_AIS_OK) > >>>>>> + goto done_give_hdls; > >>>>>> + > >>>>>> + if (!client_hdl_rec->valid) { > >>>>>> + if ((rc = recoverClient(client_hdl_rec)) != > >>>>>> SA_AIS_OK) { > >>>>>> + ncshm_give_hdl(client_hdl_rec- > >>>>>>> local_hdl); > >>>>>> + ncshm_give_hdl(readHandle); > >>>>>> + if (rc == > >>>>>> SA_AIS_ERR_BAD_HANDLE) { > >>>>>> + > >>>>>> osafassert(pthread_mutex_lock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_hdl_rec_force_del(&ntfa_cb.client_list, client_hdl_rec); > >>>>>> + > >>>>>> osafassert(pthread_mutex_unlock(&ntfa_cb.cb_lock) == 0); > >>>>>> + > >>>>>> ntfa_shutdown(false); > >>>>>> + } > >>>>>> + goto done; > >>>>>> + } > >>>>>> + } > >>>>>> /** > >>>>>> ** Populate a sync MDS message > >>>>>> **/ > >>>>>> @@ -3092,12 +3526,6 @@ SaAisErrorT saNtfNotificationReadNext(Sa > >>>>>> send_param->client_id = client_hdl_rec->ntfs_client_id; > >>>>>> send_param->readerId = reader_hdl_rec->reader_id; > >>>>>> send_param->searchDirection = searchDirection; > >>>>>> - /* Check whether NTFS is up or not */ > >>>>>> - if (!ntfa_cb.ntfs_up) { > >>>>>> - TRACE("NTFS down"); > >>>>>> - rc = SA_AIS_ERR_TRY_AGAIN; > >>>>>> - goto done_give_hdls; > >>>>>> - } > >>>>>> > >>>>>> do { > >>>>>> /* Send a sync MDS message */ > >>>>>> diff --git a/osaf/libs/agents/saf/ntfa/ntfa_mds.c > >>>>>> b/osaf/libs/agents/saf/ntfa/ntfa_mds.c > >>>>>> --- a/osaf/libs/agents/saf/ntfa/ntfa_mds.c > >>>>>> +++ b/osaf/libs/agents/saf/ntfa/ntfa_mds.c > >>>>>> @@ -369,7 +369,12 @@ static uint32_t ntfa_mds_svc_evt(struct > >>>>>> TRACE("NTFS down"); > >>>>>> > >>>>>> pthread_mutex_lock(&ntfa_cb.cb_lock); > >>>>>> > >>>>>> memset(&ntfa_cb.ntfs_mds_dest, 0, sizeof(MDS_DEST)); > >>>>>> - ntfa_cb.ntfs_up = 0; > >>>>>> + > >>>>>> + if (mds_cb_info- > >>>>>>> info.svc_evt.i_change == NCSMDS_NO_ACTIVE) { > >>>>>> + > >>>>>> ntfa_update_ntfsv_state(NTFA_NTFSV_NO_ACTIVE); > >>>>>> + } else > >>>>>> + > >>>>>> ntfa_update_ntfsv_state(NTFA_NTFSV_DOWN); > >>>>>> + > >>>>>> > >>>>>> pthread_mutex_unlock(&ntfa_cb.cb_lock); > >>>>>> } > >>>>>> break; > >>>>>> @@ -382,7 +387,12 @@ static uint32_t ntfa_mds_svc_evt(struct > >>>>>> TRACE_2("MSG from NTFS > >>>>>> NCSMDS_NEW_ACTIVE/UP"); > >>>>>> > >>>>>> pthread_mutex_lock(&ntfa_cb.cb_lock); > >>>>>> ntfa_cb.ntfs_mds_dest = > >>>>>> mds_cb_info->info.svc_evt.i_dest; > >>>>>> - ntfa_cb.ntfs_up = 1; > >>>>>> + > >>>>>> + if (mds_cb_info- > >>>>>>> info.svc_evt.i_change == NCSMDS_NEW_ACTIVE) { > >>>>>> + > >>>>>> ntfa_update_ntfsv_state(NTFA_NTFSV_NEW_ACTIVE); > >>>>>> + } else > >>>>>> + > >>>>>> ntfa_update_ntfsv_state(NTFA_NTFSV_UP); > >>>>>> + > >>>>>> if (ntfa_cb.ntfs_sync_awaited) { > >>>>>> /* signal waiting > >>>>>> thread */ > >>>>>> > >>>>>> m_NCS_SEL_OBJ_IND(&ntfa_cb.ntfs_sync_sel); > >>>>>> diff --git a/osaf/libs/agents/saf/ntfa/ntfa_util.c > >>>>>> b/osaf/libs/agents/saf/ntfa/ntfa_util.c > >>>>>> --- a/osaf/libs/agents/saf/ntfa/ntfa_util.c > >>>>>> +++ b/osaf/libs/agents/saf/ntfa/ntfa_util.c > >>>>>> @@ -49,7 +49,7 @@ static unsigned int ntfa_create(void) > >>>>>> } > >>>>>> > >>>>>> /* Block and wait for indication from MDS meaning NTFS is up > >>>>>> */ > >>>>>> - > >>>>>> osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(ntfa_cb.ntfs_s > >>>>>> ync_sel), 30000); > >>>>>> + > >>>>>> osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(ntfa_cb.ntfs_s > >>>>>> ync_sel), 10000); > >>>>>> > >>>>>> pthread_mutex_lock(&ntfa_cb.cb_lock); > >>>>>> ntfa_cb.ntfs_sync_awaited = 0; > >>>>>> @@ -108,7 +108,25 @@ static bool ntfa_clear_mbx(NCSCONTEXT ar > >>>>>> } > >>>>>> return true; > >>>>>> } > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_notification_list_del > >>>>>> > >>>>>> + Description : This routine free element allocated in list of > notification > >>>>>> + > >>>>>> + Arguments : pointer to the list of notification records anchor. > >>>>>> + > >>>>>> + Return Values : None > >>>>>> + > >>>>>> + Notes : > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +static void ntfa_notification_list_del(ntfa_notification_hdl_rec_t > >>>>>> **plstr_hdl) > >>>>>> +{ > >>>>>> + ntfa_notification_hdl_rec_t *lstr_hdl = *plstr_hdl; > >>>>>> + while (lstr_hdl != NULL) { > >>>>>> + ntfa_notification_destructor(lstr_hdl); > >>>>>> + lstr_hdl = lstr_hdl->next; > >>>>>> + } > >>>>>> +} > >>>>>> > >>>>>> > >> > /********************************************************** > >>>>>> ****************** > >>>>>> Name : ntfa_notification_hdl_rec_list_del > >>>>>> > >>>>>> @@ -130,6 +148,70 @@ static void ntfa_notification_hdl_rec_li > >>>>>> lstr_hdl = NULL; > >>>>>> } > >>>>>> } > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_filter_list_del > >>>>>> + > >>>>>> + Description : This routine free element allocated in list of > >>>>>> filter > >>>>>> + > >>>>>> + Arguments : pointer to the list of filters records anchor. > >>>>>> + > >>>>>> + Return Values : None > >>>>>> + > >>>>>> + Notes : > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +static void ntfa_filter_list_del(ntfa_filter_hdl_rec_t **plstr_hdl) > >>>>>> +{ > >>>>>> + ntfa_filter_hdl_rec_t *lstr_hdl = *plstr_hdl; > >>>>>> + > >>>>>> + while (lstr_hdl != NULL) { > >>>>>> + ntfa_filter_destructor(lstr_hdl); > >>>>>> + lstr_hdl = lstr_hdl->next; > >>>>>> + } > >>>>>> +} > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_filter_hdl_rec_list_del > >>>>>> + > >>>>>> + Description : This routine deletes a list of allocated filters > >>>>>> + > >>>>>> + Arguments : pointer to the list of filters records anchor. > >>>>>> + > >>>>>> + Return Values : None > >>>>>> + > >>>>>> + Notes : > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +static void ntfa_filter_hdl_rec_list_del(ntfa_filter_hdl_rec_t > >>>> **plstr_hdl) > >>>>>> +{ > >>>>>> + ntfa_filter_hdl_rec_t *lstr_hdl; > >>>>>> + > >>>>>> + while ((lstr_hdl = *plstr_hdl) != NULL) { > >>>>>> + *plstr_hdl = lstr_hdl->next; > >>>>>> + ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, > >>>>>> lstr_hdl->filter_hdl); > >>>>>> + free(lstr_hdl); > >>>>>> + lstr_hdl = NULL; > >>>>>> + } > >>>>>> +} > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_reader_hdl_rec_list_del > >>>>>> + > >>>>>> + Description : This routine deletes a list of allocated readers > >>>>>> + > >>>>>> + Arguments : pointer to the list of readers records anchor. > >>>>>> + > >>>>>> + Return Values : None > >>>>>> + > >>>>>> + Notes : > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +static void ntfa_reader_hdl_rec_list_del(ntfa_reader_hdl_rec_t > >>>>>> **plstr_hdl) > >>>>>> +{ > >>>>>> + ntfa_reader_hdl_rec_t *lstr_hdl; > >>>>>> + while ((lstr_hdl = *plstr_hdl) != NULL) { > >>>>>> + *plstr_hdl = lstr_hdl->next; > >>>>>> + ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, > >>>>>> lstr_hdl->reader_hdl); > >>>>>> + ntfa_del_ntf_filter_ptrs(&lstr_hdl->filters); > >>>>>> + free(lstr_hdl); > >>>>>> + lstr_hdl = NULL; > >>>>>> + } > >>>>>> +} > >>>>>> > >>>>>> static SaAisErrorT > ntfa_alloc_callback_notification(SaNtfNotificationsT > >>>>>> *notification, > >>>>>> > >>>>>> ntfsv_send_not_req_t *not_cbk, ntfa_client_hdl_rec_t > >>>>>> *hdl_rec) > >>>>>> @@ -407,6 +489,10 @@ static SaAisErrorT ntfa_hdl_cbk_rec_prc( > >>>>>> free(cbk_info- > >>>>>>> param.discarded_cbk.discardedNotificationIdentifiers); > >>>>>> } > >>>>>> break; > >>>>>> + case NTFSV_DUMMY_CALLBACK: > >>>>>> + TRACE("Do nothing with dummy callback, just > >>>>>> return OK"); > >>>>>> + rc = SA_AIS_OK; > >>>>>> + break; > >>>>>> default: > >>>>>> TRACE("unsupported callback type: %d", > >>>>>> cbk_info->type); > >>>>>> rc = SA_AIS_ERR_LIBRARY; > >>>>>> @@ -544,20 +630,21 @@ unsigned int ntfa_startup(void) > >>>>>> * > >>>>>> * @return unsigned int > >>>>>> */ > >>>>>> -unsigned int ntfa_shutdown(void) > >>>>>> +unsigned int ntfa_shutdown(bool forced) > >>>>>> { > >>>>>> unsigned int rc = NCSCC_RC_SUCCESS; > >>>>>> > >>>>>> - TRACE_ENTER2("ntfa_use_count: %u", ntfa_use_count); > >>>>>> + TRACE_ENTER2("ntfa_use_count: %u, forced: %u", > >>>>>> ntfa_use_count, forced); > >>>>>> pthread_mutex_lock(&ntfa_lock); > >>>>>> > >>>>>> - if (ntfa_use_count > 1) { > >>>>>> - /* Users still exist, just decrement the use count > >>>>>> */ > >>>>>> - ntfa_use_count--; > >>>>>> - } else if (ntfa_use_count == 1) { > >>>>>> + if ((forced && (ntfa_use_count > 0)) || (ntfa_use_count == 1)) > >>>>>> { > >>>>>> ntfa_destroy(); > >>>>>> rc = ncs_agents_shutdown(); > >>>>>> ntfa_use_count = 0; > >>>>>> + ntfa_cb.ntfa_ntfsv_state = > >>>>>> NTFA_NTFSV_NONE; > >>>>>> + } else if (ntfa_use_count > 1) { > >>>>>> + /* Users still exist, just decrement the use count > >>>>>> */ > >>>>>> + ntfa_use_count--; > >>>>>> } > >>>>>> > >>>>>> pthread_mutex_unlock(&ntfa_lock); > >>>>>> @@ -633,7 +720,27 @@ ntfa_client_hdl_rec_t *ntfa_find_hdl_rec > >>>>>> > >>>>>> return NULL; > >>>>>> } > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_subscriber_list_del > >>>>>> > >>>>>> + Description : This routine deletes a list of allocated subscribers > >>>>>> + > >>>>>> + Arguments : pointer to the list of subscribers records anchor. > >>>>>> + > >>>>>> + Return Values : None > >>>>>> + > >>>>>> + Notes : > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +void ntfa_subscriber_list_del() > >>>>>> +{ > >>>>>> + ntfa_subscriber_list_t *listPtr = subscriberNoList; > >>>>>> + while (listPtr != NULL) { > >>>>>> + ntfa_subscriber_list_t* tmpSub = listPtr; > >>>>>> + listPtr = listPtr->next; > >>>>>> + free(tmpSub); > >>>>>> + } > >>>>>> + subscriberNoList = NULL; > >>>>>> +} > >>>>>> > >>>>>> > >> > /********************************************************** > >>>>>> ****************** > >>>>>> Name : ntfa_hdl_list_del > >>>>>> > >>>>>> @@ -651,15 +758,24 @@ void ntfa_hdl_list_del(ntfa_client_hdl_r > >>>>>> > >>>>>> while ((client_hdl = *p_client_hdl) != NULL) { > >>>>>> *p_client_hdl = client_hdl->next; > >>>>>> + m_NCS_IPC_DETACH(&client_hdl->mbx, > >>>>>> ntfa_clear_mbx, NULL); > >>>>>> + m_NCS_IPC_RELEASE(&client_hdl->mbx, NULL); > >>>>>> ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, > >>>>>> client_hdl->local_hdl); > >>>>>> /** clean up the channel records for this ntfa-client > >>>>>> **/ > >>>>>> + ntfa_notification_list_del(&client_hdl- > >>>>>>> notification_list); > >>>>>> ntfa_notification_hdl_rec_list_del(&client_hdl- > >>>>>>> notification_list); > >>>>>> + > >>>>>> + ntfa_filter_list_del(&client_hdl->filter_list); > >>>>>> + ntfa_filter_hdl_rec_list_del(&client_hdl- > >>>>>>> filter_list); > >>>>>> + > >>>>>> + ntfa_reader_hdl_rec_list_del(&client_hdl- > >>>>>>> reader_list); > >>>>>> /** remove the association with hdl-mngr > >>>>>> **/ > >>>>>> free(client_hdl); > >>>>>> client_hdl = 0; > >>>>>> } > >>>>>> + ntfa_subscriber_list_del(); > >>>>>> } > >>>>>> > >>>>>> > >>>>>> > >> > /********************************************************** > >>>>>> ****************** > >>>>>> @@ -757,10 +873,80 @@ uint32_t ntfa_filter_hdl_rec_del(ntfa_fi > >>>>>> TRACE("The node couldn't be deleted"); > >>>>>> return NCSCC_RC_FAILURE; > >>>>>> } > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_hdl_rec_force_del > >>>>>> > >>>>>> + Description : This routine deletes all memory allocated to client. > >>>>>> + > >>>>>> + Arguments : NTFA_CLIENT_HDL_REC **list_head > >>>>>> + NTFA_CLIENT_HDL_REC *rm_node > >>>>>> + > >>>>>> + Return Values : None > >>>>>> + > >>>>>> + Notes : > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +void ntfa_hdl_rec_force_del(ntfa_client_hdl_rec_t **list_head, > >>>>>> ntfa_client_hdl_rec_t *rm_node) > >>>>>> +{ > >>>>>> + ntfa_client_hdl_rec_t *list_iter = *list_head; > >>>>>> + TRACE_ENTER(); > >>>>>> + /* First remove the rm_node out of the list of client */ > >>>>>> + if (list_iter == rm_node) > >>>>>> + *list_head = rm_node->next; > >>>>>> + else { > >>>>>> + while (list_iter) { > >>>>>> + if (list_iter->next == rm_node) { > >>>>>> + list_iter->next = > >>>>>> rm_node->next; > >>>>>> + break; > >>>>>> + } > >>>>>> + list_iter = list_iter->next; > >>>>>> + } > >>>>>> + } > >>>>>> + /* Release all msgs in mailbox */ > >>>>>> + ntfsv_msg_t *cbk_msg; > >>>>>> + while((cbk_msg = > >>>>>> (ntfsv_msg_t*)m_NCS_IPC_NON_BLK_RECEIVE(&rm_node->mbx, > >>>>>> cbk_msg)) > >>>>>> + != NULL) { > >>>>>> + ntfa_msg_destroy(cbk_msg); > >>>>>> + } > >>>>>> + /* delete subscriber of this client out of the subcriberNoList*/ > >>>>>> + ntfa_subscriber_list_t* subscriber_hdl = subscriberNoList; > >>>>>> + while (subscriber_hdl != NULL) { > >>>>>> + ntfa_subscriber_list_t *rm_subscriber = > >>>>>> subscriber_hdl; > >>>>>> + subscriber_hdl = subscriber_hdl->next; > >>>>>> + if (rm_node->local_hdl == rm_subscriber- > >>>>>>> subscriberListNtfHandle) { > >>>>>> + if (rm_subscriber->next != NULL) { > >>>>>> + rm_subscriber- > >>>>>>> next->prev = rm_subscriber->prev; > >>>>>> + } > >>>>>> + > >>>>>> + if (rm_subscriber->prev != NULL) { > >>>>>> + rm_subscriber- > >>>>>>> prev->next = rm_subscriber->next; > >>>>>> + } else { > >>>>>> + if (rm_subscriber- > >>>>>>> next != NULL) > >>>>>> + > >>>>>> subscriberNoList = rm_subscriber->next; > >>>>>> + else > >>>>>> + > >>>>>> subscriberNoList = NULL; > >>>>>> + } > >>>>>> + > >>>>>> ntfa_del_ntf_filter_ptrs(&rm_subscriber->filters); > >>>>>> + free(rm_subscriber); > >>>>>> + } > >>>>>> + } > >>>>>> + /* Now delete client */ > >>>>>> + m_NCS_IPC_DETACH(&rm_node->mbx, ntfa_clear_mbx, > >>>>>> NULL); > >>>>>> + m_NCS_IPC_RELEASE(&rm_node->mbx, NULL); > >>>>>> + ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, rm_node- > >>>>>>> local_hdl); > >>>>>> + ntfa_notification_list_del(&rm_node->notification_list); > >>>>>> + ntfa_notification_hdl_rec_list_del(&rm_node- > >>>>>>> notification_list); > >>>>>> + > >>>>>> + ntfa_filter_list_del(&rm_node->filter_list); > >>>>>> + ntfa_filter_hdl_rec_list_del(&rm_node->filter_list); > >>>>>> + > >>>>>> + ntfa_reader_hdl_rec_list_del(&rm_node->reader_list); > >>>>>> + free(rm_node); > >>>>>> + > >>>>>> + TRACE_LEAVE(); > >>>>>> +} > >>>>>> > >>>>>> > >> > /********************************************************** > >>>>>> ****************** > >>>>>> Name : ntfa_hdl_rec_del > >>>>>> - > >>>>>> + > >>>>>> Description : This routine deletes the a client handle record > >>>>>> from > >>>>>> a list of client hdl records. > >>>>>> > >>>>>> @@ -962,7 +1148,7 @@ ntfa_client_hdl_rec_t *ntfa_hdl_rec_add( > >>>>>> /** Associate with the client_id obtained from NTFS > >>>>>> **/ > >>>>>> rec->ntfs_client_id = client_id; > >>>>>> - > >>>>>> + rec->valid = true; > >>>>>> /** Initialize and attach the IPC/Priority queue > >>>>>> **/ > >>>>>> > >>>>>> @@ -1063,7 +1249,7 @@ static void logtrace_init_constructor(vo > >>>>>> * > >>>>>> * @param instance > >>>>>> */ > >>>>>> -void ntfa_hdl_rec_destructor(ntfa_notification_hdl_rec_t > *instance) > >>>>>> +void ntfa_notification_destructor(ntfa_notification_hdl_rec_t > >>>> *instance) > >>>>>> { > >>>>>> ntfa_notification_hdl_rec_t *notificationInstance = instance; > >>>>>> > >>>>>> @@ -1111,7 +1297,7 @@ void ntfa_hdl_rec_destructor(ntfa_notifi > >>>>>> * > >>>>>> * @param instance > >>>>>> */ > >>>>>> -void ntfa_filter_hdl_rec_destructor(ntfa_filter_hdl_rec_t > *filter_rec) > >>>>>> +void ntfa_filter_destructor(ntfa_filter_hdl_rec_t *filter_rec) > >>>>>> { > >>>>>> switch (filter_rec->ntfType) { > >>>>>> case SA_NTF_TYPE_OBJECT_CREATE_DELETE: > >>>>>> @@ -1202,6 +1388,7 @@ uint32_t ntfa_reader_hdl_rec_del(ntfa_re > >>>>>> **/ > >>>>>> ncshm_give_hdl(rm_node->reader_hdl); > >>>>>> ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, > >>>>>> rm_node->reader_hdl); > >>>>>> + ntfa_del_ntf_filter_ptrs(&rm_node->filters); > >>>>>> free(rm_node); > >>>>>> return NCSCC_RC_SUCCESS; > >>>>>> } else { /* find the rec */ > >>>>>> @@ -1213,6 +1400,7 @@ uint32_t ntfa_reader_hdl_rec_del(ntfa_re > >>>>>> **/ > >>>>>> > >>>>>> ncshm_give_hdl(rm_node->reader_hdl); > >>>>>> > >>>>>> ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, rm_node- > >>>>>>> reader_hdl); > >>>>>> + > >>>>>> ntfa_del_ntf_filter_ptrs(&rm_node->filters); > >>>>>> free(rm_node); > >>>>>> return > >>>>>> NCSCC_RC_SUCCESS; > >>>>>> } > >>>>>> @@ -1258,3 +1446,258 @@ void > ntfa_add_to_async_cbk_msg_list(ntfs > >>>>>> > >>>>>> TRACE_LEAVE(); > >>>>>> } > >>>>>> + > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_notify_handle_invalid > >>>>>> + > >>>>>> + Description : This routine sends a dummy callback msg to client's > >>>> mailbox > >>>>>> + so that the client polls in and calls > >>>>>> saNtfDispatch. > >>>>>> + Arguments : > >>>>>> + > >>>>>> + Return Values : None > >>>>>> + > >>>>>> + Notes : None > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +void ntfa_notify_handle_invalid() { > >>>>>> + ntfa_client_hdl_rec_t *client_hdl = ntfa_cb.client_list; > >>>>>> + TRACE_ENTER(); > >>>>>> + while (client_hdl != NULL) { > >>>>>> + /* Only applicable for subscriber */ > >>>>>> + if (client_hdl->reg_cbk.saNtfNotificationCallback > >>>>>> != NULL || > >>>>>> + client_hdl- > >>>>>>> reg_cbk.saNtfNotificationDiscardedCallback != NULL) { > >>>>>> + /* Create a dummy msg */ > >>>>>> + ntfsv_msg_t *msg = > >>>>>> malloc(sizeof(ntfsv_msg_t)); > >>>>>> + memset(msg, 0, > >>>>>> sizeof(ntfsv_msg_t)); > >>>>>> + msg->info.cbk_info.type = > >>>>>> NTFSV_DUMMY_CALLBACK; > >>>>>> + /* Send dummy msg to client > >>>>>> mailbox */ > >>>>>> + if > >>>>>> (m_NCS_IPC_SEND(&client_hdl->mbx, msg, > >>>> MDS_SEND_PRIORITY_HIGH) != > >>>>>> NCSCC_RC_SUCCESS) { > >>>>>> + > >>>>>> TRACE_1("m_NCS_IPC_SEND Failed to client(id:%u)", > >>>>>> client_hdl->ntfs_client_id); > >>>>>> + > >>>>>> ntfa_msg_destroy(msg); > >>>>>> + } > >>>>>> + } > >>>>>> + > >>>>>> + client_hdl = client_hdl->next; > >>>>>> + } > >>>>>> + TRACE_LEAVE(); > >>>>>> +} > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_update_ntfsv_state > >>>>>> + > >>>>>> + Description : Update current NTF Server state by the > >> @changedState > >>>>>> indicated > >>>>>> + by MDS event > >>>>>> + Arguments : @changedState [IN]: state to be changed of NTF > >> Server > >>>>>> + > >>>>>> + Return Values : None > >>>>>> + > >>>>>> + Notes : None > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +void ntfa_update_ntfsv_state(ntfa_ntfsv_state_t changedState) > >>>>>> +{ > >>>>>> + TRACE_ENTER(); > >>>>>> + TRACE_1("Current state: %u, Changed state: %u", > >>>>>> ntfa_cb.ntfa_ntfsv_state, > >>>>>> + > >>>>>> > >>>>>> changedState); > >>>>>> + > >>>>>> + ntfa_client_hdl_rec_t *client_hdl = ntfa_cb.client_list; > >>>>>> + > >>>>>> + switch (ntfa_cb.ntfa_ntfsv_state){ > >>>>>> + case NTFA_NTFSV_NONE: > >>>>>> + ntfa_cb.ntfa_ntfsv_state = changedState; > >>>>>> + break; > >>>>>> + case NTFA_NTFSV_DOWN: > >>>>>> + if (changedState == NTFA_NTFSV_NEW_ACTIVE > >>>>>> || > >>>>>> + changedState == > >>>>>> NTFA_NTFSV_UP) { > >>>>>> + TRACE("Active NTF server has > >>>>>> been restarted"); > >>>>>> + ntfa_cb.ntfa_ntfsv_state = > >>>>>> NTFA_NTFSV_UP; > >>>>>> + ntfa_notify_handle_invalid(); > >>>>>> + } else > >>>>>> + TRACE("Unexpected state > >>>>>> changes"); > >>>>>> + break; > >>>>>> + case NTFA_NTFSV_NO_ACTIVE: > >>>>>> + if (changedState == > >>>>>> NTFA_NTFSV_NEW_ACTIVE) { > >>>>>> + TRACE("Standby NTF server > >>>>>> becomes new Active"); > >>>>>> + /* NTF server is functioning > >>>>>> normally */ > >>>>>> + ntfa_cb.ntfa_ntfsv_state = > >>>>>> NTFA_NTFSV_UP; > >>>>>> + } else if (changedState == NTFA_NTFSV_DOWN) > >>>>>> { > >>>>>> + TRACE("Active NTF Server is > >>>>>> Down"); > >>>>>> + ntfa_cb.ntfa_ntfsv_state = > >>>>>> NTFA_NTFSV_DOWN; > >>>>>> + /* Mark all client handles are > >>>>>> invalid */ > >>>>>> + while (client_hdl != NULL) { > >>>>>> + client_hdl->valid = > >>>>>> false; > >>>>>> + client_hdl = > >>>>>> client_hdl->next; > >>>>>> + } > >>>>>> + } > >>>>>> + break; > >>>>>> + case NTFA_NTFSV_NEW_ACTIVE: > >>>>>> + TRACE("Unknown"); > >>>>>> + break; > >>>>>> + case NTFA_NTFSV_UP: > >>>>>> + if (changedState == NTFA_NTFSV_NO_ACTIVE) { > >>>>>> + TRACE("Active NTF server > >>>>>> temporarily unavailable"); > >>>>>> + /* Failover/Switchover is > >>>>>> happening > >>>>>> + * Any API calls result in > >>>>>> TRY_AGAIN > >>>>>> + */ > >>>>>> + ntfa_cb.ntfa_ntfsv_state = > >>>>>> NTFA_NTFSV_NO_ACTIVE; > >>>>>> + } else > >>>>>> + TRACE("Unexpected state > >>>>>> changes"); > >>>>>> + break; > >>>>>> + default: > >>>>>> + osafassert(false); > >>>>>> + } > >>>>>> + > >>>>>> + TRACE_LEAVE(); > >>>>>> +} > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_copy_ntf_filter_ptrs > >>>>>> + > >>>>>> + Description : Copy a list of filter from pSrc to pDes > >>>>>> + > >>>>>> + Arguments : pDes* [OUT]: list of outcome filter > >>>>>> + pSrc* [IN]: list of input filter > >>>>>> + > >>>>>> + Return Values : SA_AIS_OK if succeed, other values as failed > >>>>>> + > >>>>>> + Notes : None > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +SaAisErrorT ntfa_copy_ntf_filter_ptrs(ntfsv_filter_ptrs_t* pDes, > >>>>>> + > >>>>>> const ntfsv_filter_ptrs_t* pSrc) { > >>>>>> + SaAisErrorT rc = SA_AIS_OK; > >>>>>> + SaNtfNotificationFilterHeaderT *des_header; > >>>>>> + SaNtfNotificationFilterHeaderT *src_header; > >>>>>> + TRACE_ENTER(); > >>>>>> + > >>>>>> + if (pSrc->alarm_filter) { > >>>>>> + pDes->alarm_filter = calloc(1, > >>>>>> sizeof(SaNtfAlarmNotificationFilterT)); > >>>>>> + des_header = &(pDes->alarm_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + src_header = &(pSrc->alarm_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + if ((rc = ntfsv_filter_header_alloc(des_header, > >>>>>> src_header->numEventTypes, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotifyingObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationClassIds)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_filter_alarm_alloc(pDes- > >>>>>>> alarm_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->alarm_filter->numProbableCauses, > >>>>>> + > >>>>>> > >>>>>> pSrc->alarm_filter->numPerceivedSeverities, > >>>>>> + > >>>>>> > >>>>>> pSrc->alarm_filter->numTrends)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_copy_ntf_filter_alarm(pDes- > >>>>>>> alarm_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->alarm_filter)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + if (pSrc->sec_al_filter) { > >>>>>> + pDes->sec_al_filter = calloc(1, > >>>>>> sizeof(SaNtfSecurityAlarmNotificationFilterT)); > >>>>>> + des_header = &(pDes->sec_al_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + src_header = &(pSrc->sec_al_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + if ((rc = ntfsv_filter_header_alloc(des_header, > >>>>>> src_header->numEventTypes, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotifyingObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationClassIds)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_filter_sec_alarm_alloc(pDes- > >>>>>>> sec_al_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->sec_al_filter->numProbableCauses, > >>>>>> + > >>>>>> > >>>>>> pSrc->sec_al_filter->numSeverities, > >>>>>> + > >>>>>> > >>>>>> pSrc->sec_al_filter->numSecurityAlarmDetectors, > >>>>>> + > >>>>>> > >>>>>> pSrc->sec_al_filter->numServiceUsers, > >>>>>> + > >>>>>> > >>>>>> pSrc->sec_al_filter->numServiceProviders)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_copy_ntf_filter_sec_alarm(pDes- > >>>>>>> sec_al_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->sec_al_filter)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + if (pSrc->sta_ch_filter) { > >>>>>> + pDes->sta_ch_filter = calloc(1, > >>>>>> sizeof(SaNtfStateChangeNotificationFilterT)); > >>>>>> + des_header = &(pDes->sta_ch_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + src_header = &(pSrc->sta_ch_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + if ((rc = ntfsv_filter_header_alloc(des_header, > >>>>>> src_header->numEventTypes, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotifyingObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationClassIds)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_filter_state_ch_alloc(pDes- > >>>>>>> sta_ch_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->sta_ch_filter->numSourceIndicators, > >>>>>> + > >>>>>> > >>>>>> pSrc->sta_ch_filter->numStateChanges)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_copy_ntf_filter_state_ch(pDes- > >>>>>>> sta_ch_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->sta_ch_filter)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + if (pSrc->obj_cr_del_filter) { > >>>>>> + pDes->obj_cr_del_filter = calloc(1, > >>>>>> sizeof(SaNtfObjectCreateDeleteNotificationFilterT)); > >>>>>> + des_header = &(pDes->obj_cr_del_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + src_header = &(pSrc->obj_cr_del_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + if ((rc = ntfsv_filter_header_alloc(des_header, > >>>>>> src_header->numEventTypes, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotifyingObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationClassIds)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_filter_obj_cr_del_alloc(pDes- > >>>>>>> obj_cr_del_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->obj_cr_del_filter->numSourceIndicators)) != > >>>>>> SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_copy_ntf_filter_obj_cr_del(pDes- > >>>>>>> obj_cr_del_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->obj_cr_del_filter)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + } > >>>>>> + > >>>>>> + if (pSrc->att_ch_filter) { > >>>>>> + pDes->att_ch_filter = calloc(1, > >>>>>> sizeof(SaNtfAttributeChangeNotificationFilterT)); > >>>>>> + des_header = &(pDes->att_ch_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + src_header = &(pSrc->att_ch_filter- > >>>>>>> notificationFilterHeader); > >>>>>> + if ((rc = ntfsv_filter_header_alloc(des_header, > >>>>>> src_header->numEventTypes, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotifyingObjects, > >>>>>> + > >>>>>> > >>>>>> src_header->numNotificationClassIds)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_filter_attr_change_alloc(pDes- > >>>>>>> att_ch_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->att_ch_filter->numSourceIndicators)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + if ((rc = ntfsv_copy_ntf_filter_attr_ch(pDes- > >>>>>>> att_ch_filter, > >>>>>> + > >>>>>> > >>>>>> pSrc->att_ch_filter)) != SA_AIS_OK) > >>>>>> + goto done; > >>>>>> + } > >>>>>> +done: > >>>>>> + TRACE_LEAVE(); > >>>>>> + return rc; > >>>>>> +} > >>>>>> + > >>>>>> > >> > +/********************************************************* > >>>>>> ******************* > >>>>>> + Name : ntfa_del_ntf_filter_ptrs > >>>>>> + > >>>>>> + Description : Delete the filter pointers > >>>>>> + > >>>>>> + Arguments : filter_ptrs* [IN/OUT]: filter pointers > >>>>>> + > >>>>>> + Return Values : SA_AIS_OK if succeed, other values as failed > >>>>>> + > >>>>>> + Notes : None > >>>>>> > >> > +********************************************************* > >>>>>> *********************/ > >>>>>> +SaAisErrorT ntfa_del_ntf_filter_ptrs(ntfsv_filter_ptrs_t* > filter_ptrs) > >>>>>> +{ > >>>>>> + SaAisErrorT rc = SA_AIS_OK; > >>>>>> + if (filter_ptrs->alarm_filter) { > >>>>>> + ntfsv_filter_alarm_free(filter_ptrs- > >>>>>>> alarm_filter, true); > >>>>>> + free(filter_ptrs->alarm_filter); > >>>>>> + } > >>>>>> + > >>>>>> + if (filter_ptrs->sec_al_filter) { > >>>>>> + ntfsv_filter_sec_alarm_free(filter_ptrs- > >>>>>>> sec_al_filter, true); > >>>>>> + free(filter_ptrs->sec_al_filter); > >>>>>> + } > >>>>>> + > >>>>>> + if (filter_ptrs->sta_ch_filter) { > >>>>>> + ntfsv_filter_state_ch_free(filter_ptrs- > >>>>>>> sta_ch_filter, true); > >>>>>> + free(filter_ptrs->sta_ch_filter); > >>>>>> + } > >>>>>> + > >>>>>> + if (filter_ptrs->obj_cr_del_filter) { > >>>>>> + ntfsv_filter_obj_cr_del_free(filter_ptrs- > >>>>>>> obj_cr_del_filter, true); > >>>>>> + free(filter_ptrs->obj_cr_del_filter); > >>>>>> + } > >>>>>> + > >>>>>> + if (filter_ptrs->att_ch_filter) { > >>>>>> + ntfsv_filter_attr_ch_free(filter_ptrs- > >>>>>>> att_ch_filter, true); > >>>>>> + free(filter_ptrs->att_ch_filter); > >>>>>> + } > >>>>>> + return rc; > >>>>>> +} > > ------------------------------------------------------------------------------ Transform Data into Opportunity. Accelerate data analysis in your applications with Intel Data Analytics Acceleration Library. Click to learn more. http://pubads.g.doubleclick.net/gampad/clk?id=278785231&iu=/4140 _______________________________________________ Opensaf-devel mailing list Opensaf-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/opensaf-devel
