İşletim sistemleri - omegaegitim.com · 2019. 9. 9. · gnu/linux işletim sisteminde varsayılan...

İşletim Sistemleri

Bölüm 2 1 | S a y f aKabuk


Dr. Binnur Kurt [email protected]

https://www.deepcloudlabs.com


Bölüm 2 2 | S a y f a Kabuk

İÇİNDEKİLER

1. İşletim Sistemi 2. Kabuk 3. Prosesler 4. İplikler 5. İplikler Arası Eş Zamanlama 6. Prosesler Arası İletişim 7. İş Sıralama 8. Prosesler Arası Eş zamanlama 9. Bellek Yönetimi 10. Dosya Sistemi 11. Soket Haberleşme



BÖLÜM 2

Kabuk

Bölümün Amacı

Bölüm sonunda aşağıdaki konular öğrenilmiş olacaktır:

► Kabuğun özellikleri ve işletim sistemindeki görevleri

► Kabuk komut formatı

► Kabuk programlama

o Değişkenler

o Aritmetik İşlemler

o Koşullar ve Döngüler

o Fonksiyonlar



2.1 Kabuk nedir?

İşletim sistemlerinde, çekirdek sistem kaynaklarını yönetmekten sorumludur. Bunun için çok sayıda servisten oluşur. Bu servisler genel olarak prosesler arasında işlemci ve bellek gibi kaynaklara erişimini düzenler. Servislere sistem çağrıları ile ulaşılır. İşletim sistemi ile kullanıcı programları arasında tanımlanmış bir arayüz vardır. Bu arayüz bir dizi yordamdan oluşur. Bu yordamların neler olduğu, aldıkları parametreler ve parametre tipleri IEEE POSIX standardı tarafından tanımlanmıştır. Bu yordamlara ulaşmak için trap işletimci

komutundan yararlanılır. trap kesmesi ile birlikte kontrol ilgili yordama geçer ve kod çekirdek seviyesinde koşmaya başlar. Ancak sistem çağrıları alt düzey çağrılar olduğu için, sistem yönetimi ile ilgili işler için sistem çağrılarını kullanmak zordur. Bunun için sistem komutlarını kullanıyoruz. Örneğin dosya kopyalamak için cp

komutu kullanılır. Kabuk kullanıcı için bir komut satırı sağlar ve buradan kullanıcının girdiği komutları çalıştırır ve sonucu listeler. Kabuğun görevleri aşağıdaki gibi sıralanabilir: a. Çekirdek ile kullanıcı arasında bir arayüz tanımlar. b. Komut satırı yorumlayıcısıdır. Kullanıcıdan aldığı komutları çekirdeğin

anlayacağı sistem çağrılarına dönüştürür. c. Programlama ortamı sağlar. Böylelikle karmaşık komutlar ya da periyodik

olarak çalıştırılacak işler bir betik haline getirilebilir. Bu betikler ilgili kabuk tarafından çalıştırılır.

2.2 Kabuk Türleri

Tarihsel olarak Unix işletim sistemi geliştirilirken çok sayıda kabuk yazıldığını görüyoruz. Bunlar arasında çok sık karşılaştığımız kabukların listesini aşağıda veriyorum:

Bourne Shell sh

Korn Shell ksh

C Shell csh

TC Shell tcsh

B(ourne)A(gain) Shell bash

Desktop Korn Shell dtksh

Job Control Shell jsh

Restricted Shell rsh

Z Shell zsh Bu kabuklar arasında hız, güvenlik seviyesi, programlama yetenekleri gibi farklılıklar bulunur. Bu kabuklardan sıkça kullanılan birkaç tanesine bir göz atalım.

2.2.1 Bourne Shell (sh)

AT&T Bell laboratuvarında Steve R. Bourne tarafından yazılmıştır. Kabuk betiklerinde en çok tercih edilen kabuktur. Bourne kabuğu, hız ve taşınabilirliği ile öne çıkmaktadır. Solaris işletim sisteminde varsayılan kabuk sh’dır. Ancak bazı önemli

eksikleri bulunmaktadır: eski komutları hatırlamaz, aritmetik ve mantıksal işleçler



bulunmaz. root kullanıcısı için varsayılan imleç # ve diğer kullanıcılar için ise imleç $ sembolleridir. Solaris işletim sisteminde açılış betikleri Bourne kabuğu tarafından

çalıştırılır.

2.2.2 C Shell (csh)

