static ssize_t monitor_read(struct file *filp, char *buf,
size_t count, loff_t *f_pos) {
ssize_t rc= 0;
m_lock(&mutex);
while (curr_pos <= *f_pos) {
if (c_wait(&wait_queue, &mutex)) {
printk("<1>read interrupted while waiting for data\n");
rc= -EINTR;
goto epilog;
}
}
if (count > curr_size) {
count= curr_size;
}
printk("<1>read %d bytes at %d (%p)\n", (int)count, (int)*f_pos, filp);
/* Transfering data to user space */
if (copy_to_user(buf, monitor_buffer, count)!=0) {
rc= -EFAULT;
goto epilog;
}
*f_pos= curr_pos - (curr_size-count);
rc= count;
epilog:
m_unlock(&mutex);
return rc;
}
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 syncread_read(struct file *filp, char *buf,
size_t count, loff_t *f_pos) {
ssize_t rc;
m_lock(&mutex);
while (curr_size <= *f_pos && writing) {
/* si el lector esta en el final del archivo pero hay un proceso
* escribiendo todavia en el archivo, el lector espera.
*/
if (c_wait(&cond, &mutex)) {
printk("<1>read interrupted\n");
rc= -EINTR;
goto epilog;
}
}
if (count > curr_size-*f_pos) {
count= curr_size-*f_pos;
}
printk("<1>read %d bytes at %d\n", (int)count, (int)*f_pos);
/* Transfiriendo datos hacia el espacio del usuario */
if (copy_to_user(buf, syncread_buffer+*f_pos, count)!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
*f_pos+= count;
rc= count;
epilog:
m_unlock(&mutex);
return rc;
}
ssize_t bano_read(struct file *filp, char *buf, size_t count, loff_t *f_pos) {
ssize_t rc;
int dv;
m_lock(&mutex);
dv = iminor(filp->f_inode);
if (dv == 0) {
// Dama
while (curr_size_d <= *f_pos && damas > 0) {
printk("What? \n");
/* si el lector esta en el final del archivo pero hay un proceso
* escribiendo todavia en el archivo, el lector espera.
*/
if (c_wait(&cond, &mutex)) {
printk("<1>read interrupted\n");
rc= -EINTR;
goto epilog;
}
}
printk("Curresize: %d\n", (int) curr_size_d);
printk("Damas: %d\n", damas);
if (count > curr_size_d-*f_pos) {
count= curr_size_d-*f_pos;
}
printk("<1>read %d bytes at (damas) %d\n", (int)count, (int)*f_pos);
/* Transfiriendo datos hacia el espacio del usuario */
if (copy_to_user(buf, buffer_d+*f_pos, count)!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
} else {
// Varon
while (curr_size_v <= *f_pos && varones > 0) {
printk("What? \n");
/* si el lector esta en el final del archivo pero hay un proceso
* escribiendo todavia en el archivo, el lector espera.
*/
if (c_wait(&cond, &mutex)) {
printk("<1>read interrupted\n");
rc= -EINTR;
goto epilog;
}
}
printk("Curresize: %d\n", (int) curr_size_v);
printk("Varones: %d\n", varones);
if (count > curr_size_v-*f_pos) {
count= curr_size_v-*f_pos;
}
printk("<1>read %d bytes at (varones) %d\n", (int)count, (int)*f_pos);
/* Transfiriendo datos hacia el espacio del usuario */
if (copy_to_user(buf, buffer_v+*f_pos, count)!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
}
*f_pos+= count;
rc= count;
epilog:
m_unlock(&mutex);
return rc;
}
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;
}
