/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <time.h> #include <signal.h> #include <poll.h> #include "isns_server.h" #include "isns_cache.h" #include "isns_obj.h" #include "isns_pdu.h" #include "isns_func.h" #include "isns_qry.h" #include "isns_msgq.h" #include "isns_log.h" #include "isns_sched.h" #include "isns_scn.h" #include "isns_esi.h" /* * global variables. */ /* * local variables. */ static ev_t *ev_list = NULL; static uint32_t stopwatch = 0; static pthread_mutex_t stw_mtx = PTHREAD_MUTEX_INITIALIZER; static int wakeup = 0; static pthread_mutex_t idl_mtx = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t idl_cond = PTHREAD_COND_INITIALIZER; /* * external variables. */ extern const int UID_ATTR_INDEX[MAX_OBJ_TYPE_FOR_SIZE]; extern boolean_t time_to_exit; extern msg_queue_t *sys_q; extern uint64_t esi_threshold; #ifdef DEBUG extern void dump_pdu1(isns_pdu_t *); #endif /* * local functions. */ static void *esi_monitor(void *); /* * **************************************************************************** * * new_esi_portal: * Make a new portal for ESI event. * * uid - the portal object UID. * ip6 - the portal IPv6 format IP address. * port - the portal port. * esip - the ESI port. * return - the new ESI portal. * * **************************************************************************** */ static esi_portal_t * new_esi_portal( uint32_t uid, in6_addr_t *ip6, uint32_t port, uint32_t esip ) { esi_portal_t *p; p = (esi_portal_t *)malloc(sizeof (esi_portal_t)); if (p != NULL) { if (((int *)ip6)[0] == 0x00 && ((int *)ip6)[1] == 0x00 && ((uchar_t *)ip6)[8] == 0x00 && ((uchar_t *)ip6)[9] == 0x00 && ((uchar_t *)ip6)[10] == 0xFF && ((uchar_t *)ip6)[11] == 0xFF) { p->sz = sizeof (in_addr_t); p->ip4 = ((uint32_t *)ip6)[3]; } else { p->sz = sizeof (in6_addr_t); } p->ip6 = ip6; p->port = port; p->esip = esip; p->ref = uid; p->so = 0; p->next = NULL; } return (p); } /* * **************************************************************************** * * free_esi_portal: * Free a list of portal of one ESI event. * * p - the ESI portal. * * **************************************************************************** */ static void free_esi_portal( esi_portal_t *p ) { esi_portal_t *n; while (p != NULL) { n = p->next; free(p->ip6); free(p); p = n; } } /* * **************************************************************************** * * ev_new: * Make a new ESI event. * * uid - the Entity object UID. * eid - the Entity object name. * len - the length of the name. * return - the ESI event. * * **************************************************************************** */ static ev_t * ev_new( uint32_t uid, uchar_t *eid, uint32_t len ) { ev_t *ev; ev = (ev_t *)malloc(sizeof (ev_t)); if (ev != NULL) { if (pthread_mutex_init(&ev->mtx, NULL) != 0 || (ev->eid = (uchar_t *)malloc(len)) == NULL) { free(ev); return (NULL); } ev->uid = uid; (void) strcpy((char *)ev->eid, (char *)eid); ev->eid_len = len; /* initialization time */ ev->flags = EV_FLAG_INIT; } return (ev); } /* * **************************************************************************** * * cb_portal_uids: * Callback function which makes a copy of the portal child object * UIDs from a Network Entity object. * * p1 - the Network Entity object. * p2 - the lookup control data. * return - the number of portal object UIDs. * * **************************************************************************** */ static int cb_portal_uids( void *p1, void *p2 ) { isns_obj_t *obj = (isns_obj_t *)p1; lookup_ctrl_t *lcp = (lookup_ctrl_t *)p2; isns_attr_t *attr; uint32_t *cuidp; uint32_t num = 0; uint32_t *p = NULL; cuidp = get_child_t(obj, OBJ_PORTAL); if (cuidp != NULL) { p = (uint32_t *)malloc(*cuidp * sizeof (*p)); if (p != NULL) { num = *cuidp ++; (void) memcpy(p, cuidp, num * sizeof (*p)); lcp->data[1].ptr = (uchar_t *)p; } } attr = &obj->attrs[ATTR_INDEX_ENTITY(ISNS_ENTITY_REG_PERIOD_ATTR_ID)]; if (attr->tag != 0 && attr->value.ui != 0) { lcp->data[2].ui = attr->value.ui; } else { /* just one second before the end of the world */ lcp->data[2].ui = INFINITY - 1; } return (num); } /* * **************************************************************************** * * cb_esi_portal: * Callback function which gets ESI port number and ESI interval * from a portal object. * * p1 - the Portal object. * p2 - the lookup control data. * return - the ESI interval. * * **************************************************************************** */ static int cb_esi_portal( void *p1, void *p2 ) { uint32_t intval = 0; isns_obj_t *obj; lookup_ctrl_t *lcp; in6_addr_t *ip; uint32_t esip; isns_attr_t *attr; if (cb_clone_attrs(p1, p2) == 0) { obj = (isns_obj_t *)p1; lcp = (lookup_ctrl_t *)p2; ip = lcp->data[1].ip; esip = lcp->data[2].ui; if (esip != 0) { attr = &obj->attrs[ATTR_INDEX_PORTAL( ISNS_PORTAL_PORT_ATTR_ID)]; lcp->data[0].ui = attr->value.ui; attr = &obj->attrs[ATTR_INDEX_PORTAL( ISNS_ESI_INTERVAL_ATTR_ID)]; if (attr->tag != 0 && attr->value.ui != 0) { intval = attr->value.ui; } else { intval = DEFAULT_ESI_INTVAL; } } else { free(ip); } } return ((int)intval); } /* * **************************************************************************** * * extract_esi_portal: * Extract a list of portal which have an ESI port for an Entity. * * uid - the Entity object UID. * intval - the ESI interval for returnning. * return - the list of portals. * * **************************************************************************** */ static esi_portal_t * extract_esi_portal( uint32_t uid, uint32_t *intval ) { esi_portal_t *list = NULL; esi_portal_t *p; lookup_ctrl_t lc; uint32_t num_of_portal; uint32_t *portal_uids; uint32_t intv; /* prepare for looking up entity object */ SET_UID_LCP(&lc, OBJ_ENTITY, uid); lc.data[1].ptr = NULL; lc.data[2].ui = INFINITY - 1; /* get the array of the portal uid(s) */ num_of_portal = (uint32_t)cache_lookup(&lc, NULL, cb_portal_uids); portal_uids = (uint32_t *)lc.data[1].ptr; *intval = lc.data[2].ui; /* prepare for looking up portal object(s) */ SET_UID_LCP(&lc, OBJ_PORTAL, 0); lc.id[1] = ISNS_PORTAL_IP_ADDR_ATTR_ID; lc.id[2] = ISNS_ESI_PORT_ATTR_ID; FOR_EACH_OBJS(portal_uids, num_of_portal, uid, { if (uid != 0) { lc.data[0].ui = uid; intv = cache_lookup(&lc, NULL, cb_esi_portal); if (intv != 0) { p = new_esi_portal(uid, (in6_addr_t *)lc.data[1].ip, lc.data[0].ui, lc.data[2].ui); if (p != NULL) { p->next = list; list = p; if (*intval > intv) { *intval = intv; } } } } }); /* free up the portal uid array */ free(portal_uids); return (list); } /* * **************************************************************************** * * ev_add: * Add an ESI event. * * ev - the ESI event. * init - 0: initialization time, otherwise not. * return - error code. * * **************************************************************************** */ static int ev_add( ev_t *ev, int init ) { uint32_t intval; esi_portal_t *p; double rnd; uint32_t t = 0; /* get the portal(s) which are registered for ESI monitoring */ /* and the second interval for ESI or registration expiration */ p = extract_esi_portal(ev->uid, &intval); ev->intval = intval; if (p != NULL) { ev->type = EV_ESI; ev->portal = p; /* avoid running everything at the same time */ if (init != 0) { /* generate random number within range (0, 1] */ rnd = (rand() + 1) / (double)(RAND_MAX + 1); t = (uint32_t)(intval * rnd); } } else { /* no portal is registered for ESI monitoring, make */ /* an entry for entity registration expiration */ ev->type = EV_REG_EXP; ev->portal = NULL; if (init != 0) { t = intval; } } /* schedule the event */ return (el_add(ev, t, NULL)); } /* * global functions. */ /* * **************************************************************************** * * sigalrm: * The signal handler for SIGALRM, the ESI proc uses the SIGALRM * for waking up to perform the client status inquery. * * sig - the signal. * * **************************************************************************** */ /*ARGSUSED*/ void sigalrm( int sig ) { /* wake up the idle */ (void) pthread_mutex_lock(&idl_mtx); wakeup = 1; /* wake up naturally */ (void) pthread_cond_signal(&idl_cond); (void) pthread_mutex_unlock(&idl_mtx); } /* * **************************************************************************** * * esi_load: * Load an ESI event from data store. * * uid - the Entity object UID. * eid - the Entity object name. * len - the length of the name. * return - error code. * * **************************************************************************** */ int esi_load( uint32_t uid, uchar_t *eid, uint32_t len ) { int ec = 0; /* make a new event */ ev_t *ev = ev_new(uid, eid, len); /* put the new event to the list */ if (ev != NULL) { ev->next = ev_list; ev_list = ev; } else { ec = ISNS_RSP_INTERNAL_ERROR; } return (ec); } /* * **************************************************************************** * * verify_esi_portal: * Verify ESI port and add the ESI entries after the ESI are loaded. * * return - error code. * * **************************************************************************** */ int verify_esi_portal( ) { int ec = 0; ev_t *ev; /* add each event from the list */ while (ev_list != NULL && ec == 0) { ev = ev_list; ev_list = ev->next; ev->next = NULL; ec = ev_add(ev, 1); } return (ec); } /* * **************************************************************************** * * esi_add: * Add a new ESI event when a new Entity is registered. * * uid - the Entity object UID. * eid - the Entity object name. * len - the length of the name. * return - error code. * * **************************************************************************** */ int esi_add( uint32_t uid, uchar_t *eid, uint32_t len ) { int ec = 0; /* make a new event */ ev_t *ev = ev_new(uid, eid, len); if (ev != NULL) { /* interrupt idle */ ev->flags |= EV_FLAG_WAKEUP; ec = ev_add(ev, 0); } else { ec = ISNS_RSP_INTERNAL_ERROR; } return (ec); } /* * **************************************************************************** * * esi_remove: * Remove an ESI event immediately. * * uid - the Entity object UID. * return - always successful. * * **************************************************************************** */ int esi_remove( uint32_t uid ) { (void) el_remove(uid, 0, 0); return (0); } /* * **************************************************************************** * * esi_remove_obj: * Update an ESI event when a Entity object or a Portal object is * removed from server. If the object is being removed because of * ESI failure, the ESI event will be removed with a pending time, * otherwise, the ESI will be removed immediately. * * obj - the object being removed. * pending - the pending flag. * return - always successful. * * **************************************************************************** */ int esi_remove_obj( const isns_obj_t *obj, int pending ) { uint32_t puid, uid; switch (obj->type) { case OBJ_PORTAL: puid = get_parent_uid(obj); uid = get_obj_uid(obj); break; case OBJ_ENTITY: puid = get_obj_uid(obj); uid = 0; break; default: puid = 0; break; } if (puid != 0) { (void) el_remove(puid, uid, pending); } return (0); } /* * **************************************************************************** * * get_stopwatch: * Get the stopwatch. It might need to signal the condition to * wake up the idle so the stopwatch gets updated. * * flag - wake up flag. * return - the stopwatch. * * **************************************************************************** */ uint32_t get_stopwatch( int flag ) { uint32_t t; /* not re-schedule, wake up idle */ (void) pthread_mutex_lock(&idl_mtx); if (flag != 0) { wakeup = 2; /* wake up manually */ (void) pthread_cond_signal(&idl_cond); } else { wakeup = 0; /* clear previous interruption */ } (void) pthread_mutex_unlock(&idl_mtx); /* get most current time */ (void) pthread_mutex_lock(&stw_mtx); t = stopwatch; (void) pthread_mutex_unlock(&stw_mtx); return (t); } /* * **************************************************************************** * * ev_intval: * Get the time interval of an ESI event. * * p - the ESI event. * return - the time interval. * * **************************************************************************** */ uint32_t ev_intval( void *p ) { return (((ev_t *)p)->intval); } /* * **************************************************************************** * * ev_match: * Check the ESI event maching an Entity object. * * p - the ESI event. * uid - the Entity object UID. * return - 1: match, otherwise not. * * **************************************************************************** */ int ev_match( void *p, uint32_t uid ) { if (((ev_t *)p)->uid == uid) { return (1); } else { return (0); } } /* * **************************************************************************** * * ev_remove: * Remove a portal or an ESI event. If all of ESI portal has been * removed, the ESI event will be marked as removal pending, which * will result in removing the Entity object after the pending time. * * p - the ESI event. * portal_uid - the Portal object UID. * flag - 0: the ESI is currently in use, otherwise it is scheduled. * pending - flag for the ESI removal pending. * return - 0: the ESI is physically removed, otherwise not. * * **************************************************************************** */ int ev_remove( void *p, uint32_t portal_uid, int flag, int pending ) { ev_t *ev = (ev_t *)p; esi_portal_t **pp, *portal; int has_portal = 0; int state; /* remove one portal only */ if (portal_uid != 0) { pp = &ev->portal; portal = *pp; while (portal != NULL) { /* found the match portal */ if (portal->ref == portal_uid) { /* mark it as removed */ portal->ref = 0; if (flag != 0) { /* not in use, remove it physically */ *pp = portal->next; portal->next = NULL; free_esi_portal(portal); } else { pp = &portal->next; } } else { /* one or more esi portals are available */ if (portal->ref != 0) { has_portal = 1; } pp = &portal->next; } portal = *pp; } } /* no portal available */ if (has_portal == 0) { state = (pending << 1) | flag; switch (state) { case 0x0: /* mark the event as removed */ ev->flags |= EV_FLAG_REMOVE; isnslog(LOG_DEBUG, "ev_remove", "%s [%d] is marked as removed.", ev->type == EV_ESI ? "ESI" : "REG_EXP", ev->uid); break; case 0x1: /* physically remove the event */ ev_free(ev); break; case 0x2: case 0x3: /* mark the event as removal pending */ isnslog(LOG_DEBUG, "ev_remove", "%s [%d] is marked as removal pending.", ev->type == EV_ESI ? "ESI" : "REG_EXP", ev->uid); ev->flags |= EV_FLAG_REM_P1; has_portal = 1; break; default: break; } } else { isnslog(LOG_DEBUG, "ev_remove", "%s [%d] removed portal %d.", ev->type == EV_ESI ? "ESI" : "REG_EXP", ev->uid, portal_uid); } return (has_portal); } /* * **************************************************************************** * * ev_free: * Free an ESI event. * * p - the ESI event. * * **************************************************************************** */ void ev_free( void *p ) { ev_t *ev = (ev_t *)p; /* free up all of portals */ free_esi_portal(ev->portal); isnslog(LOG_DEBUG, "ev_free", "%s [%d] is physically removed.", ev->type == EV_ESI ? "ESI" : "REG_EXP", ev->uid); free(ev->eid); /* free the event */ free(ev); } /* * **************************************************************************** * * evf_init: * Check the initial flag of an ESI event. * * p - the ESI event. * return - 0: not initial, otherwise yes. * * **************************************************************************** */ int evf_init( void *p ) { return (((ev_t *)p)->flags & EV_FLAG_INIT); } /* * **************************************************************************** * * evf_again: * Check the again flag of an ESI event. * (this flag might be eliminated and use the init flag.) * * p - the ESI event. * return - 0: not again, otherwise yes. * * **************************************************************************** */ int evf_again( void *p ) { return (((ev_t *)p)->flags & EV_FLAG_AGAIN); } /* * **************************************************************************** * * evf_wakeup: * Check the wakeup flag of an ESI event. The idle might need to * wake up before the event is scheduled. * * p - the ESI event. * return - 0: no wakeup, otherwise yes. * * **************************************************************************** */ int evf_wakeup( void *p ) { return (((ev_t *)p)->flags & EV_FLAG_WAKEUP); } /* * **************************************************************************** * * evf_rem: * Check the removal flag of an ESI event. The ESI entry might be * marked as removal. * * p - the ESI event. * return - 0: not removed, otherwise yes. * * **************************************************************************** */ int evf_rem( void *p ) { return (((ev_t *)p)->flags & EV_FLAG_REMOVE); } /* * **************************************************************************** * * evf_rem_pending: * Check the removal pending flag of an ESI event. The ESI entry * might be marked as removal pending. If it is, we will switch the * event type and change the time interval. * * p - the ESI event. * return - 0: not removal pending, otherwise yes. * * **************************************************************************** */ int evf_rem_pending( void *p ) { ev_t *ev = (ev_t *)p; if ((ev->flags & EV_FLAG_REM_P) != 0) { if (ev->type != EV_REG_EXP) { isnslog(LOG_DEBUG, "ev_rem_pending", "%s [%d] is changed to REG_EXP.", ev->type == EV_ESI ? "ESI" : "REG_EXP", ev->uid); ev->type = EV_REG_EXP; ev->intval *= 2; /* after 2 ESI interval */ } return (1); } return (0); } /* * **************************************************************************** * * evf_zero: * Reset the event flag. * * p - the ESI event. * * **************************************************************************** */ void evf_zero( void *p ) { ev_t *ev = (ev_t *)p; /* not acutally clear it, need to set again flag */ /* and keep the removal pending flag */ ev->flags = EV_FLAG_AGAIN | (ev->flags & EV_FLAG_REM_P); } /* * **************************************************************************** * * evl_append: * Append an ESI event to the list, the list contains all of * ESI events which are being processed at present. * * p - the ESI event. * * **************************************************************************** */ void evl_append( void *p ) { ev_t *ev; ev = (ev_t *)p; ev->next = ev_list; ev_list = ev; } /* * **************************************************************************** * * evl_strip: * Strip off an ESI event from the list after the event is being * processed, it will be scheduled in the scheduler. * * p - the ESI event. * * **************************************************************************** */ void evl_strip( void *p ) { ev_t **evp = &ev_list; ev_t *ev = *evp; while (ev != NULL) { if (ev == p) { *evp = ev->next; break; } evp = &ev->next; ev = *evp; } } /* * **************************************************************************** * * evl_remove: * Remove an ESI event or a portal of an ESI event from the event list. * * id1 - the Entity object UID. * id2 - the Portal object UID. * pending - the pending flag. * return - 1: found a match event, otherwise not. * * **************************************************************************** */ int evl_remove( uint32_t id1, uint32_t id2, int pending ) { ev_t *ev = ev_list; while (ev != NULL) { /* found it */ if (ev_match(ev, id1) != 0) { /* lock the event */ (void) pthread_mutex_lock(&ev->mtx); /* mark it as removed */ (void) ev_remove(ev, id2, 0, pending); /* unlock the event */ (void) pthread_mutex_unlock(&ev->mtx); /* tell caller removal is done */ return (1); } ev = ev->next; } /* not found it */ return (0); } #define ALARM_MAX (21427200) /* * **************************************************************************** * * idle: * Idle for certain amount of time or a wakeup signal is recieved. * * t - the idle time. * return - the time that idle left. * * **************************************************************************** */ static int idle( uint32_t t ) { uint32_t t1, t2, t3 = 0; int idl_int = 0; /* hold the mutex for stopwatch update */ (void) pthread_mutex_lock(&stw_mtx); do { if (t > ALARM_MAX) { t1 = ALARM_MAX; } else { t1 = t; } /* start alarm */ (void) alarm(t1); /* hold the mutex for idle condition */ (void) pthread_mutex_lock(&idl_mtx); /* wait on condition variable to wake up idle */ while (wakeup == 0) { (void) pthread_cond_wait(&idl_cond, &idl_mtx); } if (wakeup == 2) { idl_int = 1; } /* clean wakeup flag */ wakeup = 0; /* release the mutex for idle condition */ (void) pthread_mutex_unlock(&idl_mtx); /* stop alarm */ t2 = alarm(0); /* seconds actually slept */ t3 += t1 - t2; t -= t3; } while (t > 0 && idl_int == 0); /* increate the stopwatch by the actually slept time */ stopwatch += t3; /* release the mutex after stopwatch is updated */ (void) pthread_mutex_unlock(&stw_mtx); /* return the amount of time which is not slept */ return (t); } /* * **************************************************************************** * * ev_ex: * Execute an event. To inquiry the client status or * perform registration expiration. * * ev - the event. * * **************************************************************************** */ static void ev_ex( ev_t *ev ) { pthread_t tid; switch (ev->type) { case EV_ESI: if (pthread_create(&tid, NULL, esi_monitor, (void *)ev) != 0) { isnslog(LOG_DEBUG, "ev_ex", "pthread_create() failed."); /* reschedule for next occurence */ (void) el_add(ev, 0, NULL); } else { /* increase the thread ref count */ inc_thr_count(); } break; case EV_REG_EXP: (void) queue_msg_set(sys_q, REG_EXP, (void *)ev); break; default: break; } } /* * **************************************************************************** * * esi_proc: * ESI thread entry, which: * 1: fetch an event from schedule, * 2: idle for some time, * 3: execute the event or re-schedule it, * 4: repeat from step 1 before server is being shutdown. * * arg - the thread argument. * * **************************************************************************** */ /*ARGSUSED*/ void * esi_proc( void *arg ) { uint32_t t, t1, pt; ev_t *ev; void *evp; while (time_to_exit == B_FALSE) { ev = (ev_t *)el_first(&pt); /* caculate the idle time */ if (ev != NULL) { if (pt > stopwatch) { t = pt - stopwatch; } else { t = 0; } } else { t = INFINITY; } do { /* block for a certain amount of time */ if (t > 0) { isnslog(LOG_DEBUG, "esi_proc", "idle for %d seconds.", t); t1 = idle(t); } else { t1 = 0; } if (t1 > 0) { isnslog(LOG_DEBUG, "esi_proc", "idle interrupted after idle for " "%d seconds.", t - t1); } if (time_to_exit != B_FALSE) { ev = NULL; /* force break */ } else if (ev != NULL) { if (t1 > 0) { /* not naturally waken up */ /* reschedule current event */ evp = NULL; (void) el_add(ev, pt, &evp); ev = (ev_t *)evp; t = t1; } else { /* excute */ isnslog(LOG_DEBUG, "esi_proc", "excute the cron job[%d].", ev->uid); ev_ex(ev); ev = NULL; } } } while (ev != NULL); } return (NULL); } /* * **************************************************************************** * * esi_ping: * Ping the client with the ESI retry threshold for status inquiry. * * so - the socket descriptor. * pdu - the ESI packet. * pl - the length of packet. * return - 1: status inquired, otherwise not. * * **************************************************************************** */ static int esi_ping( int so, isns_pdu_t *pdu, size_t pl ) { int try_cnt = 0; isns_pdu_t *rsp = NULL; size_t rsp_sz; int alive = 0; do { if (isns_send_pdu(so, pdu, pl) == 0) { if (isns_rcv_pdu(so, &rsp, &rsp_sz, ISNS_RCV_SHORT_TIMEOUT) > 0) { #ifdef DEBUG dump_pdu1(rsp); #endif alive = 1; break; } } else { /* retry after 1 second */ (void) sleep(1); } try_cnt ++; } while (try_cnt < esi_threshold); if (rsp != NULL) { free(rsp); } return (alive); } /* * **************************************************************************** * * esi_monitor: * Child thread for client status mornitoring. * * arg - the ESI event. * * **************************************************************************** */ static void * esi_monitor( void *arg ) { ev_t *ev = (ev_t *)arg; esi_portal_t *p; int so; isns_pdu_t *pdu = NULL; size_t sz; size_t pl; size_t half; time_t t; int feedback; /* lock the event for esi monitoring */ (void) pthread_mutex_lock(&ev->mtx); if (evf_rem(ev) != 0) { goto mon_done; } else if (evf_rem_pending(ev) != 0) { goto mon_done; } /* timestamp */ t = time(NULL); /* allocate ESI PDU */ if (pdu_reset_esi(&pdu, &pl, &sz) != 0 || pdu_add_tlv(&pdu, &pl, &sz, ISNS_TIMESTAMP_ATTR_ID, 8, (void *)&t, 1) != 0 || pdu_add_tlv(&pdu, &pl, &sz, ISNS_EID_ATTR_ID, ev->eid_len, (void *)ev->eid, 0) != 0) { /* no memory, will retry later */ goto mon_done; } /* set pdu head */ pdu->version = htons((uint16_t)ISNSP_VERSION); pdu->func_id = htons((uint16_t)ISNS_ESI); pdu->xid = htons(get_server_xid()); /* keep the current lenght of the playload */ half = pl; p = ev->portal; while (p != NULL) { if (p->ref != 0 && /* skip IPv6 portal */ p->sz != sizeof (in6_addr_t) && pdu_add_tlv(&pdu, &pl, &sz, ISNS_PORTAL_IP_ADDR_ATTR_ID, sizeof (in6_addr_t), (void *)p->ip6, 0) == 0 && pdu_add_tlv(&pdu, &pl, &sz, ISNS_PORTAL_PORT_ATTR_ID, 4, (void *)p->port, 0) == 0) { /* connect once */ so = connect_to(p->sz, p->ip4, p->ip6, p->esip); if (so != -1) { feedback = esi_ping(so, pdu, pl); (void) close(so); /* p->so = so; */ } else { /* cannot connect, portal is dead */ feedback = 0; } if (feedback == 0) { isnslog(LOG_DEBUG, "esi_monitor", "ESI ping failed."); (void) queue_msg_set(sys_q, DEAD_PORTAL, (void *)p->ref); } else { goto mon_done; } } pl = half; p = p->next; } mon_done: /* unlock the event after esi monitoring is done */ (void) pthread_mutex_unlock(&ev->mtx); /* clean up pdu */ if (pdu != NULL) { free(pdu); } /* set reschedule flags */ ev->flags |= EV_FLAG_WAKEUP; /* reschedule for next occurence */ (void) el_add(ev, 0, NULL); /* decrease the thread ref count */ dec_thr_count(); return (NULL); } /* * **************************************************************************** * * portal_dies: * Handles the dead portal that ESI detected. * * uid - the Portal object UID. * * **************************************************************************** */ void portal_dies( uint32_t uid ) { int ec = 0; lookup_ctrl_t lc; /* prepare the lookup control for deregistration */ SET_UID_LCP(&lc, OBJ_PORTAL, uid); /* lock the cache for object deregistration */ (void) cache_lock_write(); /* deregister the portal */ ec = dereg_object(&lc, 1); /* unlock cache and sync with data store */ (void) cache_unlock_sync(ec); } /* * **************************************************************************** * * portal_dies: * Handles the Entity registration expiration. * * p - the ESI event. * * **************************************************************************** */ void reg_expiring( void *p ) { int ec = 0; ev_t *ev = (ev_t *)p; lookup_ctrl_t lc; /* prepare the lookup control for deregistration */ SET_UID_LCP(&lc, OBJ_ENTITY, ev->uid); /* lock the cache for object deregistration */ (void) cache_lock_write(); if (evf_rem(ev) == 0) { /* deregister the entity */ ec = dereg_object(&lc, 0); /* unlock cache and sync with data store */ ec = cache_unlock_sync(ec); if (ec == 0) { /* successfuk, mark ev as removed */ ev->flags |= EV_FLAG_REMOVE; } else { /* failed, retry after 3 mintues */ ev->intval = 3 * 60; isnslog(LOG_DEBUG, "reg_expiring", "dereg failed, retry after 3 mintues."); } } else { /* ev is marked as removed, no need to dereg */ (void) cache_unlock_nosync(); } /* reschedule it for next occurence */ (void) el_add(ev, 0, NULL); }