California Üniversitesinde, Bill Joy tarafından yazılmıştır. Önceki komutları hatırlaması, aritmetik ve C benzeri ifadeler yazılabilmesi ve takma isim tanımlanabilmesi en önemli özellikleridir. Ancak Bourne kabuğundan daha yavaştır. root kullanıcısı için varsayılan imleç # ve diğer kullanıcılar için ise imleç % sembolleridir.

2.2.3 Korn Shell (ksh)

AT&T Bell laboratuvarında David Korn tarafından yazılmıştır. Bourne kabuğunu kapsar. Bu nedenle Bourne kabuğu için yazılan betikler Korn kabuğunda da çalışabilir. C kabuğu ile benzer özelliklere sahiptir. Önceki komutları hatırlar, aritmetik ve mantıksal işlemleri destekler, dizi ve fonksiyon tanımlanabilir. C kabuğundan daha hızlıdır. root kullanıcısı için varsayılan imleç # ve diğer kullanıcılar için ise imleç

$ sembolleridir. GNU/Linux işletim sisteminde varsayılan kabuk BASH’dir.

2.3 Komut Formatı

Kabuk kullanıcıdan aldığı komutları çalıştırır. Bu komutların belirli bir formatı vardır. Komutlar – ile verilen seçenek ile parametre değerlerini alırlar. Komutların düzgün kullanımı için seçeneklerin ve parametrelerin neler olduğunun bilinmesi gerekir. Bunun için öncelikli olarak man komutuna başvurulabilir: [student@server1 ~]$ man cal



Bir komutu eğer izin veriyorsa birden fazla seçenekle ya da seçeneksiz olarak çalıştırabiliriz: [student@server1 ~]$ uname Linux [student@server1 ~]$ uname -a Linux server1.example.com 3.8.13-16.2.1.el6uek.x86_64 #1 SMP Thu Nov 7 17:01:44 PST 2013 x86_64 x86_64 x86_64 GNU/Linux [student@server1 ~]$ uname -i x86_64 [student@server1 ~]$ uname -r 3.8.13-16.2.1.el6uek.x86_64 [student@server1 ~]$ uname -s Linux [student@server1 ~]$ uname -r -s Linux 3.8.13-16.2.1.el6uek.x86_64 [student@server1 ~]$ uname -s -r Linux 3.8.13-16.2.1.el6uek.x86_64 [student@server1 ~]$ uname -rs Linux 3.8.13-16.2.1.el6uek.x86_64 [student@server1 ~]$ uname -sr Linux 3.8.13-16.2.1.el6uek.x86_64 [student@server1 ~]$ uname -rs -i Linux 3.8.13-16.2.1.el6uek.x86_64 x86_64 [student@server1 ~]$ uname -rsi Linux 3.8.13-16.2.1.el6uek.x86_64 x86_64 [student@server1 ~]$ uname -r -s -i Linux 3.8.13-16.2.1.el6uek.x86_64 x86_64 Yukarıda uname komutunu herhangi bir seçenek vermeden çalıştırdık. Birden fazla

seçenek vererek çalıştırdık. Birden fazla seçenek alması durumunda bu seçenekleri toplu olarak verebileceğimiz gibi ayrı ayrı da verebiliriz: -sir ile -s –i -r aynı

anlama gelir. Benzer şekilde –si -r ile -s –i -r aynı anlama gelir. Bazen komutlar parametre alabilirler. Cal komutu ekrana takvimi döker. Eğer bir parametre verilmemiş ise içinde bulunulan yılın ve ayın takvimini ekrana döker. İstenirse ay ve yıl parametreleri verilebilir: [student@server1 ~]$ cal September 2014 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 [student@server1 ~]$ cal 7 1973 July 1973 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14



15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

İstenirse sadece yıl parametre olarak verilerek o yılın takvimi ekrana dökülebilir: [student@server1 ~]$ cal 1973 1973 January February March Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 1 2 3 1 2 3 7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10 14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17 21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24 28 29 30 31 25 26 27 28 25 26 27 28 29 30 31 April May June Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 1 2 3 4 5 1 2 8 9 10 11 12 13 14 6 7 8 9 10 11 12 3 4 5 6 7 8 9 15 16 17 18 19 20 21 13 14 15 16 17 18 19 10 11 12 13 14 15 16 22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23 29 30 27 28 29 30 31 24 25 26 27 28 29 30 July August September Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 1 2 3 4 1 8 9 10 11 12 13 14 5 6 7 8 9 10 11 2 3 4 5 6 7 8 15 16 17 18 19 20 21 12 13 14 15 16 17 18 9 10 11 12 13 14 15 22 23 24 25 26 27 28 19 20 21 22 23 24 25 16 17 18 19 20 21 22 29 30 31 26 27 28 29 30 31 23 24 25 26 27 28 29 30 October November December Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 1 2 3 1 7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8 14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15 21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22 28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29 30 31

