Пример #1
0
int main(int argc, char **argv)
{
    pthread_mutex_t mutex;
    pthread_mutexattr_t attr;
    int i;
    char *processName;
    
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_setpshared(&attr, 0);
    pthread_mutex_init(&mutex, &attr);
    
    pid_t pid = fork();
    
    if (pid >= 0) {
        if (pid == 0) {
            processName = "Child process";
        } else {
            processName = "Parent process";
        }
        
        for (i = 0; i < 10; ++i) {
            printf("%s: acquiring mutex.\n", processName);
            pthread_mutex_lock(&mutex);
            printf("%s: mutex acquired, sleeping.\n", processName);
            sleep(1);
            printf("%s: Done sleeping, releasing mutex.\n", processName);
            pthread_mutex_unlock(&mutex);
            printf("%s: Mutex released.\n", processName);
        }
    } else {
        printf("Failed to fork\n");
    }
    
    return 0;
}
Пример #2
0
inline void tal_init(lock_t* lock, lock_attr_t* attr)
{
  /* Set attributes */
  if (attr != NULL) {
    memcpy(&(lock->attr), attr, sizeof(lock_attr_t));
  }

#ifdef WITH_POSIX_THREAD_PROCESS_SHARED
  if (pthread_mutexattr_init(&(lock->mtx_attr)) != 0) {
    fprintf(stderr, "Error: Could not init mutexattr\n");
  }

  if (pthread_mutexattr_setpshared(&(lock->mtx_attr), PTHREAD_PROCESS_SHARED) != 0) {
    fprintf(stderr, "Error: Could not set pshared\n");
  }

  if (pthread_mutex_init(&(lock->mtx), &(lock->mtx_attr)) != 0) {
    fprintf(stderr, "Error: Could not initalize mutex\n");
  }
#else
#if LOCK_ROUND_ROBIN == 1
  fork_idx = attr->fork_idx;
  lock->current_idx = fork_idx;
#else
  atomic_flag_clear(&(lock->cat));
#endif
#endif
}
Пример #3
0
void accept_mutex_init(void)
{
    pthread_mutexattr_t mattr;
    int fd;

    fd = open ("/dev/zero", O_RDWR);
    if (fd == -1) {
	perror ("open(/dev/zero)");
	exit (1);
    }
    mutex = (pthread_mutex_t *)mmap ((caddr_t)0, sizeof (*mutex),
		    PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (mutex == (void *)(caddr_t)-1) {
	perror ("mmap");
	exit (1);
    }
    close (fd);
    if (pthread_mutexattr_init(&mattr)) {
	perror ("pthread_mutexattr_init");
	exit (1);
    }
    if (pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED)) {
	perror ("pthread_mutexattr_setpshared");
	exit (1);
    }
    if (pthread_mutex_init(mutex, &mattr)) {
	perror ("pthread_mutex_init");
	exit (1);
    }
    sigfillset(&accept_block_mask);
    sigdelset(&accept_block_mask, SIGHUP);
    sigdelset(&accept_block_mask, SIGTERM);
    sigdelset(&accept_block_mask, SIGUSR1);
}
Пример #4
0
Файл: mutex.cpp Проект: adob/axe
        Mutex::Mutex() {
            pthread_mutexattr_t attr;
            
            if (int code = pthread_mutexattr_init(&attr)) {
                raise(code);
            }

            if (int code = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE)) {
                pthread_mutexattr_destroy(&attr);
                raise(code);
            }

            //         if (pthread_mutexattr_settype&attr, PTHREAD_MUTEX_DEFAULT) {
            //             pthread_mutexattr_destory(&attr);
            //             throw error(errno);
            //         }
            //         
            //         if (pthread_mutexattr_setprotocol&attr, PTHREAD_PRIO_NONE)) {
            //             pthread_mutexattr_destory(&attr);
            //             throw error(errno);
            //         }

            if (int code = pthread_mutex_init(&mutex, &attr)) {
                pthread_mutexattr_destroy(&attr);
                raise(code);
            }

            if (int code = pthread_mutexattr_destroy(&attr)) {
                raise(code);
            }
            //print "create";
        }
