int am_i_alone(t_player *player)
{
int i;
int j;
sem_lock(player);
i = 0;
while (i < HEIGHT)
{
j = 0;
while (j < WIDTH)
{
if ((i != player->posy
|| j != player->posx) && player->map[i][j] != 0)
{
sem_unlock(player);
return (0);
}
j++;
}
i++;
}
sem_unlock(player);
return (1);
}
void *customer(int id)
{
while(1)
{
sem_lock(mutex);/*P(mutex)*/
(*cid)++;
if((*rear+1)%10!=*front)
{
ARR[*rear]=*cid;
printf("Customer %d occupied %d seat number \n",ARR[*rear],*rear);
*rear=(*rear+1)%10;
sleep(2);
sem_unlock(mutex);//release waiting for mutex
if((*front+1)%10==*rear)
{
sem_unlock(custc);
printf("waking up barber\n");
}
}
else
{
printf("comming customer %d is leaving bcs of full\n",*cid);
sleep(2);
sem_unlock(mutex);
}
sleep(10);
}
exit(id);
}
int
_camera_setcool (int reg, int setpt, int prel, int fan, int state)
{
MicroTemperatureRegulationParams cool;
//GetVersionResults st;
if (!is_init)
return -1;
cool.regulation = reg;
cool.ccdSetpoint = setpt;
cool.preload = prel;
camera_fan (fan);
sem_lock ();
if (MicroCommand (MC_REGULATE_TEMP, cameraID, &cool, NULL))
goto err;
camera_reg = state;
sem_unlock ();
return 0;
err:
sem_unlock ();
errno = ENODEV;
return -1;
}
extern int
camera_fan (int fan_state)
{
MiscellaneousControlParams ctrl;
StatusResults sr;
if (!is_init)
return -1;
ctrl.fanEnable = fan_state;
ctrl.shutterCommand = 0;
sem_lock ();
if ((MicroCommand (MC_STATUS, cameraID, NULL, &sr)))
goto err;
ctrl.ledState = sr.ledStatus;
if (MicroCommand (MC_MISC_CONTROL, cameraID, &ctrl, NULL))
goto err;
sem_unlock ();
return 0;
err:
sem_unlock ();
errno = ENODEV;
return -1;
}
uint32_t get_ip(const uint16_t port)
{
int next = ip_map_id;
uint32_t ip;
map_t *m;
if(sem_lock() == -1)
return 0;
while(next >= 0)
{
m = shmat(next, NULL, 0);
if(m->port > port)
{
shmdt(m);
sem_unlock();
return 0;
}
if(m->port == port)
{
if (verbose) fprintf(stderr, "got %u->%u from ip map\n", port, m->ip);
ip = m->ip;
shmdt(m);
sem_unlock();
return ip;
}
next = m->next;
shmdt(m);
}
sem_unlock();
return 0;
}
/* Should be improved to support st237 filter wheel */
extern int
camera_set_filter (int filter) /* set camera filter */
{
PulseOutParams pop;
if (!is_init)
return -1;
if (filter < 1 || filter > 5)
{
errno = EINVAL;
return -1;
}
pop.pulsePeriod = 18270;
pop.pulseWidth = 500 + 300 * (filter - 1);
pop.numberPulses = 60;
sem_lock ();
if (MicroCommand (MC_PULSE, cameraID, &pop, NULL))
goto err;
camera_filter = filter;
sem_unlock ();
return 0;
err:
sem_unlock ();
errno = ENODEV;
return -1;
}
extern int
camera_cool_hold () /* hold on that temperature */
{
QueryTemperatureStatusResults qtsr;
float ot; // optimal temperature
if (!is_init)
return -1;
if (camera_reg == CAMERA_COOL_HOLD)
return 0; // already cooled
sem_lock ();
if (MicroCommand (MC_TEMP_STATUS, cameraID, NULL, &qtsr))
goto err;
sem_unlock ();
ot = ccd_ad2c (qtsr.ccdThermistor);
ot = ((int) (ot + 5) / 5) * 5;
camera_fan (1);
return camera_cool_setpoint (ot);
err:
sem_unlock ();
errno = ENODEV;
return -1;
}
extern int
camera_expose (int chip, float *exposure, int light)
{
CAMERA *C;
int imstate;
if (!is_init)
return -1;
sem_lock ();
#ifdef INIT_SHUTTER
init_shutter ();
#else
if (!light) // init shutter only for dark images
init_shutter ();
#endif
if (OpenCCD (chip, &C))
goto err;
if (CCDExpose (C, (int) 100 * (*exposure) + 0.5, light))
goto err;
sem_unlock ();
// wait for completing exp
do
{
sem_lock ();
imstate = CCDImagingState (C);
sem_unlock ();
pthread_testcancel ();
TimerDelay (100000);
}
while (imstate);
sem_lock ();
readout_line[chip] = 0;
if (CCDReadout
(img[chip], C, 0, 0, C->vertImage, C->horzImage,
ch_info[chip].binning_vertical))
goto err;
CloseCCD (C);
sem_unlock ();
return 0;
err:
CloseCCD (C);
sem_unlock ();
errno = ENODEV;
return -1;
}
void
sem_wait(sem_t *sp)
{
/*Possible bug point*/
while(sem_try_lock(sp) != 0);
((sem*)sp)->value--;
if ( ((sem*)sp)->value < 0 ) {
sem_unlock(sp);
sem_yield(sp);
}
sem_unlock(sp);
}
static int semctl_down(int semid, int semnum, int cmd, int version, union semun arg)
{
struct sem_array *sma;
int err;
struct sem_setbuf setbuf;
struct kern_ipc_perm *ipcp;
if(cmd == IPC_SET) {
if(copy_semid_from_user (&setbuf, arg.buf, version))
return -EFAULT;
}
sma = sem_lock(semid);
if(sma==NULL)
return -EINVAL;
if (sem_checkid(sma,semid)) {
err=-EIDRM;
goto out_unlock;
}
ipcp = &sma->sem_perm;
if (current->euid != ipcp->cuid &&
current->euid != ipcp->uid && !capable(CAP_SYS_ADMIN)) {
err=-EPERM;
goto out_unlock;
}
switch(cmd){
case IPC_RMID:
freeary(semid);
err = 0;
break;
case IPC_SET:
ipcp->uid = setbuf.uid;
ipcp->gid = setbuf.gid;
ipcp->mode = (ipcp->mode & ~S_IRWXUGO)
| (setbuf.mode & S_IRWXUGO);
sma->sem_ctime = CURRENT_TIME;
sem_unlock(semid);
err = 0;
break;
default:
sem_unlock(semid);
err = -EINVAL;
break;
}
return err;
out_unlock:
sem_unlock(semid);
return err;
}
extern int
camera_info (struct camera_info *info)
{
//PAR_ERROR ret = CE_NO_ERROR;
StatusResults gvr;
QueryTemperatureStatusResults qtsr;
if (!is_init)
return -1;
sem_lock ();
if (MicroCommand (MC_STATUS, cameraID, NULL, &gvr))
goto err;
if (MicroCommand (MC_TEMP_STATUS, cameraID, NULL, &qtsr))
goto err;
// get camera info
get_eeprom ();
sem_unlock ();
strcpy (info->type, Cams[eePtr.model].fullName);
strcpy (info->serial_number, eePtr.serialNumber);
if (Cams[eePtr.model].hasTrack)
chips = 2;
else
chips = 1;
info->chips = chips;
info->chip_info = ch_info;
// memcpy(info->chip_info,&(ch_info[0]),sizeof(struct chip_info));
info->temperature_regulation = camera_reg;
info->temperature_setpoint = ccd_ad2c (qtsr.ccdSetpoint);
info->cooling_power = (qtsr.power == 255) ? 1000 : qtsr.power * 3.906;
info->air_temperature = ambient_ad2c (qtsr.ambientThermistor);
info->ccd_temperature = ccd_ad2c (qtsr.ccdThermistor);
info->fan = gvr.fanEnabled;
info->filter = camera_filter;
info->can_df = 1;
return 0;
err:
sem_unlock ();
errno = ENODEV;
return -1;
}
/* Free a semaphore set. */
static void freeary (int id)
{
struct sem_array *sma;
struct sem_undo *un;
struct sem_queue *q;
int size;
sma = sem_rmid(id);
/* Invalidate the existing undo structures for this semaphore set.
* (They will be freed without any further action in sem_exit()
* or during the next semop.)
*/
for (un = sma->undo; un; un = un->id_next)
un->semid = -1;
/* Wake up all pending processes and let them fail with EIDRM. */
for (q = sma->sem_pending; q; q = q->next) {
q->status = -EIDRM;
q->prev = NULL;
wake_up_process(q->sleeper); /* doesn't sleep */
}
sem_unlock(id);
used_sems -= sma->sem_nsems;
size = sizeof (*sma) + sma->sem_nsems * sizeof (struct sem);
ipc_free(sma, size);
}
asmlinkage long sys_semget (key_t key, int nsems, int semflg)
{
int id, err = -EINVAL;
struct sem_array *sma;
if (nsems < 0 || nsems > sc_semmsl)
return -EINVAL;
down(&sem_ids.sem);
if (key == IPC_PRIVATE) {
err = newary(key, nsems, semflg);
} else if ((id = ipc_findkey(&sem_ids, key)) == -1) { /* key not used */
if (!(semflg & IPC_CREAT))
err = -ENOENT;
else
err = newary(key, nsems, semflg);
} else if (semflg & IPC_CREAT && semflg & IPC_EXCL) {
err = -EEXIST;
} else {
sma = sem_lock(id);
if(sma==NULL)
BUG();
if (nsems > sma->sem_nsems)
err = -EINVAL;
else if (ipcperms(&sma->sem_perm, semflg))
err = -EACCES;
else
err = sem_buildid(id, sma->sem_perm.seq);
sem_unlock(id);
}
up(&sem_ids.sem);
return err;
}
void ClearBooks(bookkeeper_t *bookkeeper, bookkeeper_t *tmp_books) {
bookkeeper_list_t *bookkeeper_list_entry;
if ( !bookkeeper )
return;
bookkeeper_list_entry = Get_bookkeeper_list_entry(bookkeeper);
if ( !bookkeeper_list_entry ) {
// this should never happen
LogError("Software error in %s line %d: %s", __FILE__, __LINE__, "Entry not found in list");
return;
}
sem_lock(bookkeeper_list_entry->sem_id);
// backup copy
if ( tmp_books != NULL ) {
memcpy((void *)tmp_books, (void *)bookkeeper, sizeof(bookkeeper_t));
}
bookkeeper->first = 0;
bookkeeper->last = 0;
bookkeeper->numfiles = 0;
bookkeeper->filesize = 0;
bookkeeper->sequence++;
sem_unlock(bookkeeper_list_entry->sem_id);
} // End of ClearBooks
/* returns without sem_lock on error! */
static int alloc_undo(struct sem_array *sma, struct sem_undo** unp, int semid, int alter)
{
int size, nsems, error;
struct sem_undo *un;
nsems = sma->sem_nsems;
size = sizeof(struct sem_undo) + sizeof(short)*nsems;
sem_unlock(semid);
un = (struct sem_undo *) kmalloc(size, GFP_KERNEL);
if (!un)
return -ENOMEM;
memset(un, 0, size);
error = sem_revalidate(semid, sma, nsems, alter ? S_IWUGO : S_IRUGO);
if(error) {
kfree(un);
return error;
}
un->semadj = (short *) &un[1];
un->semid = semid;
un->proc_next = current->semundo;
current->semundo = un;
un->id_next = sma->undo;
sma->undo = un;
*unp = un;
return 0;
}
static int newary(struct ipc_namespace *ns, struct ipc_params *params)
{
int id;
int retval;
struct sem_array *sma;
int size;
key_t key = params->key;
int nsems = params->u.nsems;
int semflg = params->flg;
int i;
if (!nsems)
return -EINVAL;
if (ns->used_sems + nsems > ns->sc_semmns)
return -ENOSPC;
size = sizeof (*sma) + nsems * sizeof (struct sem);
sma = ipc_rcu_alloc(size);
if (!sma) {
return -ENOMEM;
}
memset (sma, 0, size);
sma->sem_perm.mode = (semflg & S_IRWXUGO);
sma->sem_perm.key = key;
sma->sem_perm.security = NULL;
retval = security_sem_alloc(sma);
if (retval) {
ipc_rcu_putref(sma);
return retval;
}
id = ipc_addid(&sem_ids(ns), &sma->sem_perm, ns->sc_semmni);
if (id < 0) {
security_sem_free(sma);
ipc_rcu_putref(sma);
return id;
}
ns->used_sems += nsems;
sma->sem_base = (struct sem *) &sma[1];
for (i = 0; i < nsems; i++) {
INIT_LIST_HEAD(&sma->sem_base[i].sem_pending);
spin_lock_init(&sma->sem_base[i].lock);
}
sma->complex_count = 0;
INIT_LIST_HEAD(&sma->sem_pending);
INIT_LIST_HEAD(&sma->list_id);
sma->sem_nsems = nsems;
sma->sem_ctime = get_seconds();
sem_unlock(sma, -1);
rcu_read_unlock();
return sma->sem_perm.id;
}
void stm32_flash_lock(void)
{
sem_lock();
flash_lock(STM32_FLASH_BANK0_BASE);
#if defined(STM32_FLASH_DUAL_BANK)
flash_lock(STM32_FLASH_BANK1_BASE);
#endif
sem_unlock();
}
/* doesn't acquire the sem_lock on error! */
static int sem_revalidate(int semid, struct sem_array* sma, int nsems, short flg)
{
struct sem_array* smanew;
smanew = sem_lock(semid);
if(smanew==NULL)
return -EIDRM;
if(smanew != sma || sem_checkid(sma,semid) || sma->sem_nsems != nsems) {
sem_unlock(semid);
return -EIDRM;
}
if (ipcperms(&sma->sem_perm, flg)) {
sem_unlock(semid);
return -EACCES;
}
return 0;
}
extern int
camera_end_expose (int chip)
{
EndExposureParams eep;
eep.ccd = chip;
sem_lock ();
if (!is_init)
return -1;
if (MicroCommand (MC_END_EXPOSURE, cameraID, &eep, NULL))
{
sem_unlock ();
errno = ENODEV;
return -1;
}
sem_unlock ();
return 0;
};
void add_ip(uint16_t port, uint32_t ip)
{
int next = ip_map_id;
int prev = -1;
int n;
map_t *m;
if(ip == 0xFFFFFFFF || sem_lock() == -1)
return;
while(next >= 0)
{
m = shmat(next, NULL, 0);
if(m->port > port)
{
shmdt(m);
break;
}
if(m->port == port)
{
m->ip = ip;
if (verbose) fprintf(stderr, "updated %u->%u to ip map\n", port, ip);
shmdt(m);
sem_unlock();
return;
}
prev = next;
next = m->next;
shmdt(m);
}
n = new_shared_map();
m = shmat(n, NULL, 0);
m->port = port;
m->ip = ip;
m->next = next;
shmdt(m);
m = shmat(prev, NULL, 0);
m->next = n;
shmdt(m);
sem_unlock();
if (verbose) fprintf(stderr, "added %u->%u to ip map\n", port, ip);
}
void remove_ip(uint16_t port)
{
int next = ip_map_id;
int delid;
int prev = -1;
map_t *m;
if(sem_lock() == -1)
return;
while(next >= 0)
{
m = shmat(next, NULL, 0);
if(m->port > port)
{
shmdt(m);
sem_unlock();
return;
}
if(m->port == port)
{
if(prev) {
delid = next;
next = m->next;
shmdt(m);
shmctl(delid, IPC_RMID, NULL);
m = shmat(prev, NULL, 0);
m->next = next;
}
shmdt(m);
sem_unlock();
if (verbose) fprintf(stderr, "removed %u from ip map\n", port);
return;
}
prev = next;
next = m->next;
shmdt(m);
}
sem_unlock();
}
void ReleaseBookkeeper(bookkeeper_t *bookkeeper, int destroy) {
bookkeeper_list_t *bookkeeper_list_entry;
struct shmid_ds buf;
if ( !bookkeeper )
return;
bookkeeper_list_entry = Get_bookkeeper_list_entry(bookkeeper);
if ( !bookkeeper_list_entry ) {
// this should never happen
LogError("Software error in %s line %d: %s", __FILE__, __LINE__, "Entry not found in list");
return;
}
// detach from my process addr space memory
if ( shmdt((void *)bookkeeper) == -1 ) {
// ups ..
LogError("shmdt() error in %s line %d: %s", __FILE__, __LINE__, strerror(errno) );
}
bookkeeper = NULL;
if ( destroy == 0 ) {
// Entry no longer valid
bookkeeper_list_entry->bookkeeper = NULL;
bookkeeper_list_entry->shm_id = 0;
bookkeeper_list_entry->sem_id = 0;
return;
}
// prevent other proceeses to access the share memory, while we are removing it
// try to clean up.
sem_lock(bookkeeper_list_entry->sem_id);
if ( shmctl(bookkeeper_list_entry->shm_id, IPC_RMID, &buf) ) {
// ups ..
LogError("shmctl() error in %s line %d: %s", __FILE__, __LINE__, strerror(errno) );
}
sem_unlock(bookkeeper_list_entry->sem_id);
if ( semctl( bookkeeper_list_entry->sem_id, 0, IPC_RMID ) == -1 ) {
// ups ..
LogError("semctl() error in %s line %d: %s", __FILE__, __LINE__, strerror(errno) );
}
// Entry no longer valid
bookkeeper_list_entry->bookkeeper = NULL;
bookkeeper_list_entry->shm_id = 0;
bookkeeper_list_entry->sem_id = 0;
} // End of ReleaseBookkeeper
extern int
camera_readout_line (int chip_id, short start, short length, void *data)
{
if (!is_init)
return -1;
if (readout_line[chip_id & 1] >= max_line[chip_id & 1])
return (-1);
// has to be locked !
sem_lock ();
memcpy (data, lin[chip_id & 1][readout_line[chip_id & 1]++] + start,
length * sizeof (unsigned short));
sem_unlock ();
return 0;
};
void
sem_signal(sem_t *sp)
{
while(sem_try_lock(sp) != 0);
int yield = 0;
((sem*)sp)->value++;
if ( ((sem*)sp)->value <= 0 ) {
assert(!is_list_empty(&((sem*)sp)->waiters));
sem_unblock(sp);
yield = 1;
}
sem_unlock(sp);
if (yield == 1)
t_yield();
}
static int sysvipc_sem_read_proc(char *buffer, char **start, off_t offset, int length, int *eof, void *data)
{
off_t pos = 0;
off_t begin = 0;
int i, len = 0;
len += sprintf(buffer, " key semid perms nsems uid gid cuid cgid otime ctime\n");
down(&sem_ids.sem);
for(i = 0; i <= sem_ids.max_id; i++) {
struct sem_array *sma;
sma = sem_lock(i);
if(sma) {
len += sprintf(buffer + len, "%10d %10d %4o %10lu %5u %5u %5u %5u %10lu %10lu\n",
sma->sem_perm.key,
sem_buildid(i,sma->sem_perm.seq),
sma->sem_perm.mode,
sma->sem_nsems,
sma->sem_perm.uid,
sma->sem_perm.gid,
sma->sem_perm.cuid,
sma->sem_perm.cgid,
sma->sem_otime,
sma->sem_ctime);
sem_unlock(i);
pos += len;
if(pos < offset) {
len = 0;
begin = pos;
}
if(pos > offset + length)
goto done;
}
}
*eof = 1;
done:
up(&sem_ids.sem);
*start = buffer + (offset - begin);
len -= (offset - begin);
if(len > length)
len = length;
if(len < 0)
len = 0;
return len;
}
void ip_map_close()
{
int next = ip_map_id;
int delid;
map_t *m;
sem_lock();
while(next >= 0)
{
m = shmat(next, NULL, 0);
delid = next;
next = m->next;
shmdt(m);
shmctl(delid, IPC_RMID, NULL);
}
sem_unlock();
semctl(semid, 0, IPC_RMID);
if (verbose) fprintf(stderr, "Port<->IP map closed.\n");
}
int UnlookBooks(bookkeeper_t *bookkeeper) {
bookkeeper_list_t *bookkeeper_list_entry;
if ( !bookkeeper )
return 0;
bookkeeper_list_entry = Get_bookkeeper_list_entry(bookkeeper);
if ( !bookkeeper_list_entry ) {
// this should never happen
LogError("Software error in %s line %d: %s", __FILE__, __LINE__, "Entry not found in list");
return 1;
}
sem_unlock(bookkeeper_list_entry->sem_id);
return 0;
} // End of UnlookBooks
void PrintBooks(bookkeeper_t *bookkeeper) {
bookkeeper_list_t *bookkeeper_list_entry;
struct tm *ts;
time_t t;
char string[32];
if ( !bookkeeper ) {
printf("No bookkeeper record available!\n");
return;
}
bookkeeper_list_entry = Get_bookkeeper_list_entry(bookkeeper);
if ( !bookkeeper_list_entry ) {
// this should never happen
LogError("Software error in %s line %d: %s", __FILE__, __LINE__, "Entry not found in list");
return;
}
sem_lock(bookkeeper_list_entry->sem_id);
printf("Collector process: %lu\n", (unsigned long)bookkeeper->nfcapd_pid);
if ( bookkeeper->launcher_pid )
printf("Launcher process: %lu\n", (unsigned long)bookkeeper->launcher_pid);
else
printf("Launcher process: <none>\n");
printf("Record sequence : %llu\n", (unsigned long long)bookkeeper->sequence);
t = bookkeeper->first;
ts = localtime(&t);
strftime(string, 31, "%Y-%m-%d %H:%M:%S", ts);
string[31] = '\0';
printf("First : %s\n", bookkeeper->first ? string : "<not set>");
t = bookkeeper->last;
ts = localtime(&t);
strftime(string, 31, "%Y-%m-%d %H:%M:%S", ts);
string[31] = '\0';
printf("Last : %s\n", bookkeeper->last ? string : "<not set>");
printf("Number of files : %llu\n", (unsigned long long)bookkeeper->numfiles);
printf("Total file size : %llu\n", (unsigned long long)bookkeeper->filesize);
printf("Max file size : %llu\n", (unsigned long long)bookkeeper->max_filesize);
printf("Max life time : %llu\n", (unsigned long long)bookkeeper->max_lifetime);
sem_unlock(bookkeeper_list_entry->sem_id);
} // End of PrintBooks
void barber(int id)
{
while(1)
{
if(*front==*rear)
{
printf("barber is going to sleep\n");
sem_lock(custc);//sleeping
}
sem_lock(mutex);/*P(mutex)*/
printf("Barber %d is cutting hair of customer :%d.\n",id,ARR[*front]);
//sleep(2);
*front=(*front+1)%10;
sem_unlock(mutex);//releas witing for customer
//sleep(1);
}
exit(1);
}
void UpdateBooksParam(bookkeeper_t *bookkeeper, time_t lifetime, uint64_t maxsize) {
bookkeeper_list_t *bookkeeper_list_entry;
if ( !bookkeeper )
return;
bookkeeper_list_entry = Get_bookkeeper_list_entry(bookkeeper);
if ( !bookkeeper_list_entry ) {
// this should never happen
LogError("Software error in %s line %d: %s", __FILE__, __LINE__, "Entry not found in list");
return;
}
sem_lock(bookkeeper_list_entry->sem_id);
bookkeeper->max_lifetime = lifetime;
bookkeeper->max_filesize = maxsize;
bookkeeper->sequence++;
sem_unlock(bookkeeper_list_entry->sem_id);
} // End of UpdateBooksParam
