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; }
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 }
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); }
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"; }
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; }
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; }
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; }
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; }
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; } }
/* 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 ); }
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; }
/* * 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; }
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; }
/* * 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; }
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; }
//!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"); }
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; }
/* * 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); }
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); }
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; }
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; }
/* }}} */ 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; }
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; }
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; }
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; }
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"); }
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); }
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); }
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); } }
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; } } }