Yukarıdaki örneklerden de anlaşılacağı gibi komutların kaç parametre alabildikleri ve parametrelerin sırasının bir önemi bulunmaktadır. Bu sıralamanın ne olduğunu öğrenmek için man komutu ile kullanım kılavuzunu (=Manual Page) okumak gerekir.

Bazen komutlar hem seçenek hem de parametre verilerek çalıştırılır: [student@server1 /]$ ls bin boot cgroup dev etc home lib lib64 lost+found media misc mnt net opt oradata proc root sbin selinux srv sys tmp usr var [student@server1 /]$ ls -l total 106 dr-xr-xr-x. 2 root root 4096 Apr 30 03:49 bin dr-xr-xr-x. 5 root root 1024 Apr 29 11:31 boot drwxr-xr-x. 10 root root 4096 Apr 29 11:38 cgroup drwxr-xr-x. 20 root root 4260 Sep 22 00:34 dev drwxr-xr-x. 125 root root 12288 Sep 22 00:38 etc drwxr-xr-x. 5 root root 4096 Apr 30 02:22 home drwxr-xr-x. 11 root root 4096 Nov 8 2013 lib dr-xr-xr-x. 10 root root 12288 Apr 30 03:49 lib64 drwx------. 2 root root 16384 Apr 29 11:09 lost+found drwxr-xr-x. 3 root root 4096 Sep 22 00:35 media



drwxr-xr-x. 2 root root 0 Sep 16 18:44 misc drwxr-xr-x. 4 root root 4096 Apr 30 06:02 mnt drwxr-xr-x. 2 root root 0 Sep 16 18:44 net drwxr-xr-x. 15 root root 4096 May 12 01:26 opt drwxr-xr-x. 3 oracle oracle 4096 Apr 30 03:37 oradata dr-xr-xr-x. 180 root root 0 Sep 16 18:44 proc dr-xr-x---. 38 root root 4096 Sep 22 01:34 root dr-xr-xr-x. 2 root root 12288 May 6 09:35 sbin drwxr-xr-x. 7 root root 0 Sep 16 18:44 selinux drwxr-xr-x. 2 root root 4096 Nov 1 2011 srv dr-xr-xr-x. 13 root root 0 Sep 16 18:44 sys drwxrwxrwt. 20 root root 4096 Sep 22 01:50 tmp drwxr-xr-x. 15 root root 4096 May 11 20:58 usr drwxr-xr-x. 22 root root 4096 Apr 29 11:28 var [student@server1 /]$ ls -l /var total 80 drwxr-xr-x. 2 root root 4096 Apr 29 11:28 account drwxr-xr-x. 17 root root 4096 Apr 29 11:38 cache drwxr-xr-x. 2 root root 4096 Nov 18 2013 crash drwxr-xr-x. 2 root root 4096 Oct 11 2013 cvs drwxr-xr-x. 3 root root 4096 Apr 29 11:28 db drwxr-xr-x. 3 root root 4096 Apr 29 11:25 empty drwxr-xr-x. 2 root root 4096 Nov 1 2011 games drwxrwx--T. 2 root gdm 4096 Nov 22 2013 gdm drwxr-xr-x. 46 root root 4096 Apr 30 02:17 lib drwxr-xr-x. 2 root root 4096 Nov 1 2011 local drwxrwxr-x. 6 root lock 4096 Sep 21 21:11 lock drwxr-xr-x. 14 root root 4096 Sep 21 21:11 log lrwxrwxrwx. 1 root root 10 Apr 29 11:10 mail -> spool/mail drwxr-xr-x. 2 root root 4096 Nov 1 2011 nis drwxr-xr-x. 2 root root 4096 Nov 1 2011 opt drwxr-xr-x. 2 root root 4096 Nov 1 2011 preserve drwxr-xr-x. 32 root root 4096 Sep 21 20:38 run drwxr-xr-x. 14 root root 4096 Apr 29 11:22 spool drwxrwxrwt. 3 root root 4096 Sep 11 10:52 tmp drwxr-xr-x. 6 root root 4096 Apr 29 11:21 www drwxr-xr-x. 3 root root 4096 Apr 29 11:21 yp

