QDataStream &operator<<(QDataStream &out, const ValuesChangedCommand &command)
{
static const bool dontUseSharedMemory = !qgetenv("DESIGNER_DONT_USE_SHARED_MEMORY").isEmpty();
if (!dontUseSharedMemory && command.valueChanges().count() > 5) {
static quint32 keyCounter = 0;
++keyCounter;
command.m_keyNumber = keyCounter;
QByteArray outDataStreamByteArray;
QDataStream temporaryOutDataStream(&outDataStreamByteArray, QIODevice::WriteOnly);
temporaryOutDataStream.setVersion(QDataStream::Qt_4_8);
temporaryOutDataStream << command.valueChanges();;
QSharedMemory *sharedMemory = createSharedMemory(keyCounter, outDataStreamByteArray.size());
if (sharedMemory) {
std::memcpy(sharedMemory->data(), outDataStreamByteArray.constData(), sharedMemory->size());
out << command.keyNumber();
return out;
}
}
out << qint32(0);
out << command.valueChanges();
return out;
}
void PlaybackController::daemon() {
PlaylistService* playlist_service = new PlaylistService( dao_factory );
MetadataService* metadata_service = new MetadataService( dao_factory );
createSharedMemory();
shm_obj->truncate( sizeof( SharedData) );
boost::interprocess::mapped_region region (
*shm_obj,
boost::interprocess::read_write
);
SharedData* shared_data = static_cast<SharedData*>(region.get_address());
while( 1 ) {
g_debug( "Playing a tune" );
long track_id = playlist_service->getCurrentTrackId();
Track* current_track = metadata_service->getTrackById( track_id );
current_track->print();
metadata_service->free( current_track );
timespec sleep_time = {2, 0 };
nanosleep( &sleep_time, NULL );
playlist_service->cueNextTrack();
playlist_service->saveState();
}
delete metadata_service;
delete playlist_service;
}
int createSharedScene(NBodyState* st, const NBodyCtx* ctx, const char* inputFile)
{
key_t key;
size_t size;
int shmId = -1;
size = sizeof(scene_t) + st->nbody * sizeof(FloatPos);
key = DEFAULT_SHMEM_KEY;
//key = ftok(inputFile, getpid());
if (key < 0)
{
key = DEFAULT_SHMEM_KEY;
perror("Error getting key");
return 1;
}
st->scene = (scene_t*) createSharedMemory(key, size, &shmId);
if (!st->scene)
return 1;
st->shmId = shmId;
prepareSceneFromState(ctx, st);
return 0;
}
int main(int argc, char **argv)
{
createSharedMemory();
ipcon_create(&MyIP);
// Connect to brickd
if(ipcon_connect(&MyIP, HOST, PORT) < 0) {
fprintf(stderr, "Could not connect to brickd\n");
exit(1);
}
getTinker();
sleep(2); // Es dauert etwas, bis die Enumeration der Devices durch ist, also warten !!!
if ( tinkerCounter <= 0 ) {
fprintf(stderr,"Kein Gerät vorhanden ");
exit(2);
}
curses_init();
showSystem(1);
// Threads für die Anzeige erstellen
tf1_init();
getchar();
curses_end();
deleteSharedMemory();
return (0);
}
int main() {
int shmId = createSharedMemory();
if(shmId == -1) {
perror("Could not create shared memory");
return 1;
}
Buffer* buffer;
if(sharedBufferInit(shmId, &buffer, BUFFERSIZE)) {
perror("Could not initialize buffer");
return 1;
}
fprintf(stderr, "%d", shmId);
sigset_t sigset;
int sig;
sigemptyset(&sigset);
sigaddset(&sigset, SIGUSR1);
sigprocmask(SIG_BLOCK, &sigset, NULL);
printf("[%s] Producer is ready. Waiting for SIGUSR1 to PID=%d.\n", getTime(), getpid());
sigwait(&sigset, &sig);
generateData(buffer);
destroySharedMemory(shmId);
return 0;
}
int main()
{
int key1=ftok(".",1);
int key2=ftok(".",2);
int key3=ftok(".",3);
printf("%d %d %d",key1,key2,key3);
int semid =createSemaphore(key1,2);//S1 S2
int shmid1=createSharedMemory(key2,10);//x
printf("shmid1 %d from main\n",shmid1);
char *X =(char *)attachSharedMemory(shmid1);
// int shmid2=createSharedMemory(key3,10);//y
// printf("shmid2 %d from main\n",shmid2);
char *Y ; //=//(char *)attachSharedMemory(shmid2);
int *values=(int *)malloc(sizeof(int *)*2);
*values=0;*(values+1)=0;
initSemaphore(semid,values);
/* V(semid,0);
printf("hi");
P(semid,0);
*/
int x=0,y=0,i;
while(1)
{
// write(x)
i=0;
printf("P1 X=%d Y=%d\n",x,y);
while(x>0)
{
*X=x%10-'0';x/=10;X++;i++;
}
printf("*\n");
*X='\0';
printf("*\n");
X-=i;//X Points to start of shared memory
//V(1)
V(semid,0);
//P(2)
P(semid,1);
//Read Y
i=0;
while(*Y!='\0')
{
y=y*10+(*Y+'0');Y++;i++;
}
Y-=i;
//X=Y+1;
x=y+1;
printf("P1 X=%d Y=%d\n",x,y);
}
}
void Server::initServer(int port){
createSharedMemory();
int id = fork();
struct stat st;
if (stat(FIFO_NAME, &st) != 0)
mkfifo(FIFO_NAME, 0666);
if(id > 0){
initSocket(port);
wait();
}
else if (id == 0){
consumeData();
}
}
bool CrashHandlerImpl::initialize() {
Autolock autoLock(&m_Lock);
bool initialized = true;
m_CrashHandlerPath = platform::getHelperExecutable(m_CrashHandlerApp);
if(!createSharedMemory()) {
return false;
}
fillBasicCrashInfo();
if(!registerCrashHandlers()) {
destroySharedMemory();
initialized = false;
}
return initialized;
}
bool CrashHandlerImpl::initialize() {
Autolock autoLock(&m_Lock);
bool initialized = true;
fs::path local_path = fs::path(getExecutablePath());
if(!local_path.empty()) {
local_path = local_path.parent() / m_CrashHandlerApp;
if(fs::exists(local_path)) {
m_CrashHandlerPath = local_path;
}
}
if(m_CrashHandlerPath.empty()) {
local_path = m_CrashHandlerApp;
if(fs::exists(local_path)) {
m_CrashHandlerPath = local_path;
}
}
if(fs::libexec_dir && m_CrashHandlerPath.empty()) {
local_path = fs::path(fs::libexec_dir) / m_CrashHandlerApp;
if(fs::exists(local_path)) {
m_CrashHandlerPath = local_path;
}
}
if(!createSharedMemory()) {
return false;
}
fillBasicCrashInfo();
if(!registerCrashHandlers()) {
destroySharedMemory();
initialized = false;
}
return initialized;
}
int main(int argc, char ** argv)
{
numberOfPhilosophers = atoi(argv[1]);
cnts = malloc(numberOfPhilosophers * sizeof(int));
pids = malloc(numberOfPhilosophers * sizeof(int));
pid_t t;
beginPosOfStick = malloc(numberOfPhilosophers * sizeof(int));
while (1)
{
int correctBegin = 0;
for (int i = 0; i < numberOfPhilosophers; ++i)
beginPosOfStick[i] = (i - rand() % 2 + numberOfPhilosophers) % numberOfPhilosophers;
for (int i = 0; i < numberOfPhilosophers; ++i)
if (beginPosOfStick[i] == i && beginPosOfStick[(i + 1) % numberOfPhilosophers] == i)
correctBegin = 1;
if (correctBegin)
break;
}
for (int i = 0; i < numberOfPhilosophers; ++i)
printf("stick #%d is in philosopher's #%d hands\n", i, beginPosOfStick[i]);
createSharedMemory();
for (philosopherNumber = 0; philosopherNumber < numberOfPhilosophers - 1; ++philosopherNumber)
{
t = fork();
if (t == 0)
break;
else
pid[philosopherNumber] = t;
}
if (philosopherNumber == numberOfPhilosophers - 1)
pid[numberOfPhilosophers - 1] = getpid();
solve();
free(cnts);
free(pids);
return 0;
}
int main(int argc, char *argv[])
{
const unsigned int EXPECTED_ARGC = 2;
const unsigned int KEY_FILE_ARG_INDEX = 1;
const unsigned char KEY_CHAR = 'H';
const char ENDLINE[] = "\n";
const char SEPERATOR[] = ",";
key_t key = 0;
char *shm_addr = NULL;
int csv_fd = 0, queue_length = 0, shm_id = 0, sem_id = 0;
int job_number = 0, rel_prio = 0, real_prio = 0;
initSigactions();
// Initialize the rand() seed.
srand(time(NULL));
if(argc != EXPECTED_ARGC)
{
// No checking needed, exits with error code.
write(STDERR_FILENO, NOF_INPUTS_ERROR, sizeof(NOF_INPUTS_ERROR));
exit(EXIT_ERROR_CODE);
}
// Create fifo.
if(mkfifo(FIFO_NAME, ALLOW_READ_WRITE_TO_ALL) < 0)
{
// No checking needed, exits with error code.
write(STDERR_FILENO, MKFIFO_ERROR, sizeof(MKFIFO_ERROR));
exit(EXIT_ERROR_CODE);
}
writePidToFifo();
// Wait for the queue process' singal.
waitForSignal();
printf("got signal from %d!\n", Queue_Pid);
// Generate key from the given file
key = ftok(argv[KEY_FILE_ARG_INDEX], KEY_CHAR);
if(key < 0)
{
deleteFifo();
// No checking needed, exits with error code.
write(STDERR_FILENO, FTOK_ERROR, sizeof(FTOK_ERROR));
exit(EXIT_ERROR_CODE);
}
// Create shared memory.
shm_addr = createSharedMemory(key, &shm_id);
// Create semaphore.
sem_id = createBinarySemaphore(key, shm_id);
// Notify the queue.out process.
if(kill(Queue_Pid, SIGUSR1) < 0)
{
deleteFifo();
// No checking needed, exits with error code.
write(STDERR_FILENO, KILL_ERROR, sizeof(KILL_ERROR) - 1);
exit(EXIT_ERROR_CODE);
}
queue_length = readQueueLengthFromFifo();
printf("Got N: %d\n", queue_length);
// Done using the fifo - delete it.
deleteFifo();
// Game Started!
handleGame(shm_id, shm_addr, sem_id, queue_length, &job_number, \
&rel_prio, &real_prio);
deleteResources(shm_id, sem_id);
// Write results
csv_fd = open(CSV_FILE_PATH, O_CREAT | O_APPEND | O_RDWR, ALLOW_READ_WRITE_TO_ALL);
if(csv_fd < 0)
{
// No checking needed, exits with error code.
write(STDERR_FILENO, OPEN_ERROR, sizeof(OPEN_ERROR) - 1);
exit(EXIT_ERROR_CODE);
}
writeIntWithEnding(csv_fd, queue_length, SEPERATOR);
writeIntWithEnding(csv_fd, job_number, SEPERATOR);
writeIntWithEnding(csv_fd, rel_prio, SEPERATOR);
writeIntWithEnding(csv_fd, real_prio, ENDLINE);
return EXIT_OK_CODE;
}
void writeEncDecLog(int syslogType, eCRYPT_LOG_MESSAGE logMessage, void* data)
{
if( IS_SUCCESS )
{
if( logMessage == eCryptLogMessage_Allow )
*IS_SUCCESS = true;
else
*IS_SUCCESS = false;
}
void* logSM = getSharedMemory(LOG_SHARED_MEMORY_KEY, LOG_SHARED_MEMORY_SIZE);
if( logSM == NULL )
logSM = createSharedMemory(LOG_SHARED_MEMORY_KEY, LOG_SHARED_MEMORY_SIZE);
char dbsLogBuf[256] = {'\0', };
size_t logSMLength = strlen((char*)logSM);
bool isFind = false;
int dbsLogReplaceIndex = 0;
int dbsLogCnt = 0;
char** dbsLog = strSplitWithLength(logSM, logSMLength, LINE_SPLIT_STR, &dbsLogCnt);
for(int i = 0 ; i < dbsLogCnt ; ++i)
{
if( i > 0 )
dbsLogReplaceIndex += strlen(LINE_SPLIT_STR);
int logDataCnt = 0;
int logDataLength = strlen(dbsLog[i]);
char** logData = strSplitWithLength(dbsLog[i], logDataLength, LOG_SPLIT_STR, &logDataCnt);
char* smLogThreadID = logData[1];
int smLogType = atoi(logData[2]);
char* smLogAccessIP = logData[3];
char* smLogAccessUser = logData[4];
char* smLogProgramName = logData[5];
int smLogMessage = atoi(logData[6]);
int smLogCnt = atoi(logData[7]);
if( memcmp(LOG_THREAD_ID, smLogThreadID, LOG_THREAD_ID_LENGTH) != 0 ||
LOG_TYPE != smLogType ||
memcmp(LOG_ACCESS_IP, smLogAccessIP, LOG_ACCESS_IP_LENGTH) != 0 ||
memcmp(LOG_ACCESS_USER, smLogAccessUser, LOG_ACCESS_USER_LENGTH) != 0 ||
memcmp(LOG_PROGRAM_NAME, smLogProgramName, LOG_PROGRAM_NAME_LENGTH) != 0 ||
smLogMessage != logMessage )
{
dbsLogReplaceIndex += logDataLength;
freeSplit(logData, logDataCnt);
continue;
}
else
{
if( smLogMessage == eCryptLogMessage_Over_Behavior && strcmp((char*)data, logData[8]) != 0 )
{
dbsLogReplaceIndex += logDataLength;
freeSplit(logData, logDataCnt);
continue;
}
}
isFind = true;
sprintf(dbsLogBuf, "%d%s%s%s%d%s%s%s%s%s%s%s%d%s%d"
, syslogType, LOG_SPLIT_STR
, LOG_THREAD_ID, LOG_SPLIT_STR
, LOG_TYPE, LOG_SPLIT_STR
, LOG_ACCESS_IP, LOG_SPLIT_STR
, LOG_ACCESS_USER, LOG_SPLIT_STR
, LOG_PROGRAM_NAME, LOG_SPLIT_STR
, logMessage, LOG_SPLIT_STR
, smLogCnt + 1);
if( logMessage == eCryptLogMessage_Over_Behavior )
{
char dataBuf[64] = {'\0', };
sprintf(dataBuf, "%s%s", LOG_SPLIT_STR, (char*)data);
strcat(dbsLogBuf, dataBuf);
}
char* dbsFinalLog = replaceIndexWithLength(logSM, dbsLogReplaceIndex, logSMLength, dbsLog[i], dbsLogBuf);
writeSharedMemory(logSM, dbsFinalLog);
free(dbsFinalLog);
freeSplit(logData, logDataCnt);
break;
}
freeSplit(dbsLog, dbsLogCnt);
if( !isFind )
{
sprintf(dbsLogBuf, "%s%d%s%s%s%d%s%s%s%s%s%s%s%d%s%d"
, ( dbsLogCnt > 0 ) ? LINE_SPLIT_STR : ""
, syslogType, LOG_SPLIT_STR
, LOG_THREAD_ID, LOG_SPLIT_STR
, LOG_TYPE, LOG_SPLIT_STR
, LOG_ACCESS_IP, LOG_SPLIT_STR
, LOG_ACCESS_USER, LOG_SPLIT_STR
, LOG_PROGRAM_NAME, LOG_SPLIT_STR
, logMessage, LOG_SPLIT_STR
, 1);
if( logMessage == eCryptLogMessage_Over_Behavior )
{
char dataBuf[64] = {'\0', };
sprintf(dataBuf, "|%s", (char*)data);
strcat(dbsLogBuf, dataBuf);
}
strcat(logSM, dbsLogBuf);
}
releaseSharedMemory(logSM);
}
/**
* Creates/open a shared memory region
*
* The rootname will uniquely identify the shared memory region,
* and is valid across different JVM instance.
*
* The shared memory region should persist across process, until OS reboots
* or destroy call is being made.
*
* @param[in] portLibrary The port Library
* @param[out] handle This handle is required for further attach/destroy of the memory region
* @param[in] rootname Shared name for the region, which used to identify the region.
* @param[in] size Size of the region in bytes
* @param[in] perm permission for the region.
*
* @return
* \arg HYPORT_ERROR_SHMEM_OPFAILED Failure - Cannot open the shared memory region
* \arg HYPORT_INFO_SHMEM_OPENED Success - Existing memory region has been opened
* \arg HYPORT_INFO_SHMEM_CREATED Success - A new shared memory region has been created
*
*/
IDATA VMCALL
hyshmem_open (HyPortLibrary * portLibrary, struct hyshmem_handle **handle,
const char *rootname, I_32 size, I_32 perm)
{
/*TODO: Do we need the length to be longer? */
char controlFile[HYSH_MAXPATH];
IDATA retryCount, exist;
key_t fkey;
void *region;
int retry = RETRY_COUNT;
Trc_PRT_shmem_hyshmem_open_Entry (rootname, size, perm);
if (ensureDirectory (portLibrary) == FAILED)
{
portLibrary->error_set_last_error (portLibrary, errno,
HYPORT_ERROR_SHMEM_DATA_DIRECTORY_FAILED);
Trc_PRT_shmem_hyshmem_open_Exit3 ();
return HYPORT_ERROR_SHSEM_OPFAILED;
}
getControlFilePath (portLibrary, controlFile, HYSH_MAXPATH, rootname);
while (retry)
{
I_32 rc;
rc = portLibrary->file_attr (portLibrary, controlFile);
if (HyIsFile != rc)
{
Trc_PRT_shmem_hyshmem_open_Event1 (controlFile);
rc =
createSharedMemory (portLibrary, handle, controlFile, size, perm);
}
else
{
Trc_PRT_shmem_hyshmem_open_Event2 (controlFile);
rc = openSharedMemory (portLibrary, handle, controlFile);
}
switch (rc)
{
case RETRY:
Trc_PRT_shmem_hyshmem_open_Event3 (retry);
retry--;
usleep (100);
continue;
case FAILED:
Trc_PRT_shmem_hyshmem_open_Exit1 ();
return HYPORT_ERROR_SHMEM_OPFAILED;
default:
Trc_PRT_shmem_hyshmem_open_Exit (rc, *handle);
return rc;
}
}
/* max number of retry count reach, return failure */
portLibrary->file_unlink (portLibrary, controlFile);
Trc_PRT_shmem_hyshmem_open_Exit2 ();
return HYPORT_ERROR_SHMEM_OPFAILED;
}
JNIEXPORT jboolean JNICALL
Java_com_sun_media_renderer_video_XLibRenderer_xlibSetOutputSize(JNIEnv *env,
jobject blitter,
jint outWidth,
jint outHeight)
{
/* We assume that this function is called only if there is a size change */
XlibBlitter *xblitter = (XlibBlitter*) GetIntField(env, blitter, "blitter");
int inWidth = xblitter->inWidth;
int inHeight = xblitter->inHeight;
int stride = xblitter->inStride;
awtLock(env, xblitter);
/* Get rid of the old image and arrays */
if (xblitter->ximage) {
/* Clean up shared memory */
if (xblitter->shmActive) {
destroySharedMemory(xblitter);
}
xblitter->ximage->data = NULL;
XDestroyImage(xblitter->ximage);
}
if (xblitter->scaledData) {
free(xblitter->scaledData);
xblitter->scaledData = NULL;
}
if (xblitter->xincs) {
free(xblitter->xincs);
xblitter->xincs = NULL;
}
if (xblitter->yincs) {
free(xblitter->yincs);
xblitter->yincs = NULL;
}
xblitter->outWidth = outWidth;
xblitter->outHeight = outHeight;
if ( outWidth != xblitter->inWidth ||
outHeight != xblitter->inHeight) {
/* We need to scale */
xblitter->xincs = (char *) malloc(outWidth * sizeof(char));
xblitter->yincs = (char *) malloc(outHeight * sizeof(char));
{
int x, y, oldValue, newValue, xtotal;
oldValue = 0; xtotal = 0;
for (x = 1; x < xblitter->outWidth; x++) {
newValue = (int)((double)(x * xblitter->inWidth) / outWidth);
xblitter->xincs[x-1] = newValue - oldValue;
xtotal += newValue - oldValue;
oldValue = newValue;
}
xblitter->xincs[x - 1] = xblitter->inStride - xtotal;
oldValue = 0;
for (y = 1; y < xblitter->outHeight; y++) {
newValue = (int)((double)(y * inHeight) / outHeight);
xblitter->yincs[y-1] = newValue - oldValue;
oldValue = newValue;
}
}
stride = outWidth;
} else {
/* No scaling required */
xblitter->xincs = NULL;
xblitter->yincs = NULL;
xblitter->scaledData = NULL;
}
/* Try to allocate a shared memory image */
if (xblitter->shmAvailable) {
createSharedMemory(xblitter, outWidth, outHeight);
}
/* If a shared memory image could not be created and we need to scale, use XLib */
if (xblitter->shmActive == 0) {
if ( outWidth != xblitter->inWidth || outHeight != xblitter->inHeight) {
xblitter->scaledData = (void *) malloc(outWidth * outHeight *
(xblitter->bitsPerPixel >> 3));
}
xblitter->ximage = XCreateImage(xblitter->display, xblitter->visual,
xblitter->depth, ZPixmap, 0,
(char *)0, outWidth, outHeight,
xblitter->bitsPerPixel,
stride * (xblitter->bitsPerPixel >> 3));
}