Пример #5
0
static ledger_status create_locks(ledger_partition *partition, int fd) {
    ledger_status rc;
    ledger_partition_locks locks;
    pthread_mutexattr_t mattr;
    pthread_condattr_t cattr;

    rc = pthread_mutexattr_init(&mattr);
    ledger_check_rc(rc == 0, LEDGER_ERR_GENERAL, "Failed to initialize mutex attribute");

    rc = pthread_condattr_init(&cattr);
    ledger_check_rc(rc == 0, LEDGER_ERR_GENERAL, "Failed to initialize cond attribute");

    rc = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
    ledger_check_rc(rc == 0, LEDGER_ERR_GENERAL, "Failed to set mutex attribute to shared");

    rc = pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
    ledger_check_rc(rc == 0, LEDGER_ERR_GENERAL, "Failed to set cond attribute to shared");

    rc = pthread_mutex_init(&locks.rotate_lock, &mattr);
    ledger_check_rc(rc == 0, LEDGER_ERR_GENERAL, "Failed to initialize journal rotate mutex");

    rc = pthread_cond_init(&locks.rotate_cond, &cattr);
    ledger_check_rc(rc == 0, LEDGER_ERR_GENERAL, "Failed to initialize journal rotate cond");

    rc = ledger_pwrite(fd, (void *)&locks, sizeof(ledger_partition_locks), 0);
    ledger_check_rc(rc, LEDGER_ERR_IO, "Failed to write meta number of entries");

    return LEDGER_OK;

error:
    return rc;
}
Пример #6
0
int main()
{

	/* Make sure there is process-shared capability. */
	#ifndef PTHREAD_PROCESS_SHARED
	fprintf(stderr,"process-shared attribute is not available for testing\n");
	return PTS_UNRESOLVED;
	#endif

	pthread_mutexattr_t mta;
	int ret;

	 /* Set the attribute to INVALID_PSHARED_VALUE.  */
	ret=pthread_mutexattr_setpshared(&mta, INVALID_PSHARED_VALUE);
	if (ret != 0)
	{
		if (ret == EINVAL)
		{
			printf("Test PASSED\n");
			return PTS_PASS;
		}

		printf("Test FAILED: Expected return code 0 or EINVAL, got: %d", ret);
		return PTS_FAIL;
	}

	printf("Test PASSED: NOTE*: Returned 0 on error, though standard states 'may' fail.\n");
       	return PTS_PASS;

}
Пример #7
0
int
init_shared_state (struct uiomux_state * state)
{
  struct uiomux_block * block;
  pthread_mutexattr_t attr;
  pthread_mutex_t * mutex;
  struct uio * uio;
  int i;

  state->num_blocks = UIOMUX_BLOCK_MAX;

  pthread_mutexattr_init (&attr);
  pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);

  for (i = 0; i < UIOMUX_BLOCK_MAX; i++) {
    /* Initialize mutex, regardless */
    mutex = &state->mutex[i].mutex;
    pthread_mutex_init (mutex, &attr);
  }

  pthread_mutexattr_destroy (&attr);

  init_owners_table (state);

  return 0;
}
Пример #8
0
int allocate_shared_segment_mutexes(shm_daf_t *p, char *errmsg, int max_msg_length)
{

#undef  SUBNAME
#define SUBNAME "allocate_shared_segment_mutexes"

    char msg[MAX_MSG_LEN];
    pthread_mutexattr_t psharedm;

    pthread_mutexattr_init(&psharedm);
    pthread_mutexattr_setpshared(&psharedm, PTHREAD_PROCESS_SHARED);

    if (pthread_mutex_init(&(p->service_cmd_log_object.mp), &psharedm) != 0)
    {
        sprintf(msg, "%s: problem initialising service cmd log mutex, errno = %d - exiting", SUBNAME, errno);
        exit(1);
    }

    if (pthread_mutex_init(&(p->active_steps_object.mp), NULL) != 0)
    {
        sprintf(msg, "%s: problem initialising active_steps_object mutex, errno = %d - exiting", SUBNAME, errno);
        exit(1);
    }

    return 0;

}
Пример #9
0
void init_ring_buffer(struct ring_buffer* rbuff) {
  rbuff->request_writes = 0;
  rbuff->request_reads = 0;

  rbuff->response_writes = 0;
  rbuff->response_reads = 0;

  pthread_mutexattr_t mattr;
  pthread_mutexattr_init(&mattr);
  pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);  
  pthread_mutex_init(&rbuff->data_mutex, &mattr);
  
  pthread_condattr_t  cattr;
  pthread_condattr_init(&cattr);
  pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
  pthread_cond_init(&rbuff->nonempty, &cattr);
  

  int i;
  for(i = 0; i < MAXSIZE; i++) {
    pthread_cond_init(&rbuff->response_ready[i], &cattr);
    rbuff->buffer[i].request_client.response = i;
  }

}
Пример #10
0
/* init shm header */
void shm_init_header( ssm_header *header, int data_size, int history_num, ssmTimeT cycle )
{
	pthread_mutexattr_t mattr;
	pthread_condattr_t cattr; 

	header->tid_top = SSM_TID_SP - 1;	/* 初期位置 */
	header->size = data_size;	/* データサイズ */
	header->num = history_num;	/* 履歴数 */
	//header->table_size = hsize;	/* テーブルサイズ */
	header->cycle = cycle;	/* データ最小サイクル */
	header->data_off = sizeof( ssm_header );	/* データの先頭アドレス */
	header->times_off = header->data_off + ( data_size * history_num );	/* 時刻の先頭アドレス */
	//header->table_off = header->times_off + sizeof( ssmTimeT ) * hsize ;	/* time tableの先頭アドレス */
	
	/* 同期用mutexの初期化 */
	pthread_mutexattr_init(&mattr);
	pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
	pthread_mutex_init(&header->mutex, &mattr); 

	pthread_condattr_init(&cattr);
	pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
	pthread_cond_init(&header->cond, &cattr);
	
	pthread_mutexattr_destroy( &mattr );
	pthread_condattr_destroy( &cattr );
}
Пример #11
0
int clockobj_init(struct clockobj *clkobj,
		  unsigned int resolution_ns)
{
	pthread_mutexattr_t mattr;
	struct timespec now;
	int ret;

	if (resolution_ns == 0)
		return __bt(-EINVAL);

	memset(clkobj, 0, sizeof(*clkobj));
	ret = __clockobj_set_resolution(clkobj, resolution_ns);
	if (ret)
		return __bt(ret);

	/*
	 * FIXME: this lock is only used to protect the wallclock
	 * offset readings from updates. We should replace this by a
	 * confirmed reading loop.
	 */
	pthread_mutexattr_init(&mattr);
	pthread_mutexattr_settype(&mattr, mutex_type_attribute);
	pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT);
	pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_PRIVATE);
	ret = __bt(-__RT(pthread_mutex_init(&clkobj->lock, &mattr)));
	pthread_mutexattr_destroy(&mattr);
	if (ret)
		return ret;

	__RT(clock_gettime(CLOCK_COPPERPLATE, &now));
	timespec_sub(&clkobj->offset, &clkobj->epoch, &now);

	return 0;
}
Пример #12
0
/*
 * Initializes a mutex.
 */
