src/server/Process.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #include <Process.h>
  17 #include <Debug.h>
  18 #include <Database.h>
  19 #include <Config.h>
  20 #include <ErrorType.h>
  21 #include <Globals.h>
  22
  23 int ProcessManager::noThreads=0;
  24 caddr_t ProcessManager::sysAddr=0;
  25 caddr_t ProcessManager::usrAddr=0;
  26 //It does not check for re registering as well as deregistering unregistered threads.
  27 //as it is handled in the connection class open and close methods.
  28 DbRetVal ProcessManager::registerThread()
  29 {
  30 #ifdef LINUX
  31     noThreads++;
  32 #else
  33     DbRetVal rv = systemDatabase->getProcessTableMutex();
  34     if (OK != rv)
  35     {
  36         printError(rv,"Unable to get process table mutex");
  37         return rv;
  38     }
  39     pid_t pid;
  40     if (appPid == 0)
  41     {
  42         //first thread to register
  43         pid = os::getpid();
  44         appPid = pid;
  45     } else
  46     {
  47         pid = appPid;
  48     }
  49     pthread_t thrid = os::getthrid();
  50     ProcInfo* pInfo = systemDatabase->getProcInfo(0);
  51     int i=0;
  52     ProcInfo* freeSlot = NULL;
  53     int freeSlotPos =0;
  54     bool freeSlotSelected = false;
  55     for (; i < config.getMaxProcs(); i++)
  56     {
  57         if (pInfo->pid_ == pid ) break;
  58         if (!freeSlotSelected && 0 == pInfo->pid_)
  59         {
  60             freeSlot = pInfo;
  61             freeSlotPos = i;
  62             freeSlotSelected=true;
  63         }
  64         pInfo++;
  65     }
  66     if (i == config.getMaxProcs())
  67     {
  68         //First thread to register.
  69         ThreadInfo *tInfo =systemDatabase->getThreadInfo(freeSlotPos, 0);
  70         tInfo->thrid_ = thrid;
  71         tInfo->pid_ = pid;
  72         freeSlot->pid_ = pid;
  73         freeSlot->numThreads_ = 1;
  74     } else
  75     {
  76         ThreadInfo *tInfo = systemDatabase->getThreadInfo(i, 0);
  77         int j =0;
  78         for (; j < config.getMaxThreads(); j++)
  79         {
  80
  81             if (0 == tInfo->thrid_)
  82             {
  83                 tInfo->thrid_ = thrid;
  84                 tInfo->pid_ = pid;
  85                 break;
  86             }
  87             tInfo++;
  88         }
  89         if ( j == config.getMaxThreads())
  90         {
  91             systemDatabase->releaseProcessTableMutex();
  92             printError(ErrNoResource, "No free thread slot. Limit reached");
  93             return ErrNoResource;
  94         }
  95
  96         pInfo->numThreads_++;
  97     }
  98     systemDatabase->releaseProcessTableMutex();
  99 #endif
 100     return OK;
 101 }
 102 DbRetVal ProcessManager::deregisterThread()
 103 {
 104 #ifdef LINUX
 105     noThreads--;
 106 #else
 107     DbRetVal rv = systemDatabase->getProcessTableMutex();
 108     if (OK != rv)
 109     {
 110         printError(rv,"Unable to get process table mutex");
 111         return rv;
 112     }
 113     if (appPid == 0)
 114     {
 115         systemDatabase->releaseProcessTableMutex();
 116         printError(ErrSysInternal, "Process not registered\n");
 117         return ErrSysInternal;
 118     }
 119     pid_t pid = appPid;
 120     pthread_t thrid = os::getthrid();
 121
 122     ProcInfo* pInfo = systemDatabase->getProcInfo(0);
 123     int i=0;
 124     for (; i < config.getMaxProcs(); i++)
 125     {
 126         if (pInfo->pid_ == pid ) break;
 127         pInfo++;
 128     }
 129     if (i == config.getMaxProcs())
 130     {
 131         systemDatabase->releaseProcessTableMutex();
 132         printError(ErrSysFatal, "Degistering process %d is not registered with csql", pid);
 133         return ErrNoResource;
 134     }
 135     ThreadInfo *tInfo = systemDatabase->getThreadInfo(i, 0);
 136
 137     i=0;
 138     for (; i < config.getMaxThreads(); i++)
 139     {
 140         if (thrid == tInfo->thrid_)
 141         {
 142             tInfo->thrid_ = 0;
 143             tInfo->pid_ = 0;
 144             tInfo->want_ = NULL;
 145             tInfo->has_ = NULL;
 146             break;
 147         }
 148         tInfo++;
 149     }
 150     if ( i == config.getMaxThreads())
 151     {
 152         systemDatabase->releaseProcessTableMutex();
 153         printError(ErrSysFatal, "Degistering Pid %d Thread %d is not registered with csql", pid, thrid);
 154         return ErrNoResource;
 155     }
 156     pInfo->numThreads_--;
 157
 158     if (0 == pInfo->numThreads_) pInfo->pid_ = 0;
 159
 160     systemDatabase->releaseProcessTableMutex();
 161 #endif
 162     return OK;
 163 }
 164