Perbedaan antara saling pengecualian dan IO yang diblokir dalam pemrograman kernel?

Saya tidak dapat memahami perbedaan antara dua kode berikut. Adakah yang bisa menjelaskan perbedaan antara kode-kode berikut & juga menjelaskan perbedaan antara semaphore dan mutex dengan contoh....

Saling mengecualikan:

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;
}

IO yang diblokir

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;
}

operating-system linux-kernel semaphore mutex
person Sandy    schedule 04.10.2013    source sumber
comment
Perbedaannya adalah kode kedua sangat bermasalah dan tidak dapat dikompilasi. Dari mana asalnya?   -  person CL.    schedule 04.10.2013
comment
gunakan static struct semaphore mysem = __SEMAPHORE_INITIALIZER(mysem,0) sebagai ganti init_MUTEX_LOCKED(&mysem)   -  person Sandy    schedule 04.10.2013

Jawaban (1)


arrow_upward
2
arrow_downward

Mutex hanyalah semafor biner. Artinya mutex hanya dapat mempunyai dua keadaan : terkunci dan tidak terkunci. Tapi semaphore bisa memiliki lebih dari dua hitungan. Jadi jumlah proses yang dapat memperoleh kunci semaphore sama dengan jumlah yang menginisialisasi semaphore.

Dalam contoh Anda, dalam cuplikan kode pertama, apakah itu baca atau tulis, siapa pun yang memperoleh kunci itu sendiri akan melepaskan kuncinya juga setelah selesai membaca atau menulisnya. Keduanya tidak bisa bekerja secara bersamaan karena mutex.

Sedangkan pada cuplikan kode kedua, kode tersebut memperlihatkan konsep pemblokiran I/O yang dirancang untuk memecahkan masalah yang dijelaskan dalam buku Linux Device Drivers (LDD): "apa yang harus dilakukan ketika belum ada data yang dibaca, tetapi kita belum siap akhir file. Jawaban defaultnya adalah tidur menunggu data". Seperti yang Anda lihat di kode, kunci dideklarasikan sebagai Mutex dan juga dalam keadaan terkunci. Jadi, jika ada pembacaan yang terjadi ketika tidak ada data, maka tidak dapat memperoleh kunci karena mutex sudah dalam keadaan terkunci, sehingga akan masuk ke mode tidur (Singkatnya, pembacaan diblokir). Setiap kali ada tulisan yang datang, pertama-tama ia menulis ke perangkat dan kemudian melepaskan mutex. Jadi, sekarang pembacaan yang diblokir dapat memperoleh kunci itu dan dapat menyelesaikan proses pembacaannya. Di sini juga, keduanya tidak dapat bekerja secara bersamaan, namun mekanisme perolehan dan pelepasan kunci disinkronkan sedemikian rupa sehingga pembacaan tidak dapat dilanjutkan hingga penulisan tidak menulis apa pun ke perangkat.

person pratik    schedule 04.10.2013