int mutex_init(OS_MUTEX *p_mutex, const char *name)
{
	int rc = 0;

	if (p_mutex)
	{
		// set attributes to make mutex reentrant (like windows implementation)
		pthread_mutexattr_t attr;
		pthread_mutexattr_init(&attr);
		pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

		// if named make it cross-process safe
		if (name)
		{
			pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
			// create a shared memory id
			int shmid = shmget(atoi(name), sizeof (pthread_mutex_t), IPC_CREAT | 0666);
			if (shmid != -1)
			{
				// attach to the shared memory
				pthread_mutex_t *p_tmp = (pthread_mutex_t *)shmat(shmid, NULL, 0);
				if (p_tmp)
				{
					memmove(p_mutex, p_tmp, sizeof (pthread_mutex_t));
				}
			}
		}

		// failure when pthread_mutex_init(..) != 0
		rc = (pthread_mutex_init((pthread_mutex_t *)p_mutex, &attr) == 0);
	}
	return rc;
}
Пример #13
0
int main(){
	
	pthread_mutexattr_t mutex_attr;
	pthread_condattr_t cond_attr;
	buffer.occupied = buffer.nextin = buffer.nextout = 0;
	
	pthread_mutexattr_init(&mutex_attr);
	pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED);
	pthread_mutex_init(&buffer.lock, &mutex_attr);
	
	pthread_condattr_init(&cond_attr);
	pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED);
	pthread_cond_init(&buffer.less, &cond_attr);
	pthread_cond_init(&buffer.more, &cond_attr);
	
	
	pthread_t cons, prod;
	int idCons = 0, idProd = 1;
	
	pthread_create(&cons, NULL, (void *) conscons, (void *) &idCons);
	pthread_create(&prod, NULL, (void *) prodprod, (void *) &idProd);
	
	pthread_join(cons, NULL);
	pthread_join(prod, NULL);
	
	return 0;
}
Пример #14
0
/*
 * Create new hashmap.
 * Size is the size of the number of map slots. Leave it 0
 * if you want to use a default value.
 */
