sharememory.cpp

Mysql的处理

/*******************************************************************************
*FileName:	ShareMemory.cpp	
*
* implementation of the C_ShareMemory class 
*
********************************************************************************
* Copyright (c)
*
* All rights reserved.
*
*
*
* Compiler: Solaris CC
*
* Author: Tony Zheng
*
* Date: May 12th 2006
*
* Description:
*
*
*
*
*
*===============================================================================
* Modified
*
*
*
*
*******************************************************************************/

#include "ShareMemoryCommon.h"
#include "ShareMemory.h"

namespace SHM
{
  	/* private function for the C_ShareMemory class  ====start================*/
  
    void ShmLog(const char *sMessage)
    {      
        FILE *fp;
        
        if( (fp = fopen(gsLogFileName,"a+")	) == NULL)
        {
            printf("open %s failed!\n",gsLogFileName);
            exit(-1);	
        }
        fprintf(fp,"%s\n",sMessage);
        fclose(fp);
    }
    
	/*    int C_ShareMemory::PrintSemValue(int semaphore)
    {
    	struct semid_ds suSemInfo;
    	struct sem suSem;
    	union semun
        {
              int val;
              struct semid_ds *buf;
              ushort *array;	
        }unArg;
        
        unArg.buf = &suSemInfo;
        int i=0;
        for(;i < 60;i++)
        {
            semctl(m_iSemID,0,IPC_STAT,unArg);
            if(unArg.buf->sem_otime != 0)
                break;
            sleep(1);	
        }
    	
    }  */      

    void GetLogFileName(const unsigned int uiProgramFlag)
    {
        char sPathName[PATH_NAME_LEN];
        memset(sPathName,0,PATH_NAME_LEN);
        
        memset(gsLogFileName,0,LOG_FILE_NAME_LEN);
        if( (sPathName != NULL) && (*(sPathName) != '\0') )
            strcpy(gsLogFileName,sPathName);
        switch( uiProgramFlag )
        {
            case LOG_GTP:
                strcat(gsLogFileName,"gtp.shm.log");
                break;
            case LOG_ASN1:
                strcat(gsLogFileName,"asn1.shm.log");
                break;
            case LOG_GCDR:
                strcat(gsLogFileName,"gcdr.shm.log");
                break;
            case LOG_SCDR:
                strcat(gsLogFileName,"scdr.shm.log"); 
                break;
            case LOG_MCDR:
                strcat(gsLogFileName,"mcdr.shm.log");
                break;
            case LOG_MOCDR:
                strcat(gsLogFileName,"mocdr.shm.log");
                break;
            case LOG_MTCDR:
                strcat(gsLogFileName,"mtcdr.shm.log");
                break;
            case LOG_HOTBILLING:
                strcat(gsLogFileName,"hotbilling.shm.log");   
                break;
            default:
                strcat(gsLogFileName,"shm.log");   
                break;                      	
        }
    }
    
    // get config value of share memory block information
    void C_ShareMemory::GetBlockConfig()
    {
        CConfigXml ShmConfig;
        char sValue[XML_VALUE_LEN];
        string sTemp;

        if( !ShmConfig.Load(m_pConfigFileName) )
        {
            ShmLog("CConfigXml.Load() failed!");
            throw C_SHMException();
        } 

        m_pBlockInfo = (S_BlockInfo *) new char[ sizeof(S_BlockInfo) ];
        if(NULL == m_pBlockInfo)
        {
			{ShmLog("5");
			throw C_SHMException();}		
        }               
        memset(m_pBlockInfo,0,sizeof(S_BlockInfo));
             
        memset(sValue,0,XML_VALUE_LEN);
        if( !ShmConfig.GetValue("ShareMemory.Block.ShareMemoryKey",sTemp) )
		{
			ShmLog("6");
			throw C_SHMException();
		}
        strcpy(sValue,sTemp.c_str());
        m_pBlockInfo->ulShmKey = atol(sValue);
        memset(sValue,0,XML_VALUE_LEN);
        if( !ShmConfig.GetValue("ShareMemory.Block.ShareMemorySize",sTemp) )
		{
			ShmLog("6");
			throw C_SHMException();
		}
        strcpy(sValue,sTemp.c_str());
        m_pBlockInfo->ulShmTotalSize = atol(sValue);
        // verify config value
        if(m_pBlockInfo->ulShmTotalSize < SHM_MIN_SIZE)
		{
			ShmLog("7");
			throw C_SHMException();
		}
        memset(sValue,0,XML_VALUE_LEN);   
        if( !ShmConfig.GetValue("ShareMemory.Block.SemaphoreNumber",sTemp) )
		{
			ShmLog("8");
			throw C_SHMException();
		} 
        strcpy(sValue,sTemp.c_str());         
        m_pBlockInfo->uiSemTotalNumber = atoi(sValue); 
        memset(sValue,0,XML_VALUE_LEN);   
        if( !ShmConfig.GetValue("ShareMemory.Block.ControlAreaSize",sTemp) )
		{
			ShmLog("9");
			throw C_SHMException(); 
		} 
        strcpy(sValue,sTemp.c_str());
        m_pBlockInfo->ulControlAreaSize = atol(sValue);
        // verify config value
        if(m_pBlockInfo->ulControlAreaSize < CONTROL_MIN_SIZE)
		{
			ShmLog("10");
			throw C_SHMException();
		}   
        if( !ShmConfig.GetValue("ShareMemory.Block.BusinessAreaNumber",sTemp) )
		{
			ShmLog("11");
			throw C_SHMException();
		}  



        strcpy(sValue,sTemp.c_str());
       m_pBlockInfo->uiBusinessAreaNumber = atoi(sValue); 
        // verify config value                   
        if(m_pBlockInfo->uiBusinessAreaNumber < BUSINESS_NUMBER_MIN_SIZE)
		{
			ShmLog("12");
			throw C_SHMException();
		}     

		#ifdef DEBUG_SHM
		{      
			if( (fp = fopen(gsLogFileName,"a+") ) == NULL)
			{
				printf("open %s failed!\n",gsLogFileName);
				exit(-1);	
			}
			fprintf(fp,"<Block Information>\n");
			fprintf(fp,"Share Memory Key:%ld\n",m_pBlockInfo->ulShmKey);
			fprintf(fp,"Share Memory Size:%ld\n",m_pBlockInfo->ulShmTotalSize);
			fprintf(fp,"Semaphore Number:%d\n",m_pBlockInfo->uiSemTotalNumber);
			fprintf(fp,"Control Area Size:%ld\n",m_pBlockInfo->ulControlAreaSize);   
			fprintf(fp,"Business Area Number:%d\n",m_pBlockInfo->uiBusinessAreaNumber); 
			fclose(fp);
		}
		#endif    

    }
    
