Разница между взаимным исключением и заблокированным-IO в программировании ядра?

Question

Я не могу понять разницу между двумя кодами. Может ли тело объяснить разницу между следующими кодами & также объясняют между семафора Всё различие и мьютекс с примером ....

Взаимное исключение:

DEFINE_SEMAPHORE(mysem); 
static ssize_t dev_read(struct file *file,char *buf, size_t lbuf, loff_t *ppos) 
{ 
    int maxbytes, bytes_to_do, nbytes; 
    maxbytes = SIZE - *ppos; 
    if(maxbytes < lbuf) bytes_to_do = maxbytes; 
    else bytes_to_do = lbuf; 
    if(bytes_to_do == 0){ 
     printk("reached end of device\n"); 
     return -ENOSPC; 
    } 
    if(down_interruptible(&mysem)) 
     return -ERESTARTSYS; 
    nbytes = bytes_to_do - copy_to_user(buf,dev_buf+*ppos,bytes_to_do); 
    up(&mysem); 
    *ppos += nbytes; 
    return nbytes; 
} 
static ssize_t dev_write(struct file *file,const char *buf, size_t lbuf, 
          loff_t *ppos) 
{ 
    int maxbytes, bytes_to_do, nbytes; 
    maxbytes = SIZE - *ppos; 
    if(maxbytes < lbuf) bytes_to_do = maxbytes; 
    else bytes_to_do = lbuf; 
    if(bytes_to_do == 0){ 
     printk("reached end of device\n"); 
     return -ENOSPC; 
    } 
    if(down_interruptible(&mysem)) 
     return -ERESTARTSYS; 
    nbytes = bytes_to_do - copy_from_user(dev_buf+*ppos,buf,bytes_to_do); 
    ssleep(10); 
    up(&mysem); 
    *ppos += nbytes; 
    return nbytes; 
} 

Blocked IO

init_MUTEX_LOCKED(&mysem); 
static ssize_t dev_read(struct file *file,char *buf, size_t lbuf, loff_t *ppos) 
{ 
    int maxbytes, bytes_to_do, nbytes; 
    maxbytes = SIZE - *ppos; 
    if(maxbytes < lbuf) bytes_to_do = maxbytes; 
    else bytes_to_do = lbuf; 
    if(bytes_to_do == 0){ 
     printk("reached end of device\n"); 
     return -ENOSPC; 
    } 
    if(down_interruptible(&mysem)) 
     return -ERESTARTSYS; 
    nbytes = bytes_to_do - copy_to_user(buf,dev_buf+*ppos,bytes_to_do); 
    *ppos += nbytes; 
    return nbytes; 
} 
static ssize_t dev_write(struct file *file,const char *buf, size_t lbuf, 
          loff_t *ppos) 
{ 
    int maxbytes, bytes_to_do, nbytes; 
    maxbytes = SIZE - *ppos; 
    if(maxbytes < lbuf) bytes_to_do = maxbytes; 
    else bytes_to_do = lbuf; 
    if(bytes_to_do == 0){ 
     printk("reached end of device\n"); 
     return -ENOSPC; 
    } 
    nbytes = bytes_to_do - copy_from_user(dev_buf+*ppos,buf,bytes_to_do); 
    ssleep(10); 
    up(&mysem); 
    *ppos += nbytes; 
    return nbytes; 
} 

Answer 1

Mutex - это не что иное, как двоичный семафор. Это означает, что мьютекс может иметь только два состояния: заблокирован и разблокирован. Но семафор может иметь более двух счетчиков. Таким образом, количество процессов, которые могут получить блокировку семафора, равно числу, с которым инициализируется семафор.

В вашем примере, в первом фрагменте кода, независимо от того, читается или записывается, в зависимости от того, какой из них происходит, блокировка сама освобождает блокировку и после завершения ее соответствующего чтения или записи. Оба не могут работать одновременно из-за мьютекса.

Во втором фрагменте кода код демонстрирует концепцию блокирующего ввода-вывода, разработанную для решения проблемы, описанной в книге «Драйверы устройств Linux» (LDD): «что делать, когда данных еще нет, но мы 'не в конце файла. Ответ по умолчанию - это переход в режим ожидания ожидания данных ". Как вы можете видеть в коде, блокировка объявляется как Mutex, а также в заблокированном состоянии. Итак, если какое-либо чтение приходит, когда нет данных, он не может получить блокировку, поскольку мьютекс уже находится в заблокированном состоянии, поэтому он перейдет в режим сна (короткое чтение блокируется). Всякий раз, когда приходит какая-либо запись, она сначала записывает на устройство, а затем отпускает мьютекс. Таким образом, теперь заблокированное чтение может получить этот замок и может завершить его процесс чтения. Здесь также невозможно работать одновременно, но механизм блокировки и освобождения блокировки синхронизируется таким образом, что чтение не может прогрессировать, пока запись не пишет ничего на устройство.