struct hashmap *hashmap_create(unsigned int size)
{
  struct hashmap *map;
  
  if (size == 0)
    size = HASHMAP_DEFAULT_SIZE;

  map = (struct hashmap *) malloc(sizeof(struct hashmap));
  if (map == NULL)
    return NULL;
  
  int table_size = sizeof(struct hashmap_item *) * size;
  
  map->size = size;
  map->table = (struct hashmap_item **) malloc(table_size);
  if (map->table == NULL) {
    free(map);
    return NULL;
  }
  bzero(map->table, table_size);
  
#ifdef HASHMAP_THREAD_SAVE
  pthread_mutexattr_t mattr;
  pthread_mutexattr_init(&mattr);
  pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
  pthread_mutex_init(&map->mutex, &mattr);
#endif /* HASHMAP_THREAD_SAVE */
  
  return map;
}
Пример #15
0
int swTable_create(swTable *table)
{
    uint32_t row_num = table->size * (1 + SW_TABLE_CONFLICT_PROPORTION);

    //header + data
    uint32_t row_memory_size = sizeof(swTableRow) + table->item_size;

    /**
     * row data & header
     */
    size_t memory_size = row_num * row_memory_size;

    /**
     * memory pool for conflict rows
     */
    memory_size += sizeof(swMemoryPool) + sizeof(swFixedPool) + ((row_num - table->size) * sizeof(swFixedPool_slice));

    /**
     * for iterator, Iterate through all the elements
     */
    memory_size += table->size * sizeof(swTableRow *);

    void *memory = sw_shm_malloc(memory_size);
    if (memory == NULL)
    {
        return SW_ERR;
    }

    memset(memory, 0, memory_size);
    table->memory = memory;
    table->compress_threshold = table->size * SW_TABLE_COMPRESS_PROPORTION;

    table->rows = memory;
    memory += table->size * sizeof(swTableRow *);
    memory_size -= table->size * sizeof(swTableRow *);

#if SW_TABLE_USE_SPINLOCK == 0
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
    pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
    pthread_mutexattr_setrobust_np(&attr, PTHREAD_MUTEX_ROBUST_NP);
#endif

    int i;
    for (i = 0; i < table->size; i++)
    {
        table->rows[i] = memory + (row_memory_size * i);
#if SW_TABLE_USE_SPINLOCK == 0
        pthread_mutex_init(&table->rows[i]->lock, &attr);
#endif
    }

    memory += row_memory_size * table->size;
    memory_size -= row_memory_size * table->size;
    table->pool = swFixedPool_new2(row_memory_size, memory, memory_size);

    return SW_OK;
}
Пример #16
0
 //!Constructor
 mutexattr_wrapper(bool recursive = false)
 {
    if(pthread_mutexattr_init(&m_attr)!=0 ||
       pthread_mutexattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0 ||
        (recursive &&
         pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE)!= 0 ))
       throw interprocess_exception("pthread_mutexattr_xxxx failed");
 }
Пример #17
0
int __darwin_pthread_mutexattr_setpshared(pthread_mutexattr_t* attr, int pshared)
{
	pshared = TranslatePshared(pshared);
	int rv = pthread_mutexattr_setpshared(attr, pshared);
	if (rv == -1)
		errnoOut();
	return rv;
}
Пример #18
0
/*
 * Return a process-shared (global) mutex:
 */
