TEKNE - TECHNE: Karşılaştırmalı Ingilizce Türkçe Teknik Çeviri Örneği
Is it Possible to translate heavy technical subjec...
Karşılaştırmalı Ingilizce Türkçe Teknik Çeviri Örn...
LINUX Çekirdeğini Anlamak – Süreçler Arası İletişi...
Karşılaştırmalı Ingilizce Türkçe Teknik Çeviri Örneği
(1) Daniel P. Bovet, Marco Cesati, Understanding the Linux Kernel ‘den faydalanarak derlenmiştir.
18.1.4 Bir Borudan Okuyuş (Reading from a Pipe)
Bir borudan veri almak isteyen bir süreç, kendi dosya tanımlayıcısı olarak borunun okuyucu kanalı ile ilişkilendirilmiş tanımlayıcıyı belirleyerek bir oku() (read( )) sistem çağrısı çıkarır. Sonuç olarak, çekirdek, dosya işlem tablosunda uygun bir dosya nesnesi ile ilişkilendirilmiş bir oku (read) metodunu başlatır. Bir boru durumunda, oku (read) metodu için oku_boru_dişl (read_pipe_fops) tablosundaki bir girdi boru_oku() (pipe_read( )) fonksiyonuna işaret eder. A process wishing to get data from a pipe issues a read( ) system call, specifying as its file descriptor the descriptor associated with the pipe's read channel. The kernel ends up invoking the read method found in the file operation table associated with the proper file object. In the case of a pipe, the entry for the read method in the read_pipe_fops table points to the pipe_read( ) function.
boru_oku() (pipe_read( )) fonksiyonu çok ilişilidir, çünkü POSIX standardı borunun okuyuş işlemlerine bir çok şart koşmuştur. Tablo 18-2 boru uzunluğu p olan(okunacak boru arabölgesindeki byteların sayısı) bir borudan n byte rica eden, oku() (read( )) sistem çağrısının umulan davranışını gösterir. Okuyuş işleminin tıkanmasız(nonblocking) olabileceğine dikkat ediniz: bu durumda, var olan bütün bytelar kullanıcı adres boşluğuna kopyalanır kopyalanmaz
tamamlanır. Ayrıca, yalnız eğer boru boş ise ve borunun yazıcı kanalı ile ilişkilendirilmiş dosya nesnesini o anda hiçbir süreç kullanmıyor ise oku() (read( )) sistem çağrısı tarafından değer döndürülür.
The pipe_read( ) function is quite involved, since the POSIX standard specifies several requirements for the pipe's read operations. Table 18-2 illustrates the expected behavior of a read( ) system call that requests n bytes from a pipe having a pipe size (number of bytes in the pipe buffer yet to be read) equal to p. Notice that the read operation can be nonblocking: in this case, it completes as soon as all available bytes (even none) have been copied into the user address space. Notice also that the value is returned by the read( ) system call only if the pipe is empty and no process is currently using the file object associated with the pipe's write channel.
 Tıkanmasız işlemler genellikle aç() (open( )) sistem çağrısı içinde O_TIKANMASIZ (O_NONBLOCK) bayrağını belirleyerek talep edilir. Bu yöntem açılamadıkları için borulara geçerli değildir; bir süreç yine de karşı düşen dosya tanımlayıcı üzerinde bir dkntl() (fcntl( )) sistem çağrısı yaparak tıkanmasız bir işlem yapılmasını şart koşabilir.
 Nonblocking operations are usually requested by specifying the O_NONBLOCK flag in the open( ) system call. This method does not