Bazen uzun soluklu bir komutu çalıştırdığımızda, tamamlanmasını beklemeden sonlandırmak isteriz. Bu durumda Ctrl+C tuşlarına basmamız yeterli olur: [student@server1 /]$ sleep 10

(10 saniye sonra) [student@server1 /]$ sleep 10 ^C

Kabuk her seferinde tek bir komut çalıştırır. Bazen birden fazla komutu tek bir seferde verip, çalıştırılmasını isteriz. Bu durumda birden fazla komutu, komutlar arasına ; sembolü koyarak giriyoruz: [student@server1 /]$ cal 7 1973 ; date ; uname -rs July 1973 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21



22 23 24 25 26 27 28 29 30 31 Mon Sep 22 01:58:19 EEST 2014 Linux 3.8.13-16.2.1.el6uek.x86_64

2.4 Alt Kabuk

Her kullanıcı için bir varsayılan kabuk vardır. Bunu echo $SHELL komutu ile öğrenebiliriz: [student@server1 ~]$ echo $SHELL /bin/bash Bu örnekte varsayılan kabuğun Bash olduğunu anlıyoruz. Şu an kullanmakta olduğumuz kabuğu anlamak için ps komutunu çalıştırmamız yeterli olur: [student@server1 ~]$ ps PID TTY TIME CMD 3819 pts/0 00:00:00 bash 3843 pts/0 00:00:00 ps ps komutu açtığımız terminalde çalışan uygulamaların listesini verir. Tüm çalışan

uygulamaların yani proseslerin listesini almak için ps -fe komutunu kullanıyoruz:

Bu örnekte Bash kabuğu ile konuştuğumuzu anlıyoruz. (Şekil-2.1)



Şekil-2.1 Bash kabuğunun çalıştığı terminal penceresi

Bir kabuktan diğerine geçiş yapmak mümkündür. Bunun için basitçe geçiş yapmak istediğimiz kabuğun komutunu çalıştırmak yeterli olur. Geçiş yaptığımız kabuğa alt kabuk adını veriyoruz. Şimdi önce Korn kabuğuna ardından C kabuğuna geçiş yapalım: [student@server1 ~]$ ksh $ ps PID TTY TIME CMD 3819 pts/0 00:00:00 bash 5746 pts/0 00:00:00 ksh 5747 pts/0 00:00:00 ps $ csh [student@server1 ~]$ ps PID TTY TIME CMD 3819 pts/0 00:00:00 bash 5746 pts/0 00:00:00 ksh 5749 pts/0 00:00:00 csh 5757 pts/0 00:00:00 ps Oluşan yapıyı Şekil-2.2’den izleyebilirsiniz. Tekrar üst kabuğa geri dönmek için ise exit komutu çalıştırılır: [student@server1 ~]$ exit $ ps PID TTY TIME CMD 3819 pts/0 00:00:00 bash 5746 pts/0 00:00:00 ksh 5801 pts/0 00:00:00 ps $ exit [student@server1 ~]$ ps PID TTY TIME CMD 3819 pts/0 00:00:00 bash 5802 pts/0 00:00:00 ps



bash

ksh

csh

ksh

csh

exit

exit

Şekil-2.2 Alt kabuklar arası geçişler

2.5 Kabuk Değişkenleri

Alt kabuk kavramı özellikle çevre değişkenleri ile çalışırken önemlidir. İki tür çevre değişkeni bulunur: Yerel ve Global. Çevre değişkeni tanımlamak son derece kolaydır: [student@server1 ~]$ VAR1=deneme [student@server1 ~]$ echo $VAR1 deneme Burada VAR1 değişkeni yerel bir değişkendir. Değişkenlerin değerlerini echo

komutu ile öğrenebiliriz. echo komutu ile değişkeni adreslerken değişkeninin adının önüne $ sembolü koyuyoruz. Yerel değişken olduğu için bir alt kabukta çalışmaya

başladığımızda değerine erişemiyoruz: [student@server1 ~]$ ksh $ echo $VAR1 $ exit [student@server1 ~]$ echo $VAR1 deneme Değişkeni global yapmak için ise export komutunu kullanıyoruz: [student@server1 ~]$ export VAR1=deneme [student@server1 ~]$ echo $VAR1 deneme [student@server1 ~]$ ksh $ echo $VAR1 deneme $ exit [student@server1 ~]$ echo $VAR1 deneme