static void init_global_mutex(pthread_mutex_t *mutex)
{
	pthread_mutexattr_t attr;

	pthread_mutexattr_init(&attr);
	pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
	pthread_mutex_init(mutex, &attr);
}
Пример #19
0
bool CMutexLock::MutexSetProcessShare()
{
	if(!m_pstAttr) {
		fprintf(stderr, "m_pstAttr is NULL.\n");
		return false;
	}
	return !pthread_mutexattr_setpshared((pthread_mutexattr_t*)m_pstAttr, PTHREAD_PROCESS_SHARED);
}
Пример #20
0
void Pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int flag)
{
	int n;
	if ((n = pthread_mutexattr_setpshared(attr, flag)) != 0)
		err_sys("pthread_metxattr_setpshared error");

	return;
}
Пример #21
0
int main(int argc, char *argv[]) {
	printf("Server started \n");

	/* Create shared memory */
	int file_descriptor;
	file_descriptor = shm_open("/sharedpid", O_RDWR | O_CREAT, S_IRWXU);

	/* Resize shared memory */
	ftruncate(file_descriptor, sizeof(pid_data));

	/* Map shared memory into address space */
	void* shared_memory;
	shared_memory = mmap(0, sizeof(pid_data), PROT_READ | PROT_WRITE, MAP_SHARED, file_descriptor, 0);

	/* Create struct */
	pid_data data;
	data.pid = getpid();

	/* Create Mutex */
	pthread_mutex_t lock = ((pid_data*)shared_memory)->pid_mutex;
	pthread_mutexattr_t myattr;
	pthread_mutexattr_init(&myattr);
	pthread_mutexattr_setpshared(&myattr, PTHREAD_PROCESS_SHARED);
	pthread_mutex_init(&lock, &myattr );

	/* Set pid in shared memory */
	pthread_mutex_lock(&lock);
	*((pid_data*)shared_memory) = data;
	pthread_mutex_unlock(&lock);
	printf("Pid stored in shared memory \n");


	/* Create channel */
	int ch_id = ChannelCreate(0);
	printf("Channel %d created \n", ch_id);
	int rcv_id;
	int buffer_recv;
	int buffer_resp;
	struct _msg_info msg_info;

	/* Set priority */
	set_priority(SERVER_PRIORITY);

	/* Listen for client */
	printf("Server listening... \n");
	while(1){
		printf("Server priority: %d\n", get_priority());
		rcv_id = MsgReceive(ch_id, &buffer_recv, sizeof(buffer_recv), &msg_info);
		buffer_resp = buffer_recv + 1;
		printf("Received: %d, Responding: %d \n", buffer_recv, buffer_resp);

		if(MsgReply(rcv_id, EOK, &buffer_resp, sizeof(buffer_resp)) != EOK){
			printf("ERROR: failed to reply to message: %d \n", buffer_recv);
		}
	}

	return EXIT_SUCCESS;
}
Пример #22
0
/* }}} */
xc_mutex_t *xc_mutex_init(xc_mutex_t *const shared_mutex, const char *pathname, unsigned char want_inter_process) /* {{{ */
{
	xc_mutex_t *mutex = NULL;
	(void) want_inter_process; /* may be unused */

#ifndef HAVE_FORK
	want_inter_process = 0;
#endif

	/* if interprocessed is needed, shared_mutex is required to be a pre-allocated memory on shm
	 * this function can always return non-shared memory if necessary despite shared memory is given
	 */

	/* when inter-process is wanted, pthread lives in shm */
#ifdef XC_MUTEX_USE_PTHREAD
	if (want_inter_process) {
		assert(shared_mutex);
		mutex = shared_mutex;
		mutex->shared = 1;
	}
	else
#endif
	{
		/* all other mutex assumed live locally */
		mutex = calloc(1, sizeof(*mutex));
		mutex->shared = 0;
#ifdef XC_MUTEX_HAVE_INTERPROCESS_SWITCH
		mutex->want_inter_process = want_inter_process;
#endif
	}


#ifdef XC_MUTEX_USE_PTHREAD
	{
		/* If you see mutex leak using valgrind, see xc_mutex_destroy function */
		pthread_mutexattr_t psharedm;
		pthread_mutexattr_init(&psharedm);
		pthread_mutexattr_setpshared(&psharedm, xc_want_inter_process() ? PTHREAD_PROCESS_PRIVATE : PTHREAD_PROCESS_SHARED);
		pthread_mutex_init(&mutex->pthread_mutex, &psharedm);
	}
#endif

#ifdef XC_MUTEX_USE_TSRM
	mutex->tsrm_mutex = tsrm_mutex_alloc();
#endif

#ifdef XC_MUTEX_USE_FCNTL
	if (xc_want_inter_process()) {
		xc_fcntl_init(&mutex->fcntl_mutex, pathname);
	}
#endif

#ifndef NDEBUG
	mutex->locked = 0;
#endif

	return mutex;
}
Пример #23
0
int tdb_mutex_init(struct tdb_context *tdb)
{
	struct tdb_mutexes *m;
	pthread_mutexattr_t ma;
	int i, ret;

	ret = tdb_mutex_mmap(tdb);
	if (ret == -1) {
		return -1;
	}
	m = tdb->mutexes;

	ret = pthread_mutexattr_init(&ma);
	if (ret != 0) {
		goto fail_munmap;
	}
	ret = pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK);
	if (ret != 0) {
		goto fail;
	}
	ret = pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED);
	if (ret != 0) {
		goto fail;
	}
	ret = pthread_mutexattr_setrobust(&ma, PTHREAD_MUTEX_ROBUST);
	if (ret != 0) {
		goto fail;
	}

	for (i=0; i<tdb->hash_size+1; i++) {
		pthread_mutex_t *chain = &m->hashchains[i];

		ret = pthread_mutex_init(chain, &ma);
		if (ret != 0) {
			goto fail;
		}
	}

	m->allrecord_lock = F_UNLCK;

	ret = pthread_mutex_init(&m->allrecord_mutex, &ma);
	if (ret != 0) {
		goto fail;
	}
	ret = 0;