work for pipes, since they cannot be opened; a process can, however, require a nonblocking operation on a pipe by issuing a fcntl( ) system
call on the corresponding file descriptor.
Tablo 18-2. Bir Borudan Byte’ların Okunuşu (Reading n Bytes from a Pipe)
Fonksiyon aşağıdaki işlemleri icra eder:
1. idüğüm(inode)'ün i_boy (i_size) alanına depolanmış olan boru boyunun 0 olup olmadığını belirler. Bu durumda, fonksiyonun geri dönüşünün zorunluluğunu veya başka bir süreç boruya yazı yazışını beklerken tıkanmasının zorunlu olup olmadığını belirler(Bakınız Tablo 18-2).
1. Determines if the pipe size, which is stored into the inode's i_size field, is 0. In this case, determines if the function must return or if the process must be blocked while waiting until another process writes some data in the pipe (see Table 18-2).
G/Ç işleminin türü (tıkanarak ya da tıkanmasız) olacağı dosya nesnesinin d_bayraklar (f_flags) alanının O_TIKANMASIZ (O_NONBLOCK) bayrağı tarafından belirlenir. Eğer gerekirse, o andaki süreci, boru_idüğüm_bilgisi (pipe_inode_info) veri yapısının bekle(wait) alanının işaret ettiği bekleyiş kuyruğuna soktukup sonra da askıya almak için kesilebilir_bekle_durumunda() (interruptible_sleep_on()) fonksiyonunu başlatır.
The type of I/O operation (blocking or nonblocking) is specified by the O_NONBLOCK flag in the f_flags field of the file object. If necessary, invokes the interruptible_sleep_on() function to suspend the current process after having inserted it in the wait queue to
which the wait field of the pipe_inode_info data structure points.
2. boru_idüğüm_bilgisi (pipe_inode_info) veri yapısının kilit (lock) alanını sınar. Eğer boş değil ise,
başka bir süreç o anda boruya erişmektedir; bu durumda, ya o anki süreci askıya alır ya da okuyuş işleminin tipine göre (tıkanmasız ya da tıkayıcılı) sistem çağrısını sona erdirir.
3. lock alanını arttırır.
4. Borunun arabölgesinden kullanıcı adres boşluğuna istenen sayıda (ya da elde var olan bytelar kadar olanı, eğer arabölge çok küçük ise) byte’ı kopyalar.
5. lock alanını azaltır.
6. Borunun bekleyiş kuyruğundaki bütün süreçleri uyandırmak için uyandır_kesilebiliri() (wake_up_interruptible( )) ‘ı başlatır.
7. Kullanıcı adres boşluğuna kopyalanmış olan byte’ların sayısını geri döndürür.
2. Checks the lock field of the pipe_inode_info data structure. If it is not null, another process is currently accessing the pipe; in this case, either suspends the current process or immediately terminates the system call, depending on the type of read operation (blocking or nonblocking).
3. Increments the lock field.
4. Copies the requested number of bytes (or the number of available bytes, if the buffer size is too small) from the pipe's buffer to the user address space.
5. Decrements the lock field.
6. Invokes wake_up_interruptible( ) to wake up all processes sleeping on the pipe's wait queue.
7. Returns the number of bytes copied into the user address space.
18.1.5 Boruya yazış (Writing into a Pipe)
Bir boruya veri koymak dileyen bir süreç, kendi dosya tanımlayıcısı olarak borunun yazıcı kanalı ile ilişkili tanımlayıcıyı kendi dosya tanımlayıcısı olarak belirleyerek, bir yaz() (write( )) system çağrısı çıkarır. Çekirdek bu isteği uygun dosya nesnesinin yaz (write) yöntemini başlatarak tatmin eder; yaz_boru_dişl() (write_pipe_fops) tablosunda karşı düşen girdi boru_yaz() (pipe_write( )) fonksiyonuna işaret eder. Tablo 18-3, POSIX standardına göre, arabölgesinde u (unused) kullanılmamış byte’ı olan bir borunun içine n byte yazmak isteyen bir yaz (write( )) sistem çağrısının davranışını canlandırmaktadır.
A process wishing to put data into a pipe issues a write( ) system call, specifying as its file descriptor the descriptor associated with the pipe's write channel. The kernel satisfies this request by invoking the write method of the proper file object; the corresponding entry in the write_pipe_fops table points to the pipe_write( ) function. Table 18-3 illustrates the behavior, specified by the POSIX standard, of a write( ) system call that requested to write n bytes into a pipe having u unused bytes in its buffer.
Standart özellikle küçük sayıda bytela ilgili yazıcı işlemlerin otomatik olarak ifa edilişini zorunlu kılar. Daha doğrusu, eğer iki ya da daha çok süreç boruya eş zamanlı yazıyorsalar, 4096’dan daha az (boru arabölgesi boyu) byte ile ilgili herhangi bir yazıcı işlem aynı boruya başka süreçler tarafından yapılan yazıcı işlemler ile içiçe geçirilmeden(interleave) bitmek zorundadır. Yine de, 4096 byte’tan daha uzun yazıcı işlemler gayrı-atomik olabilirler ve çağırıcı sürecin uyutuluşunu zorunlu kılabilirler.
In particular, the standard requires that write operations involving a small number of bytes must be automatically executed.
More precisely, if two or more processes are concurrently writing into a pipe, any write operation involving fewer than 4096 bytes (the pipe buffer size) must finish without being interleaved with write operations of other processes to the same pipe.
However, write operations involving more than 4096 bytes may be nonatomic and may also force the calling process to sleep.
Table 18-3. Bir Boruya n tane byte’ın yazılışı
Dahası, eğer bir borunun okuyucu süreci yoksa (yani idüğüm nesnesinin readers alanı 0 değerine sahipse) o boruya yazıcı bütün işlemler başarısız olmalıdır. O durumda, çekirdek yazıcı sürece bir -EPIPE hata kodu ile, bir SIGPIPE işareti gönderir, bu ise tanıdık “Kırık Boru” mesajına yol açar.
Moreover, any write operation to a pipe must fail if the pipe does not have a reading process (that is, if the readers field of the pipe's inode object has the value 0). In that case, the kernel sends a SIGPIPE signal to the writing process and terminates the write( ) system call with the -EPIPE error code, which usually leads to the familiar "Broken pipe" message.
pipe_write( ) fonksiyonu aşağıdaki işlemleri icra eder:
1. Borunun en azından bir okuyucu süreci olduğunu sınar. Eğer değilse, şuanki (current) sürece BORUİŞA (SIGPIPE) işaretini gönderir ve bir -EBORU (-EPIPE) değerini geri döndürür.
2. Borunun idüğümünün (inode) sys_write( ) fonksiyonu tarafından ayrılmış, i_sem semaforunu serbest bırakır ve aynı düğümün the i_atomik_yaz() (i_atomic_write) semaforunu ayırır. 
The pipe_write( ) function performs the following operations:
1. Checks whether the pipe has at least one reading process. If not, sends a SIGPIPE signal to the current process and return an -EPIPE value.
2. Releases the i_sem semaphore of the pipe's inode, which was acquired by the sys_write( ) function, and acquires the i_atomic_write semaphore of the same node. 
 i_sem semaforu çok sayıda sürecin bir dosya üzerinde yazış işlemleri başlatışını önler, ve dolayısıyla boru üzerinde de.
 The i_sem semaphore prevents multiple processes from starting write operations on a file, and thus on the pipe
3. Yazılacak byteların sayısının borunun arabölge boyu içinde olup olmadığını kontrol eder:
a. Eğer öyle ise, yazış işlemi atomik olmak zorundadır. Dolayısıyla, arabölgenin yazılacak bütün byteları depolayabilecek yeterli serbest boşluğa sahip olduğunu kontrol eder.
b. Eğer byteların sayısı arabölge boyundan daha büyükse, bir parça serbest boşluk olduğu sürece işlem başlar. Dolayısıyla en azından 1 byte boş yer olduğunu sınar.
3. Checks whether the number of bytes to be written is within the pipe's buffer size:
a.If so, the write operation must be atomic. Therefore, checks whether the buffer has enough free space to store all bytes to be written.
b. If the number of bytes is greater than the buffer size, the operation can start as long as there is any free space at all. Therefore, checks for at least 1 free byte.
4. Eğer arabölge yeterli serbest boşluğa sahip değilse ve yazıcı işlem tıkayıcıysa, şu andaki süreci borunun bekleyiş kuyruğuna sokar ve borudan bir miktar veri okununcaya kadar onu askıya alır. i_atomik_yaz() (i_atomic_write) semaforun serbest bırakılmadığının farkına varınız, dolayısıyla başka hiçbir süreç boru üstünde yazıcı bir işlem başlatamaz. Eğer yazıcı işlem tıkanmasız ise, -ETEKRAR (-EAGAIN) hata kodunu geri döndürür.
4. If the buffer does not have enough free space and the write operation is blocking, inserts the current process into the pipe's wait queue and suspends it until some data is read from the pipe. Notice that the i_atomic_write semaphore is not released, so no other process can start a write operation on the buffer. If the write operation is nonblocking, returns the -EAGAIN error code.
5. pipe_inode_info veri yapısının lock alanını sınar. Eğer boş değilse, bir başka süreç o anda boruyu okuyordur, dolayısıyla ya o anki süreci askıya alır ya da yazış işleminin tıkayıcı veya tımasız oluşuna bağlı olarak yazışı hemen sona erdirir.
6. kilit (lock) alanını arttırır.
7. İstenen sayıda byte’i (eğer boru boyu çok kısa ise serbest byte sayısı kadarını) kullanıcı adres boşluğundan borunun arabölgesine taşır.
8. Eğer hala yazılışı gereken bytelar var ise 4. adıma gider.
9. İstenen bütün veri yazıldıktan sonra, kilit (lock) alanını azaltır.
10. Borunun bekleyiş kuyruğunda bekleyen bütün süreçleri uyandırmak için uyandır_kesilebiliri() (wake_up_interruptible( )) ‘ı başlatır.
11. i_atomic_write semaforu serbest bırakır ve i_sem semaforunu bağlar (böylece sys_write( ) ikincisini kolaylıkla serbest bırakabilir).
12. Borunun arabölgesine yazılan byteların sayısını geri döndürür.
5. Checks the lock field of the pipe_inode_info data structure. If it is not null, another process is currently reading the pipe, so either suspends the current process or immediately terminates the write depending on whether the write operation is blocking or nonblocking.
6. Increments the lock field.
7. Copies the requested number of bytes (or the number of free bytes if the pipe size is too small) from the user address space to the pipe's buffer.
8. If there are bytes yet to be written, goes to step 4.
9. After all requested data is written, decrements the lock field.
10. Invokes wake_up_interruptible( ) to wake up all processes sleeping on the pipe's wait queue.
11. Releases the i_atomic_write semaphore and acquires the i_sem semaphore (so that sys_write( ) can safely release the latter).
12. Returns the number of bytes written into the pipe's buffer.
Posted by Air Traffic Control and Large Systems at 12:02