static int countCvtRecords(void)
{
    DBENTRY dbentry;
    extern DBBASE *pdbbase;
    int result = 0;
    long status;

    dbInitEntry(pdbbase, &dbentry);
    status = dbFindRecordType(&dbentry,"cvt");
    if (!status) {
        result = dbGetNRecords(&dbentry);
    }
    dbFinishEntry(&dbentry);
    return result;
}
static long ai_init(int pass)
{
    long i;

    if (pass) return 0;

    /* Create timers */
    for (i = 0; i < TOTAL_TYPES; i++) {
        scanIoInit(&scan[i].ioscan);
        scan[i].wd = wdogCreate(scan_time, i);
        scan[i].total = 0;
        scan[i].on = 0;
        scan[i].rate_sec = parmTypes[i].scan_rate;
    }

    /* Init OSD stuff */
    scan_mutex = epicsMutexMustCreate();
    devIocStatsInitCpuUsage();
    devIocStatsInitCpuUtilization(&loadinfo);
    devIocStatsInitFDUsage();
    devIocStatsInitMemUsage();
    devIocStatsInitWorkspaceUsage();
    devIocStatsInitSuspTasks();
    devIocStatsInitIFErrors();
    /* Get initial values of a few things that don't change much */
    devIocStatsGetClusterInfo(SYS_POOL, &clustinfo[SYS_POOL]);
    devIocStatsGetClusterInfo(DATA_POOL, &clustinfo[DATA_POOL]);
    devIocStatsGetClusterUsage(SYS_POOL, &mbufnumber[SYS_POOL]);
    devIocStatsGetClusterUsage(DATA_POOL, &mbufnumber[DATA_POOL]);
    devIocStatsGetCpuUtilization(&loadinfo);
    devIocStatsGetIFErrors(&iferrors);
    devIocStatsGetFDUsage(&fdusage);

    /* Count EPICS records */
    if (pdbbase) {
        DBENTRY dbentry;
        long	  status;
        dbInitEntry(pdbbase,&dbentry);
        status = dbFirstRecordType(&dbentry);
        while (!status) {
            recordnumber += dbGetNRecords(&dbentry);
            status = dbNextRecordType(&dbentry);
        }
        dbFinishEntry(&dbentry);
    }
    return 0;
}
static long ai_init(int pass)
{
    long i;

    if (pass) return 0;

    /* Create timers */
    for (i = 0; i < TOTAL_TYPES; i++) {
        scanIoInit(&scan[i].ioscan);
        scan[i].wd = wdogCreate(scan_time, i);
        scan[i].total = 0;
        scan[i].on = 0;
        scan[i].rate_sec = scan_rate_sec[i];
        scan[i].last_read_sec = 1000000;
    }

    /* Init OSD stuff */
    devIocStatsInitCpuUsage();
    devIocStatsInitCpuUtilization(&loadinfo);
    devIocStatsInitFDUsage();
    devIocStatsInitMemUsage();
    devIocStatsInitWorkspaceUsage();
    devIocStatsInitSuspTasks();
    devIocStatsInitIFErrors();

    /* Count EPICS records */
    if (pdbbase) {
        DBENTRY dbentry;
        long	  status;
        dbInitEntry(pdbbase,&dbentry);
        status = dbFirstRecordType(&dbentry);
        while (!status) {
            recordnumber += dbGetNRecords(&dbentry);
            status = dbNextRecordType(&dbentry);
        }
        dbFinishEntry(&dbentry);
    }
    return 0;
}
long epicsShareAPI dbnr(int verbose)
{
    DBENTRY dbentry;
    DBENTRY *pdbentry=&dbentry;
    long status;
    int nrecords;
    int naliases;
    int trecords = 0;
    int taliases = 0;

    if (!pdbbase) {
        printf("No database loaded\n");
        return 0;
    }

    dbInitEntry(pdbbase, pdbentry);
    status = dbFirstRecordType(pdbentry);
    if (status) {
        printf("No record types loaded\n");
        return 0;
    }

    printf("Records  Aliases  Record Type\n");
    while (!status) {
        naliases = dbGetNAliases(pdbentry);
        taliases += naliases;
        nrecords = dbGetNRecords(pdbentry) - naliases;
        trecords += nrecords;
        if (verbose || nrecords)
            printf(" %5d    %5d    %s\n",
                nrecords, naliases, dbGetRecordTypeName(pdbentry));
        status = dbNextRecordType(pdbentry);
    }

    dbFinishEntry(pdbentry);
    printf("Total %d records, %d aliases\n", trecords, taliases);
    return 0;
}
Exemple #5
0
int epicsShareAPI logAlarmsInit (
) {
    DBENTRY     dbentry;
    DBENTRY     *pdbentry=&dbentry;
    long        status;
    int		numRecords=0;
    int		tid[MSG_TASK_NUM], btid, ctid, rtid;
    int		normalRangeSize, overRangeSize;
    struct sockaddr_in	*psin;
    int		node;
    char	string[32];
    char	*pstring, *serverList, *ptok, *pheader;
    int		i;

    if (initialized) {
	errlogPrintf ("logAlarmsInit: already initialized\n");
	return ERROR;
    }

    clkRate = sysClkRateGet();

    tickInitWait = (unsigned long)(clkRate * INIT_DELAY_SEC + 0.5);

    tickMaxSilent = (unsigned long)(clkRate * BEACON_IDLE_SEC + 0.5);
    tickBeaconPeriod = (unsigned long)(clkRate * BEACON_PERIOD_SEC + 0.5);
    tickBeaconReplyTmo = (unsigned long)(clkRate * BEACON_REPLY_TMO_SEC + 0.5);
    tickMessageReplyTmo = (unsigned long)(clkRate * MESSAGE_REPLY_TMO_SEC + 0.5);
    /* wait time between retrying to send messages (>= 1 tick) */
    tickMsgRetryWait = (unsigned long)(clkRate * MESSAGE_RETRY_WAIT_SEC + 0.5);
    if (tickMsgRetryWait == 0UL) tickMsgRetryWait = 1UL;

    if(!pdbbase) {
	errlogPrintf ("logAlarmsInit: No database has been loaded\n");
        return ERROR;
    }

    serverList = getenv ("EPICS_ALARM_SERVER_INET");
    if (!serverList) {
	errlogPrintf ("logAlarmsInit: EPICS_ALARM_SERVER_INET env not defined\n");
	return ERROR;
    }

    pstring = getenv ("EPICS_ALARM_MESSAGE_PORT");
    if (!pstring)
	msg_port = DEFAULT_MSG_PORT;
    else {
	msg_port = (unsigned short) atoi (pstring);
	if (msg_port < 1024) {
	    msg_port = DEFAULT_MSG_PORT;
	    errlogPrintf ("Port number EPICS_ALARM_MESSAGE_PORT is wrong\n");
	}
    }

    pstring = getenv ("EPICS_ALARM_COMMAND_PORT");
    if (!pstring)
	cmd_port = DEFAULT_CMD_PORT;
    else {
	cmd_port = (unsigned short) atoi (pstring);
	if (cmd_port < 1024) {
	    cmd_port = DEFAULT_CMD_PORT;
	    errlogPrintf ("Port number EPICS_ALARM_COMMAND_PORT is wrong\n");
	}
    }

    /* if allAcceptOption is set, commands are accepted from all servers */
    pstring = getenv ("EPICS_ALARM_COMMAND_ACCEPT_ALL");
    if (strcmp (pstring, "YES") == 0)
	allAcceptOption = TRUE;

    psin = &msgServerAddr[0];
    node = 0;

    ptok = strtok_r (serverList, " ", &pstring);

    while (ptok && node < SERVERS_MAX && aToIPAddr (ptok, msg_port, psin) == 0) {
        node++;
        psin++;
	ptok = strtok_r (NULL, " ", &pstring);
    }
    numServersConfigured = node;

    if (numServersConfigured == 0) {
	errlogPrintf (
	  "logAlarmsInit: No server correctly defined in EPICS_ALARM_SERVER_INET\n");
    }

    wakeupSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
    if (!wakeupSem) {
	errlogPrintf ("logAlarmsInit: Reader wakeup semaphore could not be created\n");
        return ERROR;
    }

    bucketSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
    if (!bucketSem) {
	errlogPrintf ("logAlarmsInit: Hash facility mutex could not be created\n");
	cleanup (1);
        return ERROR;
    }

    ringSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
    if (!ringSem) {
	errlogPrintf ("logAlarmsInit: Ring r/w mutex could not be created\n");
	cleanup (2);
        return ERROR;
    }

    ringWriteSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
    if (!ringWriteSem) {
	errlogPrintf ("logAlarmsInit: Ring (write) mutex could not be created\n");
	cleanup (3);
        return ERROR;
    }

    msgSockSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
    if (!msgSockSem) {
	errlogPrintf ("logAlarmsInit: MsgSocket mutex could not be created\n");
	cleanup (4);
        return ERROR;
    }

    dbInitEntry(pdbbase,pdbentry);

    status = dbFirstRecordType(pdbentry);
    while(!status) {
	int	numRecordsType;

	numRecordsType = dbGetNRecords(pdbentry);
	DEBUG2(4,"There are %d records of type %s\n",
	  numRecordsType, dbGetRecordTypeName(pdbentry))
	numRecords += numRecordsType;
	status = dbNextRecordType(pdbentry);
    }
    dbFinishEntry(pdbentry);

    normalRangeSize = (int)(numRecords * RING_NORMAL_MULTI) + 1;
    overRangeSize = numRecords + numRecords / RING_OVER_DIVI + 1;

    ringSize = normalRangeSize + overRangeSize;

    pRingBottom = (msgBuffer_t *)calloc (ringSize, sizeof(msgBuffer_t));
    if (!pRingBottom) {
	errlogPrintf ("logAlarmsInit: Ring buffer could not be created\n");
	cleanup (5);
	return ERROR;
    }
    pRingTop = pRingBottom + ringSize;
    DEBUG2(2,"pRingBottom:%lu  pRingTop:%lu\n",
      (unsigned long)pRingBottom, (unsigned long)pRingTop)

    ringHighWater = normalRangeSize;
    DEBUG2(2,"Ring buffer size:%d  highwater:%d\n",ringSize,ringHighWater)
    pRingRead = pRingBottom;
    pRingWrite = pRingBottom;
    msgLost = 0;

    pbuck = bucketCreate (numRecords);
    if (!pbuck) {
	errlogPrintf ("logAlarmsInit: Hash table could not be initalized\n");
	cleanup (6);
	return ERROR;
    }

    serverSelected = -1;
    serverSelectedLast = -1;

    queueAllRecords();

    /* spawn alarm beacon task */
    btid = taskSpawn ("Al'Beacon", BEACON_TASK_PRIO, BEACON_TASK_OPTIONS,
      BEACON_TASK_STACK, (FUNCPTR)alarmBeaconTask,0,0,0,0,0,0,0,0,0,0);

    if (!btid) {
	errlogPrintf ("logAlarmsInit: Beacon task could not be spawned\n");
	cleanup (7);
	return ERROR;
    }
    DEBUG1(1,"alarmBeaconTask started. Task-ID = 0x%x\n", btid);

    msg_soc = socket (AF_INET, SOCK_DGRAM, 0);
    if (msg_soc < 0) {
	errlogPrintf ("Message socket create failed\n");
	cleanup (7);
	return ERROR;
    }
    bzero ((char *) &msgReplyInAddr, sockAddrSize);
    msgReplyInAddr.sin_port = htons(msg_port);
    msgReplyInAddr.sin_family = AF_INET;
    msgReplyInAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind (msg_soc, (struct sockaddr*)&msgReplyInAddr, sockAddrSize) < 0 ) {
	errlogPrintf ("Message socket bind failed\n");
	cleanup (8);
	return ERROR;
    }

    cmd_soc = socket (AF_INET, SOCK_DGRAM, 0);
    if (cmd_soc < 0) {
	errlogPrintf ("Command socket create failed\n");
	cleanup (8);
	return ERROR;
    }
    bzero ((char *) &cmdServerAddr, sockAddrSize);
    cmdServerAddr.sin_port = htons(cmd_port);
    cmdServerAddr.sin_family = AF_INET;
    cmdServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind (cmd_soc, (struct sockaddr*)&cmdServerAddr, sockAddrSize) < 0 ) {
	errlogPrintf ("Command socket bind failed\n");
	cleanup (9);
	return ERROR;
    }

    /* spawn alarm message tasks */
    for (i=0; i<MSG_TASK_NUM; i++) {
	sprintf (string, "Al'Msg%d", i+1);
	tid[i] = taskSpawn (string, CLIENT_TASK_PRIO, CLIENT_TASK_OPTIONS,
	 CLIENT_TASK_STACK, (FUNCPTR)alarmMessageTask,i+1,0,0,0,0,0,0,0,0,0);

	if (!tid[i]) {
	    errlogPrintf (
	     "logAlarmsInit: Message task %d could not be spawned\n");
	    cleanup (9);
	    while (i > 0) taskDelete (tid[--i]);
	    taskDelete (btid);
	    return ERROR;
	}
    }

    /* spawn alarm log control (command receiver) server task */
    ctid = taskSpawn ("Al'Command", CONTROL_TASK_PRIO, CONTROL_TASK_OPTIONS,
      CONTROL_TASK_STACK, (FUNCPTR)alarmCommandTask,0,0,0,0,0,0,0,0,0,0);

    if (!ctid) {
	errlogPrintf ("logAlarmsInit: Control task could not be spawned\n");
	cleanup (9);
	taskDelete (btid);
	for (i=0; i<MSG_TASK_NUM; i++) taskDelete (tid[i]);
	return ERROR;
    }

    /* spawn message reply receiver task */
    rtid = taskSpawn ("Al'ReplyRx", REPLY_TASK_PRIO, REPLY_TASK_OPTIONS,
      REPLY_TASK_STACK, (FUNCPTR)replyReceiveTask,0,0,0,0,0,0,0,0,0,0);

    if (!rtid) {
	errlogPrintf ("logAlarmsInit: Reply receiver task could not be spawned\n");
	cleanup (9);
	taskDelete (btid);
	taskDelete (ctid);
	for (i=0; i<MSG_TASK_NUM; i++) taskDelete (tid[i]);
	return ERROR;
    }

    pheader = messageHeader;

    pstring = getenv ("EPICS_IOC_NAME");

    if (pstring)		/* given IOC name */
	pheader = messageHeader +
	  sprintf (messageHeader, "HOST=%s;", pstring);
    pheader +=
      sprintf (pheader, "HOST-PHYS=%s;APPLICATION=logAlarms;",
        gethostname (string, sizeof(string)) ? "TOO_LONG" : string);

    pstring = getenv ("EPICS_FACILITY");

    if (pstring)		/* name of application facility */
	pheader +=
	  sprintf (pheader, "FACILITY=%s;", pstring);

    /* calculate the remaining space in the message string */
    textMsgSize = MAX_MESSAGE_LENGTH - (pheader-messageHeader);

    epicsPrintf("logAlarms started\n");

    recGblAlarmHook = (RECGBL_ALARM_HOOK_ROUTINE)logEvent;
    DEBUG1(3,"recGblAlarmHook = 0x%lx\n",(unsigned long)recGblAlarmHook)

    initialized = TRUE;

    return OK;
}