fail:
	pthread_mutexattr_destroy(&ma);
fail_munmap:

	if (ret == 0) {
		return 0;
	}

	tdb_mutex_munmap(tdb);

	errno = ret;
	return -1;
}
Пример #24
0
int fifo_init(struct fifo *fifo, size_t size, bool_t prio_inherit) {
#if defined(HAVE_LIBPTHREAD) && !defined(SDL_FIFOS)

#ifndef _POSIX_THREAD_PROCESS_SHARED
#error "no _POSIX_THREAD_PROCESS_SHARED"
#endif /* _POSIX_THREAD_PROCESS_SHARED */

	/* linux multi-process locking */
	pthread_mutexattr_t mutex_attr;
	pthread_condattr_t cond_attr;
	struct utsname utsname;
	int err;

	if ((err = pthread_mutexattr_init(&mutex_attr)) < 0) {
		return err;
	}
	if (prio_inherit) {
		if ((err = pthread_mutexattr_setpshared(&mutex_attr, PTHREAD_PROCESS_SHARED)) < 0) {
			return err;
		}
#ifdef _POSIX_THREAD_PRIO_INHERIT
		/* only on PREEMPT kernels */
		if ((err = uname(&utsname)) < 0) {
			return err;
		}
		if (!RUNNING_ON_VALGRIND && strstr(utsname.version, "PREEMPT") != NULL) {
			if ((err = pthread_mutexattr_setprotocol(&mutex_attr, PTHREAD_PRIO_INHERIT)) < 0) {
				return err;
			}
		}
#endif /* _POSIX_THREAD_PRIO_INHERIT */
	}
	if ((err = pthread_mutex_init(&fifo->mutex, &mutex_attr)) < 0) {
		return err;
	}

	if ((err = pthread_condattr_init(&cond_attr)) < 0) {
		return err;
	}
	if (prio_inherit) {
		if ((err = pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED)) < 0) {
			return err;
		}
	}
	if ((err = pthread_cond_init(&fifo->cond, &cond_attr)) < 0) {
		return err;
	}
#else
	/* cross platform locks */
	fifo->mutex = SDL_CreateMutex();
	fifo->cond = SDL_CreateCond();