Şimdi VAR1 değişkeni global bir değişkene dönüştüğünden Korn kabuğundan değerine ulaşabildik.



Yerel ve global değişkenler arasındaki farkı gösteren başka bir örneği aşağıda bulabilirsiniz. Bu örnek x değişkeninin yerel değişken olarak, name değişkeninin ise

export komutu ile global değişken olarak tanımlandığına dikkat ediniz: [student@server1 ~]$ x=108 [student@server1 ~]$ name="John Locke" [student@server1 ~]$ echo $name $x John Locke 108 [student@server1 ~]$ export name [student@server1 ~]$ ksh $ print $x $ print $name John Locke $ exit [student@server1 ~]$

Korn alt kabuğunda name değişkenine erişebilirken x değişkenine erişemedik. export komutunun kullanımına ilişkin diğer detayları aşağıdaki örneği inceleyerek

öğreneceğiz: [student@server1 ~]$ var=value [student@server1 ~]$ export var [student@server1 ~]$ var=value ; export var [student@server1 ~]$ export var=value [student@server1 ~]$ export x=108 y=549 z=4629 [student@server1 ~]$ echo $x 108 [student@server1 ~]$ echo $y 549 [student@server1 ~]$ echo $z 4629 ; ile birden fazla komutu tek bir seferde kabuğa geçirmemiz mümkündür: var=value ; export var

Burada yapılan işlem export var=value ile yapılan işlemle aynıdır. export

komutu ile bir kerede birden fazla değişken tanımlanabilir. Kabuk değişkenlerine erişmek için daha yetenekli olan ${} gösterimi de kullanılmaktadır: [student@server1 ~]$ counter=1 [student@server1 ~]$ echo $counter 1 [student@server1 ~]$ echo ${counter} 1 ${} gösteriminin başka yetenekleri de vardır. Bu yetenekleri aşağıdaki örneklerde

görmeye çalışalım: [student@server1 ~]$ var=x [student@server1 ~]$ echo ${var:-y} x [student@server1 ~]$ var= [student@server1 ~]$ echo ${var:-y} y [student@server1 ~]$ unset var [student@server1 ~]$ echo ${var:=y}



y [student@server1 ~]$ echo ${var:=z} y [student@server1 ~]$ echo $var y

Burada ${var:-y} ile var değişkenin değeri yoksa y değerini kullanması isteniyor. Burada değişkenin değerinin değişmediğine dikkat edin. Eğer değişkeninin değerinin değişmesini istiyorsanız ${var:=y} gösterimini kullanmalısınız.

Değişkenin değeri üzerinde + sembolü kullanılarak bitiştirme işlemi yapılabilir: [student@server1 ~]$ for f in 4 8 15 16 23 42 > do > list=${list:+$list,}$f > done [student@server1 ~]$ echo $list 4,8,15,16,23,42 Değişken çift tırnak içinde kullanıldığında değişkeninin içeriğindeki görünmeyen karakterler ekrana basılır: [student@server1 ~]$ list="a b c d e f" [student@server1 ~]$ echo $list a b c d e f [student@server1 ~]$ echo "$list" a b c d e f

2.6 Kabuk Betikleri

Çok sık çalıştırdığımız kalabalık seçenekleri olan ya da karmaşık komutları betik dosyası oluşturarak komut satırından kolayca erişilebilir hale getirebiliriz. Bunun dışında periyodik olarak çalıştırılacak işlerimiz varsa, yine bu işleri, betik dosyası oluşturup örneğin crontab servisini kullanarak otomatik olarak çalıştırabiliriz.

Benzer şekilde basit karmaşıklıktaki sistem seviyesindeki problemler için betik yazmayı tercih ederiz. Daha karmaşık problemler için Perl, Python gibi daha üst düzey dilleri kullanmayı tercih ederiz. Betik dosyaları oluşturulurken belirli bir kabuk tercih edilir ve çalıştırmasını istediğimiz kabuğu ilk satırda belirtiriz: #!/bin/sh set -- * files=$# set -- */ dirs=$# echo “Dosya sayisi ($PWD): $files” echo “Katalog sayisi ($PWD): $dirs” Yukarıdaki betiği first.sh dosyasında oluşturmuş olalım. Bu betiği çalıştırabilmek için çalışma yetkisi vermemiz gerekir: [student@server1 ~]$ chmod +x first.sh Artık çalıştırabiliriz: [student@server1 ~]$ ./first.sh Dosya sayisi (/home/student): 19



