Пример #1
0
bool JdbcUtil::getSemaphores(bool create)
{
	setError(NULL);

	if (semaphoreId == -1)
	{
		int semid;
		if ((semid = semget(memoryKey, 0, 0666 ))==-1)
		{
			if ((errno==ENOENT) && create)
			{
				if ((semid = semget(memoryKey, TOTAL_SEM, IPC_CREAT | 0666 ))==-1)
				{
					setPerror("Cannot create semaphores");
					return false;
				}
			}
			else
			{
				setPerror("Cannot get semaphores");
				return false;
			}
		}
		semaphoreId = semid;
	}
	return true;
}
Пример #2
0
bool JdbcUtil::removeMemory(void)
{
	setError(NULL);

	if (!getMemory(false))
	{
		// If not found, it does not exist
		if (errorCode == ENOENT) return true;
		return false;
	}

	// deactivate the old memory in case some still has it attached
	if (attachMemory())
	{
		sharedMemory->active = false;
		detachMemory();
	}

	// Remove the memory
	if (shmctl(sharedMemoryId,IPC_RMID,NULL)==-1)
	{
		setPerror("Cannot remove shared memory");
		return false;
	}
	sharedMemoryId = -1;
	return true;
}
Пример #3
0
bool JdbcUtil::attachMemory(void)
{
	setError(NULL);

	// If we have not accessed the memory, get it
	//   only if it has already been created.
	if ((sharedMemoryId==-1) &&
	    !getMemory(false)) return false;

	if (sharedMemory && !sharedMemory->active)
	{
		// We are attached to an old memory segment.
		// Detach it so we can attach the new one.
		if (!detachMemory()) return false;
	}

	if (sharedMemory==NULL)
	{
		// At this point we have an id to the memory, now we
		//   can attach it.
		void *shm;
		if ((shm = shmat(sharedMemoryId, NULL, 0)) == (void *) -1)
		{
			setPerror("Cannot attach shared memory");
			return false;
		}
		sharedMemory = (struct JdbcUtilMemoryStruct *) shm;
	}
	return true;
}
Пример #4
0
/* setCreate()
 */
LS_BITSET_T *
setCreate(const int size,
          int (*directFunction)(void *),
          void *(*inverseFunction)(int ),
          char *caller)
{
    static char   *fname = "setCreate()";
    int           sz;
    LS_BITSET_T   *set;

    set = calloc(1, sizeof(LS_BITSET_T));
    if (!set) {
        bitseterrno = LS_BITSET_ERR_NOMEM;
        ls_syslog(LOG_ERR,"%s %s", fname, setPerror(bitseterrno));
        return NULL;
    }

    set->setDescription = putstr_(caller);

    /* Size is the number of elements the caller wants
     * to store in the set.
     */
    sz = (size > 0) ? size : SET_DEFAULT_SIZE;

    /* Width is how many bytes we need to store
     * size number of elements.
     */
    set->setWidth = (sz + WORDLENGTH - 1)/WORDLENGTH;

    /* This is the new size eventually rounded up by 1.
     */
    set->setSize = (set->setWidth) * WORDLENGTH;

    set->setNumElements = 0;

    set->bitmask = calloc(set->setWidth, sizeof(unsigned int));
    if (!set->bitmask) {
        bitseterrno = LS_BITSET_ERR_NOMEM;
        return NULL;
    }

    if (directFunction)
        set->getIndexByObject = directFunction;
    else
        set->getIndexByObject = NULL;

    if (inverseFunction)
        set->getObjectByIndex = inverseFunction;
    else
        set->getObjectByIndex = NULL;

    return (set);

}
Пример #5
0
bool JdbcUtil::getMemory(bool create)
{
	setError(NULL);

	if (sharedMemoryId==-1)
	{
		int shmid;

		// Try to get the memory
		if ((shmid = shmget(
			memoryKey,
			0,
			0666)) < 0)
		{
			if ((errno==ENOENT) && create)
			{
				// Does not exist.  Try to create.
				if ((shmid = shmget(
					memoryKey,
					SHARED_MEMORY_SIZE,
					IPC_CREAT | 0666)) < 0)
				{
					setPerror("Cannot create shared memory");
					return false;
				}
			}
			else
			{
				setPerror("Cannot open shared memory");
				return false;
			}
		}

		sharedMemoryId = shmid;
	}
	return true;
}
Пример #6
0
bool JdbcUtil::detachMemory(void)
{
	setError(NULL);

	if (sharedMemory)
	{
		// Detach the memory segment
		if (shmdt(sharedMemory)==-1)
		{
			setPerror("Cannot detach memory");
			return false;
		}
		sharedMemory = NULL;
	}
	return true;
}
Пример #7
0
bool JdbcUtil::removeSemaphores(void)
{
	setError(NULL);

	if (semaphoreId!=-1)
	{
		if (semctl(semaphoreId, 0, IPC_RMID) == -1)
		{
			setPerror("Cannot remove semaphore");
			return false;
		}
		semaphoreId = -1;
	}
	return true;

}
Пример #8
0
bool JdbcUtil::memoryInit(void)
{
	setError(NULL);
	if (!removeMemory()) return false;
	if (!removeSemaphores()) return false;
	if (!getMemory(true)) return false;
	if (!attachMemory()) return false;
	memset(sharedMemory,0,SHARED_MEMORY_SIZE);
	sharedMemory->active = true;

	if (!getSemaphores(true)) return false;
	if (semctl(semaphoreId, 0, SETVAL, 1) == -1)
	{
		int err = errno;
		removeMemory();
		removeSemaphores();
		setPerror(err,"Cannot initialize semaphore value");
		return false;
	}
	return true;
}
Пример #9
0
void JdbcUtil::setPerror(const char *action)
{
	setPerror(errno,action);
}