#endif
	fifo->rptr = 0;
	fifo->wptr = 0;
	fifo->size = size;

	return 0;
}
Пример #25
0
int main ()
{
  key_t shm_key = 6166529;
  const int shm_size = 1024;

  int shm_id, err_id = 0;
  char* shmaddr, *ptr;
  pthread_mutex_t *mutex_p;
  pthread_mutexattr_t m_attr;

  printf("writer started.\n");

  /* Allocate a shared memory segment. */
  shm_id = shmget(shm_key, shm_size, IPC_CREAT | S_IRUSR | S_IWUSR);

  /* Attach the shared memory segment. */
  shmaddr = (char*) shmat(shm_id, 0, 0);
  printf("shared memory attached at address %p\n", shmaddr);

  /* Start to write data. */
  mutex_p = (pthread_mutex_t *) shmaddr;
  err_id |= pthread_mutexattr_init(&m_attr);
  err_id |= pthread_mutexattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED);
  err_id |= pthread_mutex_init(mutex_p, &m_attr);
  //err_id |= pthread_mutex_init(mutex_p, NULL);
  if (err_id != 0)
  {
    printf("Failed to init mutex - %d.\n", err_id);
    exit(-1);
  }

  ptr = shmaddr + sizeof (pthread_mutex_t);
  sprintf(ptr, "mutex added.");
  printf("writer ended.\n");

  pthread_mutex_lock(mutex_p);
  printf("Mutex locked.\n");

  /*calling the other process*/
  system("./reader&");

  /*sleep 5 seconds.*/
  sleep(5);
  printf("Sleep ended.\n");
  pthread_mutex_unlock(mutex_p);
  printf("Mutex unlocked.\n");

  pthread_mutexattr_destroy(&m_attr);
  pthread_mutex_destroy(mutex_p);

  /* Detach the shared memory segment. */
  shmdt(shmaddr);
  /* Deallocate the shared memory segment.*/
  shmctl(shm_id, IPC_RMID, 0);

  return 0;
}
Пример #26
0
void Pthread_mutexattr_setpshared(pthread_mutexattr_t * attr, int flag)
{
	int n;

	if ((n = pthread_mutexattr_setpshared(attr, flag)) == 0)
		return;
	errno = n;
	fprintf(stderr, "pthread_mutexattr_setpshared error");
}
Пример #27
0
void
CreateXProcLock(void *xproc)
{
	pthread_mutexattr_t  mtxattr;

	(void) pthread_mutexattr_init(&mtxattr);
	(void) pthread_mutexattr_setpshared(&mtxattr, PTHREAD_PROCESS_SHARED);
	(void) pthread_mutex_init((pthread_mutex_t *)xproc, &mtxattr);
}
Пример #28
0
Mutext::Mutext(int nShared, int nType)
{
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_setpshared(&attr, nShared);
    pthread_mutexattr_settype(&attr, nType);
    pthread_mutex_init(&mutext, &attr);
    pthread_mutexattr_destroy(&attr);
}
Пример #29
0
void Pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared)
{
	int err;
	err = pthread_mutexattr_setpshared(attr, pshared);
	if (err) {
		err_msg("%s: pthread_mutexattr_setpshared(): ", __func__);
		err_exit(err, NULL);
	}
}
Пример #30
0
ProcessMutex::ProcessMutex(int size, int key)
    : m_key(key)
    , m_data(0)
    , m_dataSize(sizeof(Header) + size)
{
    if (key < 0) {

        while (m_key < 0) {
            struct timeval tv;
            gettimeofday(&tv, NULL);
            key_t ipckey = ftok(".", tv.tv_usec);
            m_key = ::shmget(ipckey, m_dataSize, 0644 | IPC_CREAT | IPC_EXCL);
            if (m_key == -1 && errno != EEXIST) {
                fprintf(stderr, "ProcessMutex: failed to create mutex: %s\n", strerror(errno));
                return;
            }
        }

        m_data = ::shmat(m_key, NULL, 0);
        if (-1 == (int)m_data) {
            fprintf(stderr, "ERROR %d attaching to shared memory key %d: %s\n", errno, m_key, strerror(errno));
            m_data = 0;
            return;
        }

        // Auto delete when all processes detach
        ::shmctl(m_key, IPC_RMID, NULL);

        Header* header = (Header*) m_data;
        header->marker1 = s_marker;
        header->marker2 = s_marker;

        pthread_mutexattr_t attr;
        pthread_mutexattr_init (&attr);
        pthread_mutexattr_setpshared (&attr, PTHREAD_PROCESS_SHARED);

        pthread_mutex_t* mutex = (pthread_mutex_t*) &header->mutex;
        pthread_mutex_init (mutex, &attr);
        pthread_mutexattr_destroy(&attr);
    }
    else {

        m_data = ::shmat(m_key, NULL, 0);
        if (m_data == (void*) -1) {
            fprintf(stderr, "Failed to attach to shmid: %d, ERROR: %d, %s", m_key, errno, strerror(errno));
            m_data = 0;
            return;
        }

        if (!isValid()) {
            fprintf(stderr, "Shared buffer is corrupted\n");
            ::shmdt(m_data);
            m_data = 0;
            return;
	}
    }
}