Katalog sayisi(/home/student): 16

Betiği çalıştırmanın başka yolları da bulunmaktadır: a. . komutu ile çalıştırmak

[student@server1 ~]$ . ./first.sh Dosya sayisi (/home/student): 19 Katalog sayisi(/home/student): 16

b. source komutu ile çalıştırmak [student@server1 ~]$ source ./first.sh Dosya sayisi (/home/student): 19 Katalog sayisi(/home/student): 16

c. betik dosyasının adını vererek çalıştırmak [student@server1 ~]$ ./first.sh Dosya sayisi (/home/student): 19 Katalog sayisi(/home/student): 16

d. Kabuk komutu ile çalıştırmak [student@server1 ~]$ sh ./first.sh Dosya sayisi (/home/student): 19 Katalog sayisi(/home/student): 16 a, b ve d’de verilen yöntemlerde betik dosyasının çalışma izninin olmasına bakılmaz. a ve b yöntemlerinde betik mevcut kabuk tarafından çalıştırılır, ayrı bir proses yaratılmaz. c ve d’de ise alt kabuk yaratılır ve betik bu alt kabuk tarafından çalıştırılır. Bu yüzden betik içinde tanımlana değişkenler export komutu ile tanımlanmış olsa bile, betik çalıştırılıp, kabuğa dönüldüğünde değişkene erişilemez: [student@server1 ~]$ echo $VAR1 [student@server1 ~]$ . ./second.sh [student@server1 ~]$ echo $VAR1 deneme [student@server1 ~]$ unset VAR1 [student@server1 ~]$ echo $VAR1 [student@server1 ~]$ source ./second.sh [student@server1 ~]$ echo $VAR1 deneme [student@server1 ~]$ unset VAR1 [student@server1 ~]$ echo $VAR1 [student@server1 ~]$ ./second.sh [student@server1 ~]$ echo $VAR1 [student@server1 ~]$ sh ./second.sh [student@server1 ~]$ echo $VAR1 [student@server1 ~]$ second.sh betiğinin içeriği aşağıdaki gibidir: #!/bin/sh export VAR1=deneme



2.7 Özel Kabuk Değişkenleri

Kabukla çalışırken kullanabileceğimiz özel değişkenler vardır. Şimdi bu değişkenlere bir göz atalım:

$$ Çalışan prosesin proses kimlik numarasını verir

[student@server1 ~]$ cat third.sh #!/bin/sh echo $$ [student@server1 ~]$ ps PID TTY TIME CMD 3819 pts/0 00:00:00 bash 9876 pts/0 00:00:00 ps [student@server1 ~]$ echo $$ 3819 [student@server1 ~]$ ./third.sh 9879 [student@server1 ~]$ . ./third.sh 3819 [student@server1 ~]$ source ./third.sh 3819 [student@server1 ~]$ sh ./third.sh 9888

$? Son çalıştırılan prosesin exit değerini verir. Eğer sıfırsa işlem başarılı

olmuştur. Sıfır dışındaki tüm değerler bir problemi işaret eder. Betiklerde hatalı durumları yakalamak için kullanılır. [student@server1 ~]$ ls /nodir ls: cannot access /nodir: No such file or directory [student@server1 ~]$ echo $? 2 [student@server1 ~]$ ls / bin dev lib media net proc selinux tmp boot etc lib64 misc opt root srv usr cgroup home lost+found mnt oradata sbin sys var [student@server1 ~]$ echo $? 0 [student@server1 ~]$ true ; echo $? 0 [student@server1 ~]$ false ; echo $? 1

$! Arka planda çalıştırılan prosesin kimlik numarasını öğrenmek için kullanılır.

Aşağıdaki betik arka planda bir hesap makinası açar ve 10 saniye sonra bu hesap makinasını kapatır:



#!/bin/sh gcalctool & while true ; do pid=$! sleep 10 kill -9 $pid break done &

# Değişkenin içeriğinin karakter uzunluğunu verir. [student@server1 ~]$ export var="Hello Mars" [student@server1 ~]$ echo ${#var} 10

%

Değişkenin içeriğinden sağdan ilk eşleşmeyi siler.

%% Değişkenin içeriğinden sağdan ilk eşleşmeyi siler.

# Değişkenin içeriğinden soldan ilk eşleşmeyi siler.

## Değişkenin içeriğinden soldan ilk eşleşmeyi siler.