    // get ShareMemoryID and SemaphoreSetID, if not exist, creat it
    void C_ShareMemory::GetShmSemID(unsigned char &ucInitialFlag)
    {               
        key_t ktKey;
        
		/*        char sDescription[CONFIG_PATH_LEN];
		               
		ShmLog("GetShmSemID");
		        // get config file path, generate key  
		        memset(sDescription,0,CONFIG_PATH_LEN);
		        strcpy(sDescription,m_pConfigFileName);
		        memset(strrchr(sDescription,'/') + 1,0,1); 
		        ShmLog(sDescription);             
		        ktKey = ftok(sDescription,'0');
		        if(-1 == ktKey)
		{ShmLog("13");throw C_SHMException();}*/
          
        // get share memory block config information
        GetBlockConfig();   
        
        ktKey = (key_t) m_pBlockInfo->ulShmKey; 
		//printf("Key%0x\n",ktKey);
        char sxqy[100];
        sprintf(sxqy, "%d", ktKey);
        ShmLog(sxqy);
        
        sprintf(sxqy, "%d", m_pBlockInfo->ulShmTotalSize);
        ShmLog(sxqy);
        
        // get share memory ID, if not exist, creat it and set ucInitialFlag = 1 
        m_iShmID = shmget(ktKey,m_pBlockInfo->ulShmTotalSize,IPC_CREAT|IPC_EXCL|0600);
        sprintf(sxqy, "%d", m_iShmID);
        ShmLog(sxqy);
        if(m_iShmID < 0)
        {
        	sprintf(sxqy, "EACCES=%d", EACCES);
        	ShmLog(sxqy);
        	sprintf(sxqy, "EEXIST=%d", EEXIST);
        	ShmLog(sxqy);
        	sprintf(sxqy, "EINVAL=%d", EINVAL);
        	ShmLog(sxqy);
        	sprintf(sxqy, "ENOENT=%d", ENOENT);
        	ShmLog(sxqy);
        	sprintf(sxqy, "ENOMEM=%d", ENOMEM);
        	ShmLog(sxqy);
        	sprintf(sxqy, "ENOSPC=%d", ENOSPC);
        	ShmLog(sxqy);
        	sprintf(sxqy, "errno=%d", errno);
        	ShmLog(sxqy);
            if(EEXIST == errno)
            {
                m_iShmID = shmget(ktKey,0,0600);
                if(m_iShmID < 0) 
                {
					{ShmLog("14_");
					throw C_SHMException();}
                }               	
            }
            else 
			{
				ShmLog("14");
				throw C_SHMException();
			}
        }
        else    
        {
            ucInitialFlag = 1;       	
        }                   

      // get semaphore set ID, if not exist, creat it and initialize semaphore value
      if(m_pBlockInfo->uiSemTotalNumber > 0)
      {
          union semun
          {
              int val;
              struct semid_ds *buf;
              ushort *array;	
          }unArg;
            
          m_iSemID = semget(ktKey,m_pBlockInfo->uiSemTotalNumber,IPC_CREAT|IPC_EXCL|0600);         
          if(m_iSemID < 0)
          {
              if(EEXIST == errno)
              {
                  struct semid_ds suSemInfo;
                
                  m_iSemID = semget(ktKey,0,0600);
                  if(m_iShmID < 0) 
                  {
						{
							ShmLog("15_");
							throw C_SHMException();
						}
                  }           
                  unArg.buf = &suSemInfo;
                  // make sure semaphore have been initialized
                  int i=0;
                  for(;i < 60;i++)
                  {
                      semctl(m_iSemID,0,IPC_STAT,unArg);
                      if(unArg.buf->sem_otime != 0)
                          break;
                      sleep(1);	
                  }
                  if(60 == i)
					{ShmLog("15");throw C_SHMException();}	                	
              }
              else
			  {
			  	  ShmLog("16");
			  	  throw C_SHMException();
			  }         	
          }