static ssize_t monitor_write( struct file *filp, const char *buf,
size_t count, loff_t *f_pos) {
ssize_t rc;
m_lock(&mutex);
if (count>MAX_SIZE) {
count = MAX_SIZE;
}
printk("<1>write %d bytes at %d (%p)\n", (int)count, curr_pos, filp);
/* Transfering data from user space */
if (copy_from_user(monitor_buffer, buf, count)!=0) {
rc= -EFAULT;
goto epilog;
}
curr_size = count;
curr_pos += count;
*f_pos= curr_pos;
c_broadcast(&wait_queue);
rc= count;
epilog:
m_unlock(&mutex);
return rc;
}
ssize_t syncread_write( struct file *filp, const char *buf,
size_t count, loff_t *f_pos) {
int rc;
loff_t last;
m_lock(&mutex);
last= *f_pos + count;
if (last>MAX_SIZE) {
count -= last-MAX_SIZE;
}
printk("<1>write %d bytes at %d\n", (int)count, (int)*f_pos);
/* Transfiriendo datos desde el espacio del usuario */
if (copy_from_user(syncread_buffer+*f_pos, buf, count)!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
*f_pos += count;
curr_size= *f_pos;
rc= count;
c_broadcast(&cond);
epilog:
m_unlock(&mutex);
return rc;
}
int syncread_release(struct inode *inode, struct file *filp) {
m_lock(&mutex);
if (filp->f_mode & FMODE_WRITE) {
writing= FALSE;
c_broadcast(&cond);
printk("<1>close for write successful\n");
}
else if (filp->f_mode & FMODE_READ) {
readers--;
if (readers==0)
c_broadcast(&cond);
printk("<1>close for read (readers remaining=%d)\n", readers);
}
m_unlock(&mutex);
return 0;
}
int syncread_open(struct inode *inode, struct file *filp) {
int rc= 0;
m_lock(&mutex);
if (filp->f_mode & FMODE_WRITE) {
int rc;
printk("<1>open request for write\n");
/* Se debe esperar hasta que no hayan otros lectores o escritores */
pend_open_write++;
while (writing || readers>0) {
if (c_wait(&cond, &mutex)) {
pend_open_write--;
c_broadcast(&cond);
rc= -EINTR;
goto epilog;
}
}
writing= TRUE;
pend_open_write--;
curr_size= 0;
c_broadcast(&cond);
printk("<1>open for write successful\n");
}
else if (filp->f_mode & FMODE_READ) {
/* Para evitar la hambruna de los escritores, si nadie esta escribiendo
* pero hay escritores pendientes (esperan porque readers>0), los
* nuevos lectores deben esperar hasta que todos los lectores cierren
* el dispositivo e ingrese un nuevo escritor.
*/
while (!writing && pend_open_write>0) {
if (c_wait(&cond, &mutex)) {
rc= -EINTR;
goto epilog;
}
}
readers++;
printk("<1>open for read\n");
}
epilog:
m_unlock(&mutex);
return rc;
}
ssize_t bano_write( struct file *filp, const char *buf, size_t count, loff_t *f_pos) {
int rc;
int copyFromUserResult;
int dv;
loff_t last;
m_lock(&mutex);
dv = iminor(filp->f_inode);
if (dv == 0) {
last = damas_pos + count;
if (last > MAX_SIZE) {
count -= last-MAX_SIZE;
}
printk("<1>write %d bytes at (damas) %d\n", (int)count, (int)*f_pos);
copyFromUserResult = copy_from_user(buffer_d+damas_pos, buf, count);
/* Transfiriendo datos desde el espacio del usuario */
if (copyFromUserResult!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
damas_pos += count;
curr_size_d= damas_pos;
} else {
last = varones_pos + count;
if (last > MAX_SIZE) {
count -= last-MAX_SIZE;
}
printk("<1>write %d bytes at (varones) %d\n", (int)count, (int)*f_pos);
copyFromUserResult = copy_from_user(buffer_v+varones_pos, buf, count);
/* Transfiriendo datos desde el espacio del usuario */
if (copyFromUserResult!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
varones_pos += count;
curr_size_v = varones_pos;
}
rc= count;
c_broadcast(&cond);
epilog:
m_unlock(&mutex);
return rc;
}
int bano_release(struct inode *inode, struct file *filp) {
m_lock(&mutex);
if (filp->f_mode & FMODE_WRITE) {
int dv = iminor(filp->f_inode);
if (dv == 0) {
// Esta saliendo una dama
printk("<1>close for write successful dama\n");
damas--;
} else {
// Esta saliendo un varon
printk("<1>close for write successful varon\n");
varones--;
}
c_broadcast(&cond);
}
else if (filp->f_mode & FMODE_READ) {
printk("<1>close for read \n");
}
m_unlock(&mutex);
return 0;
}
int bano_open(struct inode *inode, struct file *filp) {
int rc= 0;
m_lock(&mutex);
if (filp->f_mode & FMODE_WRITE) {
int dv = iminor(filp->f_inode);
int rc;
if (dv == 0) {
// Esta entrando una dama
printk("<1>open request for write dama\n");
while (varones > 0) {
printk("no cacho 1");
if (c_wait(&cond, &mutex)) {
c_broadcast(&cond);
rc= -EINTR;
if (damas == 0) {
damas_pos = 0;
}
damas++;
goto epilog;
}
}
if (damas == 0) {
damas_pos = 0;
}
damas++;
curr_size_d = 0;
printk("no cacho 2");
c_broadcast(&cond);
printk("<1>open for write successful damas: %d \n", damas);
} else {
// Esta entrando un varon
printk("<1>open request for write varon\n");
while (damas > 0) {
if (c_wait(&cond, &mutex)) {
c_broadcast(&cond);
rc= -EINTR;
if (varones == 0) {
varones_pos = 0;
}
varones++;
goto epilog;
}
}
if (varones == 0) {
varones_pos = 0;
}
varones++;
curr_size_v= 0;
c_broadcast(&cond);
printk("<1>open for write successful varones: %d\n", varones);
}
}
else if (filp->f_mode & FMODE_READ) {
printk("<1>open for read\n");
}
epilog:
m_unlock(&mutex);
return rc;
}