[student@server1 ~]$ var=/usr/local/bin/example [student@server1 ~]$ echo ${var%/*} /usr/local/bin [student@server1 ~]$ var=usr/local/bin/example [student@server1 ~]$ echo ${var%%/*} usr [student@server1 ~]$ var=usr/local/bin/example [student@server1 ~]$ echo ${var#*/} local/bin/example [student@server1 ~]$ var=usr/local/bin/example [student@server1 ~]$ echo ${var##*/} Example [student@server1 ~]$ export var=abcdef [student@server1 ~]$ echo ${var%${var#?}} a [student@server1 ~]$ echo ${var#${var%?}} f

${var//PATTERN/STRING} var değişkenindeki tüm PATTERN’leri STRING ile değiştirir.

[student@server1 ~]$ echo -e "${var}\n${var//?/~}" Bölüm 2 - Kabuk ~~~~~~~~~~~~~~~

${var:OFFSET:LENGTH} var değişkeninde OFFSET’ten itibaren LENGTH adet karakteri getirir [student@server1 ~]$ export var=abcdefgh [student@server1 ~]$ echo ${var:3:2} de



[student@server1 ~]$ echo ${var:3} defgh

2.8 Aritmetik İşlemler

Korn kabuğu ile çalışırken değişkenler üzerinde aritmetiksel ve mantıksal işlemler yapabiliriz. Aritmetik işlemler için toplama, çıkarma, çarpma, bölme ve bölümden kalan operatörlerini kullanabiliriz. Bu operatörlerin listesini Tablo-2.1’de bulabilirsiniz:

Tablo-2.1 Aritmetik İşlemler

Korn kabuğunda tüm aritmetik işlemler tamsayı aritmetiği olarak gerçekleştirilir. Kayan noktalı sayılar için bir çözüm bulunmaz. Kayan noktalı sayılar ile işlem yapmak için bc komutunu kullanıyoruz. bc komutu bilimsel hesaplamalar da olmak üzere her

türlü karmaşıklıktaki hesaplamalar için istenilen hassasiyette hesaplama yapılmasına izin verir: [student@server1 ~]$ echo "scale=8; a(1)*4" | bc -l 3.14159264 [student@server1 ~]$ echo "scale=16; a(1)*4" | bc -l 3.1415926535897932 [student@server1 ~]$ echo "scale=64; a(1)*4" | bc -l 3.1415926535897932384626433832795028841971693993751058209749445920 [student@server1 ~]$ echo "scale=256; a(1)*4" | bc -l 3.141592653589793238462643383279502884197169399375105820974944592307\ 81640628620899862803482534211706798214808651328230664709384460955058\ 22317253594081284811174502841027019385211055596446229489549303819644\ 288109756659334461284756482337867831652712019091456484

Operatör İşlem Örnek Sonuç

+ Toplama ((x = 24 + 25)) 49

- Çıkarma ((x = 100 - 25)) 75

* Çarpma ((x = 4 * 5)) 20

/ Bölme ((x = 10 / 3)) 3

% Bölümden Kalan ((x = 10 % 3)) 1



Yukarıdaki örnekte PI sayısını istenilen basamak değerine kadar hesaplanabildiğini görüyoruz. Burada a(1), arctan trigonometrik fonksiyonunu göstermektedir.

arctan(1) PI/4’dür.

2.9 Koşullu İfadeler

Sonlanan her prosesin bir çıkış değeri bulunur. Bu değere göre prosesin başarılı olarak sonlanıp sonlanmadığı anlaşılabilir. 0 değeri işlemin başarıyla gerçekleştiğini gösterir. Sıfırdan her farklı değer işlemin başarısız olduğu anlamına gelir: [student@server1 /]$ if grep root /etc/passwd > then > echo "root bulundu." > fi root:x:0:0:root:/root:/bin/bash operator:x:11:0:operator:/root:/sbin/nologin root bulundu. ya da [student@server1 /]$ if grep root /etc/passwd > /dev/null > then > echo "root bulundu." > fi root bulundu. Bir betiği belirli bir sayıda parametre ile çalıştırmak gerekiyorsa, bunun testi aşağıdaki gibi yapılabilir: if (( $# != 2 )) then print "KULLANIM: $0 arg1 arg2 " exit fi

2.10 Döngüler

Döngü oluşturmak için birkaç yöntem bulunmaktadır. Bunlardan ilki for yapısını

kullanmaktır:

[student@server1 /]$ for meyve in elma portakal muz kavun karpuz > do > echo "Meyve: $meyve" > done Meyve: elma Meyve: portakal Meyve: muz Meyve: kavun Meyve: karpuz

İkinci yöntem while yapısını kullanmaktır. while döngüsünde döngü koşulu doğru olana kadar döngü bloğu tekrar tekrar çalıştırılır. Aşağıdaki örnekte sayısal loto için 1-49 arasında biri birinden farklı altı sayı rastgele olarak belirlenmektedir:



#!/bin/ksh (( r = RANDOM % 49 + 1 )) list="$r\n" for i in 2 3 4 5 6 ; do while true ; do (( r = RANDOM % 49 + 1 )) echo "$list" | grep "^$r$" > /dev/null if (( $? != 0 )) ; then break fi done list="$list\n$r" done list=$(echo "$list" | sort -n) echo $list Üçüncü yöntem until yapısını kullanmaktır. until döngüsünde while

döngüsünün tersine, test koşulu yanlış olduğu sürece döngü döner: #!/bin/ksh num=1 until (( num == 6 )) do echo "The value of num is: $num" (( num = num + 1 )) done print "Done."

Dizi kullanan örnek bir döngü uygulamasını inceleyelim:

#!/bin/ksh

for i in 1 2 3 4 5 6 ; do

((r= $RANDOM % 49 + 1))

numbers[$i]=$r

done

for j in ${numbers[*]} ; do

echo $j

done | sort -n

Bu örnekte, ilk for döngüsünde sayısal loto için 1-49 arasında altı sayı rastgele

olarak belirlenmekte ve numbers isimli dizide saklanmaktadır. İkinci for döngüsünde ise numbers dizindeki değerler taranarak, sıralı olacak şekilde ekrana

yazılmaktadır. Sıralama işlemi için sort komutundan yararlanılmıştır. sort komutunun sayısal değer olarak değerlendirmesi ve sıralaması için –n seçeneği

verilmiştir.

2.11 Fonksiyonlar

Çok sık karşılaşılan problemlerin çözümünü fonksiyon olarak ayrı bir dosyada saklayabilirsek, aynı problemle tekrar karşılaştığımız betikte fonksiyonu çağırarak çözüme hızlıca ulaşabiliriz. Fonksiyonlar betiklerimizden ayrı dosyalarda bir dizinde



saklanırlar. Bu dosyaların çalıştırma yetkisine de sahip olması gerekmez. Kabuğa, fonksiyonların yer aldığı bu dosyaların dizinini, FPATH sistem değişkeni ile

tanıtıyoruz: [student@server1 ~]$ mkdir fun [student@server1 ~]$ export FPATH=$HOME/fun

Bu dizinde sadece fonksiyon dosyalarının olmasına dikkat etmelisiniz. Fonksiyon ismi ile dosya ismi aynı olmalıdır. Fonksiyonun genel yazımı aşağıdaki gibidir: function hello { print “Merhaba $1” }

Burada function anahtar kelimedir. Her fonksiyonun bir adı olmalıdır. Yukarıdaki örnekte fonksiyonun adı hello’dur. Fonksiyonlar parametre alabilirler. Fonksiyonun

aldığı parametrelere erişmek için $ sembolünden yararlanıyoruz. İlk parametreye ulaşmak için $1’i ikinci parametreye ulaşmak için ise $2 tanımlamasını kullanıyoruz.

Dokuzuncu parametreden sonra kıvırcık parantez kullanılmalıdır. Örneğin onuncu parametre için ${10} gösterimi kullanılmalıdır. [student@server1 fun]$ pwd /home/student/fun [student@server1 fun]$ ls hello [student@server1 fun]$ cat hello function hello { print "Merhaba $1" } Şimdi hello isimli fonksiyonu kullanacağımız basit bir betik yazalım: [student@server1 ~]$ cat test_hello.ksh #!/bin/ksh lost[1]="Jack Shephard" lost[2]="Kate Austen" lost[3]="James Ford" IFS=, for name in ${lost[*]} do hello $name done [student@server1 ~]$ ./test_hello.ksh Merhaba Jack Shephard Merhaba Kate Austen Merhaba James Ford

Yukarıdaki örnekte lost dizisine üç değer atadık. Bu nedenle döngü üç defa döndü ve hello fonksiyonu üç defa çalıştırıldı.

İşletim sistemleri - omegaegitim.com · 2019. 9. 9. · gnu/linux işletim sisteminde varsayılan...

Documents