1 Mart 2015 Pazar

Richard Stallman - Telif Hakları Sunumu

Bu sene Stallman Türkiye'ye geldi. İstanbul'da iki sunum yaptı ve Bilmök'te bir sunum daha yapacak. Etkinlik hakkında bilgi için buraya bakabilirsiniz.

Ben Sabancı Üniversitesi'nde yapılan Telif Hakları konuşmasına katıldım. İlk defa bu kadar büyük bir insanın yaptığı konuşmaya katıldım, çok mutluyum. İstanbul Avrupa tarafında oturmam ve etkinliğin Tuzla'da olması nedeniyle 09:30da yola çıktım ama olsun :). Sabah Kadıköy'de Gülçin ile buluşup servisle etkinliğe gittim. Bu kadar zaman sadece sosyal ağlardan konuşma fırsatı bulduğum insanlarla yüz yüze görüşmek de heyecanlı oluyor.

Etkinliğe muhtemelen kapılar kırılır, ortalık yıkılır düşüncesi ve Necdet hocayla (ve ekibiyle) daha fazla vakit geçirmek için bir saat erken gittim. Necdet hocayı ve arkadaşlarımı görme kısmı tamamdı ancak böyle bir etkinlikte dolup taşıp oturmaya yer olmaması gibi bir durum beklerdim, olmadı. Salon doluydu ancak yine de beklediğim hararet yoktu.

Stallman konuşurken "bu konuda en mantıklı böyle düşünebilirdi" düşüncesi aklımda oluştu. Aslında Necdet hoca da bize okulda yıllardan beri Stallman'ın felsefesinden, görüşlerinden bahsediyor. Stallman konuşurken "Necdet hoca da bize bunlardan bahsetmişti" şeklinde hatırladım. Stallman'ın bize bahsettiği noktalar:

- Özgürlük nedir? Özgürlük yazılım açısından nedir?
- Özgürlük kod içeriği şöyle olmalıdır, böyle güvenli olmalıdır, gibi şeyleri göz önüne almaz, kullanıcının onu değiştirebilmesi, dağıtabilmesi anlamına gelir
- Özgür olmayan yazılımlar oluşturulmamalıdır
- İnsanların sahip olduğu yazılımları paylaşma hakları ellerinden alınmamalıdır
- Eğer bir sistem içerisinde özgür olmayan başka yazılımlar da varsa o sistem özgürlüğünü kaybeder

Bunun dışında tersine mühendislik hakkında da güzel şeyler söyledi. Üniversitelerde ders olarak verilmesi gerektiğinden bahsetti. Bir de Torvalds hakkında da .. :(. Bu ara Linux Vakfı'nda staj yaptığımdan yine de öyle demesek mi şirinliğinde dinledim :). Torvalds'ın Gnu projesini de kullanarak bir çekirdek oluşturduğunu ve Gnu içerisinde bir boşluk oluşup Linux'un geliştirildiğinden bahsetti.

Etkinlik başlarında Gnu is not unix şakası oldukça döndü. Bu cümleyi ilk okuduğum zamanı dün gibi hatırlıyorum. 2. sınıftayken Gnu ne acaba diyip What is gnu yazdığımda gördüğüm ilk cevap Gnu is not unix olmuştu. O zamanlar çok yeni olduğumdan "hmmm .. Pek anlamadım, bir daha okuyalım, Gnu is not unix .. hmm ..". O halim de pek şirindi ;).

Etkinliğin sonlarına doğru Gnu peluş oyuncak açık artırmaya sunuldu ve sahibi elbette ki Necdet hoca oldu. Aslında yedi kişi bir Gnu'ya girsek de olabilirdi ama .. :).

Açık artırmadan sonra dinleyicilerin sorularına yer verildi ve soranların bir kısmı Stallman'ın aslında iddia etmediği şeyleri sanki Stallman öyle düşünüyormuş gibi sordu. Düşünceler hakkında böyle düşünmek de yanlış olmaz mı, ya da şöyle düşünebilir mi şeklinde sorulmasını anlarım ama salonda ben haklıyım şeklinde yapılan konuşmalar vardı. Stallman'ın buna verdiği cevap beni dinlemeye gelenler bana katılmayabilir ne yapabilirim oldu :).

Etkinlik çıkışında Necdet hoca ve öğrenci/mezun grup birlikte vakit geçirdik. Dün Kaan'ın da söylediği gibi ben biraz neşe saçmış olsam da çok güzel bir gündü. Aşağıda etkinlikten fotoğraflar, Stallman ile topluca fotoğraf çektirdik :)





21 Şubat 2015 Cumartesi

ÇOMÜ'de Bilgisayar Mühendisliği Okumak

Geçtiğimiz yaz haziran sonunda lisans dönemimi tamamlamış oldum. 4 yıl süren dolu, heyecanlı bir üniversite hayatı oldu.

İlk sene her yeni gelen gibi şehir efsaneleri duydum, okulu bitirebilecek miyim, acaba doğru bir bölümde miyim gibi her arkadaşımda olan hislere kapıldım. Daha önceden bilgisayar bilimlerine yakınlığım yoktu, soyut konuları sevdiğim için bu bölümü seçtim. Zaten güzel ülkemde öğrencilerin nasıl bölüm seçtikleri kendi başına ayrı bir konu, ona şimdi burada değinmeyeceğim :).

1. sınıftayken Necdet hoca bize derste öğrencilerinden bahsederdi, bana da hep Necdet hocayla çalışmak uzak bir hayal gibi gelirdi, hayal dememin nedeni kendimi yetersiz görmem, o kadar yetenekli değilim, zeki değilim, ben düz lise çıkışlıyım (ne alakaysa :)) gibi .. şuan çoğu öğrencide malesef olan hisler.

Bir gün ÇoMaK ekibi alt sınıflara sunum yapacaktı, ben bu sunumu son anda öğrendim. Ondan birkaç hafta önce etkinliklere katılmalıyım, araştırma yapmalıyım gibi düşünceler aklımda oluşmaya başlamıştı. Bu sunum tam bunun üzerine denk gelmişti. O gün sunuma dinlemek için katıldım ve aynı gün Necdet hocanın ekibi arasına katıldığım gün oldu. Zaten etkinliğe katıldığın zaman böyle katılacaksın :P.

Bilgi işlem o zamanlar çok kalabalıktı, ben de pek küçüktüm ;). O zaman etrafımda Gsoc'a alınmış birçok insan vardı, bu benim üzerimdeki heyecanı daha çok artıran bir etkendi. 1. sınıftayken İngilizce'min ne kadar yetersiz olduğunu hatta hiç olmadığını fark ettim. 1'in yazından beri kurslara gidiyorum, neredeyse 3. sınıfa kadar da evde kendim kelime ezberleyerek geçirdim. 20 yaşına gelmiş bir insan olarak İngilizce iki kelimeyi bir araya getirememek gerçekten pek utandığım bir durumdu. Neyse o sorunlar da zamanla azaldı. Hatta 3. sınıfta yaptığım konuşma pratikleri 4. sınıfın sonunda Google'a iş görüşmesi için İrlanda'ya kadar gitmemi sağladı.

Öğrenciyken mezun olabilir miyim düşüncesi yerini notları sınıfta en yüksek olan öğrencilerden biri olmaya bıraktı. 3. sınıfın sonlarına kadar mezun olunca nasıl iş bulacağım düşüncesiyle kendimi geliştirme çabalarım ise yurt dışına burs alarak gitmeyi nasıl sağlayabilirim çalışmalarına döndü :).

Öğrenciyken bilgisayar bilimleri hakkında birçok farklı alanda çalıştım. Hepsinde tam bir çalışma ve birçok derin özelliğini öğrenme kadar ilerlemesem de hangi alanlarda çalışabileceğimi gördüm ve birçoğunda uygulama geliştirdim. Masaüstü uygulamaları, web uygulaması, sunucu tarafında çalışacak yazılımlar, sunucu yönetimi ve sistem yöneticilerinin kullandıkları teknolojiler, kavramlar gibi şeylere baktım. Android cihazlara uygulama yazmaya da baktım ancak pek fazla ilgimi çekmedi.

3'teyken OPW için Gnome'a katkı verdim ve o süreçte ilk kez yabancı biriyle uzaktan çalışıyordum. 3'teyken Ruby & Gtk  kullanmam, Ruby'nin eksik gördüğüm yanları nedeniyle bana listelerde soru sorma alışkanlığı kazandırdı. Aynı zamanda liste takip etme alışkanlığını da. Listeleri takip etmek insana gerçekten çok şey kazandırıyor ve üstelik takip ederken çok az vakit harcamış oluyorum.

4. sınıfta Linux çekirdeği üzerinde çalışmaya başladım ve şimdi Gnome OPW, Linux Kernel'da staj yapıyorum.

Öğrenciliğim sürecinde Necdet hocayla çalıştım, yanlış yaptığım şeylerin doğrusunu ve bunun dünya genelinde nasıl olduğunu öğrendim. Bilmediğim birçok şeyden haberdar oldum ve daha sonra hiç bilmediğim başka şeylerden nasıl haberdar olabiliceğimi öğrendim (listeleri, blogları takip etme alışkanlığıyla). Kullanıcı dostu uygulama yazmak, belgelemek, standartlara uymak ve araştırmayı öğrendim.

4 yıl benim için yoğun geçti ve bu süreci kendimi geliştirmek için bir fırsat olarak gördüm. Bir süre çok hata yapıyorum, yapamıyorum gibi düşüncelere kapıldım hatta bir ara bilgi işlemden ayrıldım, sonra geri geldim ;). Çok renkli bir öğrencilik hayatım vardı :).

Necdet hocayla birlikte çalışmak çalışma enerjimi korumamı sağladı, kendisi hep enerjisine hayran olduğum bir insan. Birlikte çalışma sürecim boyunca da cesaretlenmemi sağladı.

Ben birçok konuda normalin üzerinde heyecana sahip olan bir insanım, bir zamanlar bu kadar heyecanlı olmayı iyi bir şey gibi görmezken daha sonradan fark ettim ki bu aslında çok güzel bir şey. Şimdi öğrencilik günlerime baktığımda (sanırsın on yıl önce mezun olmuş) bu heyecanlı günlerimi ve Necdet hocanın bu konuda yaptığı şakaları hatırlıyorum :). Necdet hoca benim hem öğrenciyken birlikte çalıştığım hocam hem de arkadaşım.

Aslında Çomü'de her şey bu anlattığım kadar pürüzsüz değil malesef. Benim gördüğüm hocaların büyük bir kısmında her geçen sene ders anlatma isteğinde azalma, aynı şekilde öğrencilerde de dinleme isteğinde bir azalma var. Sorun hiçbir şekilde dersin slaytlardan işlenmesi değil. Hayvan derisine yazarak işleyecek değiliz elbette. Sorun, dersin sadece slayt okunarak işlenmesi, o slaytları çıkıp ben de okuyabilirim. Akademisyen olmaya gerek var mı bunun için? En çok anlam veremediğim ise derste sorduğumuz sorulara tatmin edici bir cevap alamıyor olmak ya da geçiştirici cevaplar almak.

Uzun yıllar boyunca anlayamadığım bir konuda okulda büyük bir çoğunluğun birbirine suç atıyor olması. Pek az insan acaba öğrenciliğimi/öğretmenliğimi düzgün yapıyor muyum dedi. Genelde büyük çoğunluk suçu başkalarında buldu. Elbette ki mesele haklı haksız bulmak değil ama ortada öğrencinin kendini geliştiremiyor olması gibi bir problem var ve bu durum karşısında hocalara hiçbir şey olmuyor. İstediğin kadar tartış, şikayet et. Olan yine öğrencilere oluyor ve mesleğini sevmeden yapan nesiller yetişiyor. Evet, öğrenciler kendilerini yetiştirmek için bir şeyler yapmalı, internette her kaynak var, çok iyi üniversitelerde anlatılan dersleri internetten de izleyebiliriz. Hocalar her şeyi alıp öğrencinin beynine yerleştirsin de değil beklentim ancak bu yaptıklarının da doğru olmadığı çok açık ortada. 4. sınıfın ilk döneminde, mecburen tamamen ezber anlatan bir hocanın iki dersini birden seçmek zorunda kalmıştık, bu da 2000 slayt yapıyor ve slaytlar tamamen dolu, resim falan çok az var. Olsa da onları da inceleyerek ezberlemek gerekiyor. Bunun dışında zaten zorunlu olan ve ezber içerikli bir dersimiz de vardı. 4'ün ikisinde toplam 6 ders açıldı, ben bunlardan bir tanesini zaten seçemiyordum diğer 40 arkadaşım gibi. Yani bu durumda seçmeli adı altında geriye kalan 5 dersin 5'ini de aldık.

4. sınıfın sonlarına doğru tüm hayat enerjim çekilmiş gibi hissettiğim bir süreç oldu, bir gün çok enerjiğim diyerek derse girdim ve içim şişti diyerek dersten çıktım. Aslında içi çabuk şişen bir insan da değilimdir ama ..

Neyse ki dört sene bitti. Lisans deneyimimden sonra hep bahsetmek istediğim yukarıda şikayet ettiğim durumlar değil, onları belki birileri bir şeyleri değiştirir ümidiyle yazdım. Şimdi hatırladıklarım, kendime ne kadar çok şey kattığım, deneyimler, güzel çalışma ve bazen yaptığım gezme günleri :).

31 Ocak 2015 Cumartesi

Linux Kernel Ekibiyle Staj

Geçtiğimiz yaz haziran sonunda mezun oldum. Mezuniyetten sonra bir işe girip çalışmak, her gün işe gidip gelmek, birkaç ay işim dışında bir şeye bakmamak, sonrasında iş temposuyla birlikte neler yapabileceğime karar vermek gibi bir düşüncem vardı. Ancak tabi ki böyle olmadı :).

Ağustos başında Google İrlanda ofisinden iş görüşmesi için e-posta aldım, benim ile başlangıç bir telefon görüşmesi yapmak istediklerini söylediler. Hemen kabul ettim. İlk üç aşamayı geçtim, son görüşme için Irlanda'ya gittim ancak son görüşmede başarılı olamadım. Sorular beklediğim gibi değildi, internetten çalıştığım gibi de değildi.

Ben evde son görüşmeye hazırlanırken Gnome OPW için başvurular da başlamıştı. Ben daha önce ilk Gnome'un araçlarına sonra da Linux Kernel'a başvurmuştum. Gnome'a katkı verirken katkı vermek için masaüstü bilgisayarınızda ortam oluşturmak zor. En son Fedora 19'un alfa sürümünü kullanmak zorunda kalmam ve alfanın hiç kullanışlı olmaması üzerine katkı vermeyi sonlandırdım :). Aslında jhubild'de kullanabiliriz ama onda ortamı hazırlaması .. bana bir tane geliştiricisi o zamanlar Fedora beta sürümü varken, beta kullanmamı önermişti, beta yine kullanılabilirdi ancak bir sonraki sürüme geçtiklerinde alfa kullanmak zorunda kalmam pek iyi olmadı. Bir de Gnome Continuous var, onu yeni gördüm ama henüz denemedim.

Linux Kernel'a katkı verdiğim sene aslında alınmayı beklemiştim gerçekten ama olmadı. Bu dönem başvuru süresi 2 ay gibi uzundu :), geçen sene 3 hafta gibi bir süreydi. Necdet hoca "Aslında sen başvursan çok şey yaparsın" dedi, ben de başvurdum ve alındım :). Alınmayı gerçekten beklemiyordum ve çok güzel bir sürpriz oldu.

Şimdi Rik van Riel ile birlikte bellek yönetimi üzerinde çalışıyorum. Bellek yönetimi katkı vermeye başlamanın en zor olduğu kısımlardan biri, çünkü çekirdeğin temel fonksiyonlarını içeriyor ve daha karmaşık. Başvurduğunuz projeye göre staj sürecinde ne kadar yama gönderebileceğinizin sayısı da değişiyor. Ben projem zor olduğundan, 4 ayda otuz satır yazabilir miyim derken şimdiden bir yamayı kabul ettiler bile :).

Linux kaynak kodunda bellek yönetimi ile ilgili dizin mm/. Eğer güncel mm dizinini takip etmek istiyorsak da Linus Torvalds'ın kullandığı dalı değil de linux-next'i takip etmek gerekiyor. Yamaları Andrew Morton kabul ediyor ve günlük olarak etiketliyor. Güncel linux-next'i nasıl takip edeceğinizi görmek için buraya bakabilirsiniz.

Anladığım kadarıyla, Linux'ta bellek yönetimi üzerine çoğunlukla Redhat ekibi bakıyor, çünkü birçok sunumu ve belgeyi o ekip hazırlamış. Ben yamaları gönderirken mm dizini bakıcılarına baktığımda genelde @redhat.com alan adlı hesaplar var. Yamaları vger.kernel.org ve  akpm@linux-foundation.org listelerine gönderdiğim için de çok mutluyum. O kadar büyük listelerdeki insanların kodlara bakıyor olması oldukça heyecanlı :).

Üzerinde çalıştığım proje ise, bellek üzerinde 2kB/4kB kadar boyutlarda olabilen sayfaların dışında bir de büyük sayfalar (huge page) var. Onların boyutları ise 2MB/4MB. Peki neden büyük sayfalara ihtiyaç duyuyoruz? Çünkü sayfalar büyük olduğunda sayfa tabloları da büyük oluyor ve bir süreç için verileri bellekten atma/belleğe getirme miktarı azalıyor. Eğer sayfalar 4MB'tan büyük olursa verimsiz oluyor.

Sistemin swap kullanması gerektiğinde büyük sayfalar normal boyutlu sayfalara parçalanıyor (2kB/4kB) ve o şekilde swap alanına yerleştiriliyor. Sorun şu ki; swap alanından belleğe tekrar geri getirilmek istendiğinde büyük sayfa olarak değil, normal boyutlu sayfalar olarak getiriliyorlar bu durumda eski verim sağlanamıyor, aynı zamanda burada izlenmesi gereken bir algoritmaya da karar verilmeli. Çünkü bir süreç swap kullanıyor diyelim, ve swapte olan bir veriye ihtiyaç duyuldu, sadece tek bir verinin bulunduğu sayfa 2kB, ancak bunun yerine 2MB büyük sayfa getirmek her zaman yararlı olmaz. Burada karar verilmesi gereken noktalar var.

Geçtiğimiz dönem kod ve belge okumak üzerine geçti. Bir tane de yama gönderdim. Sadece okunabilir sayfaları büyük sayfalar şeklinde birleştirmek için. Yamayı burada görebilirsiniz.

Bundan sonraki bir süre ise; "daha önce hiç okuma/yazma isteği almamış, henüz fiziksel belleğe eşlenmemiş, sadece sanalda bulunan, bir süre sonra ilk kez okuma izni aldığında fiziksel belleğe eşlenen sayfalar" var, bunlara zero page deniliyor, bunlar üzerinde çalışacağım. Eğer sayfa içerisinde veri yoksa, ilk okuma isteği aldığında çekirdek bunu sıfırlarla dolu bir sayfa olarak üretiyor. Bunları da büyük sayfalara dahil etmek üzere çalışacağım. Aynı zamanda (emin değilim), Documentation dizininde de belgelendirme yapmam gerekecek. Muhtemelen birkaç işim daha var ancak henüz ben bilmiyorum, danışmanımla işleri bitirdikçe yenisini alma şeklinde ilerliyoruz. Henüz başlamadığımız işlerden de şuna bir ara bakarız şeklinde konuşuyoruz.

Staj sürecinde birkaç Türkçe yazı daha yazacağım (yazmadı) :).

29 Ocak 2015 Perşembe

Sending First Patch To Upstream

Last week, I sent first patch to upstream and it was accepted in mm tree :). I am very happy about that. You can see it here.

Subsystem maintainers are very careful and a lot of people review the codes. Out side of staging directory, and before the internship, my first patch is about y2038 project. When I sent patch for y2038, a lot of developers reviewed and suggested something. I have recently seen the patch here: http://lwn.net/Articles/620870/, it was my first experience :).

Todays, I work with linux kernel mm community, this makes me very excited and happy :).  I gained some experiences in this process and learnt how can I be sure with my changes. This is most important case for coding. When I talked with my mentor, every time I reported different thing :) and said "oh this prevents collapsing pages into a thp!". Because I was testing wrong. Finally I could find what was the problem.

For test results, I look /var/log/kern.log, it is very large file so I split it like that: "split -n 5" and look newly created small files and log time stamps is important. To be sure with my changes print out virtual memory address area for my test programs.

/proc/pid/smaps shows whole vmas for the process. pr_info("vm_start = %04lx\n", vma->vm_start); is enough to see begining address of the vma. Sometimes I need to see which process run this function, I print out current->pid. If I know what happened in every step, I find my faults very easy. I have to do something like that, because other processes will log about their huge pages in kern.log and I shouldn't confuse which process logged the results. To examining kern.log was big scale thing for me.

Before sending patch I need to be careful and check something for my patch. Also keeping focus on the issues is important. Working on kernel needs to pay attention more accorrding to other projects which I got experiences with them when I was student.

After this patch, I will work on zero pages and discover new things :).

15 Ocak 2015 Perşembe

Happy Coding & Testing Process

After third week, we started coding and made basic things. Our first aim to enable read-only ptes for collapsing. I still look for this issue. Something goes wrong and I can't see what is that.

To test my changes I've prepared test programs. They create pressure on memory and supply to swapped out system. Actually, they are very basic, just make malloc(), read/write operations on memory. memtest and stress are very strong workload programs, but to swapped out something they mix operations which are not correct for me. I should test specific conditions so use my test programs and they will be sophisticated later on.

To get informations about what happened with my changes, I use smem which shows swap usage percentage, pid, ppid with -t -p options and that's enough for me :). For specific process I look /proc/pid/smaps it gives anonhugepages/anonymouspages numbers and swap usage.

To look kernel messages we can use dmesg, but its size is not enough for me :) because I've been testing almost every line of the functions. To increase size of dmesg log, you should should set CONFIG_LOG_BUF_SHIFT in kernel config file. However When I setted it by 27 which means 2^27 bytes, make seems that doesn't accept this number! Probably, the number can be 16 or 17 as suggestion of config, but I'm not sure about that. Then I've looked /var/log/kern.log, and its size enough for me :) I'm sure about test results with it.

do_swap_page() makes swapped in operations afterward khugepaged scans the pages tables that come from do_swap_page(). There is no function call for khugepaged_scan_mm_slot(), it is called per 10000 miliseconds. Its call chain is like that:
khugepaged_scan_mm_slot() -> khugepaged_scan_pmd() -> collapse_huge_page() ->
__collapse_huge_page_isolate()

Today I've realized in khugepaged_scan_pmd(), ptes seem unpresent! but they are swapped in. Then I need to look do_swap_page() again :).

31 Aralık 2014 Çarşamba

Collapsing Huge Pages & Swap In/Out

Last week, I focused on collapsing huge pages and swap in/out. Rik  have asked me some questions and I countinue to reply them. When we study, he puts some hints to questions and sometimes, I back to old questions and try to understand them better. I've started to follow linux-mm list and understand what they mention about at least :). Before I've tried to follow some staging lists but see emails a lot* everyday.

My project includes very small coding according to other kernel internship projects but the topic is too complex and its about core functionality of Linux Kernel. That's really good :). Before the internship, I was thinking "I should pick a small staging driver and study for todo issues". Because with small driver, learning and to be part of Linux Kernel can be easier and I was going to do just self study, also work at another company so have not enough time. Todays, I study on almost hardest topic with a Linux Kernel developer!


I can start coding for my project but need to discuss which policy we will follow to get swapped out pages to memory. We should discuss about trade off to collapsing pages in a 2 mb page when getting them from swap to memory. Keeping in mind the functions is a bit hard for me, I re-look a lot of time to which function what does. My memory is not good :(.


I've replied following questions which are asked me by my mentor. When I reply the questions, don't need to search just from books, look to codes and understand a bit of them :).


Following call chains for Linux Kernel - 3.18


1) How is a page swapped out?


add_to_swap()

        get_swap_page()
                scan_swap_map()
        if(PageTransHuge(page))
                if (split_huge_page_to_list(page, list))
                        swapcache_free()
        add_to_swap_cache()

Swapped out is implemented by add_swap_page(). The function allocates swap space for a page. Swap areas includes slots, and their size are equals to page frames.


It checks whether page up to date and locked then gets swap page, get_swap_page() firstly checks is there a swap page with atomic_long_read(&nr_swap_pages) if so, decrements nr_swap_pages by one. In there used highhest_bit to decrease searching time of free slot. get_swap_page() returns type swap_entry_t. add_swap_page(), cheks whether the page is huge, if so; it splits the huge page to list with

split_huge_page_to_list(page, list).  The function calls __split_huge_page() -> __split_huge_page_map().

If split_huge_page_to_list() returns 0, that means splitted pages succesfully. After that it adds the page entry to swap cache. If huge page can not splitted then called swapcache_free(entry), to release retrieved swap page.

Note: I did not understand why we set page as dirty? at line:202. The page is not changed. Rik's answer: After the page is added to the swap, it is removed from the process page tables.


Then we have a page that is only in the page cache, and not mapped in any process. The dirty bit indicates the data has to be saved to swap before the page can be freed.


scan_swap_map() is used to find free swap slot.


2) Where is the information of where a page is in swap, stored in the data structures used to track the memory of a process?  In other words, how does swap in find where in swap memory is?


Using swap_info_struct swap_info[] array, it includes indexes of ptes and also offsets are stored in swap_map.


3) How is a page swapped in?

do_swap_page()
        pte_to_swp_entry()
        lookup_swap_cache()
        if (!page)
                swapin_readahead()

        else if (PageHWPoison(page)) {...}

It calls pte_to_swp_entry(), pte is converted to swap entry. the function converts pte to architecture independent entry format. Then checks validation of entry with non_swap_entry(). Sets DELAYACCT_PF_SWAPIN flag to spcefiy that does in swap operation. It checks whether the page in swap cache. If so, checks HWPoison flag which is for recovering memory errors; if not runs swapin_readahead() to get probably needs to swap in pages. If HWPoison is setted, it goes to label out_release and release the page and swap cache page from page cache. I've a question here: if the page was huge, but right now it is not because splitted to locate on swap. The page have no compound flag anymore? Is that correct?


Rik's answer: Swap only ever stores single pages, indeed. That means swapped
in pages will not have the compound flag set page_cache_release() calls put_page(), and the function checks using PageCompound().

Note: do_swap_page() gets two pte argument. orig_pte is created by handle_mm_fault() using ACCESS_ONCE(). The macro is for volatile issues maybe but I didn't understand why second pte is created.

Answer: do_swap_page gets both the location of the pte (a pointer) and the value of the pte at handle_mm_fault time. This way it can verify whether the pte changed from its original value, while it is doing things (like retrieving data from swap)

4) How can you discover whether a page is present in the swap cache?

_PAGE_FILE detects whether the page in swap cache, it is into page table entry.

5) Under what conditions are 4kB pages collapsed into a 2MB THP?

In handle_pte_fault(), at line: 3219 do_swap_page() is called because system want to swapped in pages, so it wants to collapse the pages but it can't. This happens, if the cases occur: pte shouldn't be on memory and swap cache. Also pte should be belong to anonymous page, not to file.

Rik's question: Can you write down the call traces that contain the collapse functions in mm/huge_memory.c?
My answer, there are two cases for it:
do_huge_pmd_anonymous_page() -> alloc_hugepage_vma() -> .. __alloc_pages_nodemask()

khugepaged_scan_pmd() -> collapse_huge_page() -> khugepaged_alloc_page() -> alloc_pages_exact_node() -> .. -> __alloc_pages_nodemask()

Rik's answer: Firt call chain, you can leave alone during your project, and is important to understand what the data structures look like.

Second call chain: This is the one you will want to work with.

6) how many pages would be good to bring into swap when trying to collapse a huge page? how many is too much?

x86 systems use 4kB page size. It can be enlarged maximum 4mb. With 2mb page, it is enlarged 512 times, thats good. 4mb page means 1024 times enlarged, it is not so good, if size is more than 4mb huge page, it will be useless.

Rik's answer: Sure, but if all of them are swapped out, it is obviously a bad
idea to bring them all into memory just to collapse them into a 2MB THP.

Out of the 512 pages, what would be a reasonable number to not be in memory already, and bring in from swap? 1? 5? 10? 20? What would the number depend on?

My answer: do_swap_page() ->  swapin_readahead() -> swapin_nr_pages()

In swapin_nr_pages(), using page_cluster it detects how many pages getting swap in.

page_cluster defined in swap.c. swap_setup() function assigns its default value.

7) what about pages that are already in the swap cache? how should we count those?

For this question, I'm a bit confused, thought swap cache is a swap slot .. and replied different thing :). Firstly, I've tried to count how many pages in swap, afterwards go ahead to correct intent.

If a page in the swap cache, that means the page up to date on memory. Also the page is on the one swap slot. Swap cache size is equal to a swap slot. struct swap_info_struct, it has array swap_map.

I've read from book, swap_duplicate() increases slot usagecounter, probably it mentions about the line:

count = p->swap_map[offset];

I've seen on comment line of the function "increment its swap map count." So I guess, swap_map count can be slot usage counter. But I know swap_info struct per swap area not per swap slot. A swap area can include set of slots, so I think, swap_map count doesn't mean swap cache usage counter. Did I misunderstand? Can you inform me about swap_map?

Rik's answer: The swap_map counter means the number of users of that swap slot, which may be different from the number of users of the swap cache page.

However, this line of research is tangential to your project, and your interpretation of question 2 differs from my intent.

My answer: I've thought, when a page will be added to swap cache, it increases count of swap cache page.

add_to_swap_cache() -> __add_to_swap_cache()

In __add_to_swap_cache(), after adding radix tree, it increases the counter at line 104:
address_space->nrpages++;

nrpages specify total number of pages in address_space which stores swap cache address that means how many pages are in swap cache.

8) what about the !pte_write test in __collapse_huge_page_isolate? how can that break collapsing of a THP? is there a simple way to improve that?

pte_present() checks whether the entry have write access. It needs to create a page using page table entry with vm_normal_page(). If write access is disallowed, can't create page.

My mentor said __collapse_huge_page_isolate() is important point your project, and I've reviewed it:

__collapse_huge_page_isolate()
        for (_pte = pte; _pte < pte+HPAGE_PMD_NR; _pte++, address += PAGE_SIZE) {
                pte_none()
                !pte_present() || !pte_write()
                isolate_lru_page(page)

For loop:
Firstly, it checks pte_none(), this function returns true if pte is not in Ram. There is a counter none, checks with none for allowed khugepaged_max_ptes_none. If exceeds the limit then goes to label out. pte_none() returns true if none of the bits in the pte are set, that is the pte is all zeroes. pte_present() also is used for page swapped out. pte_write() checks whether the kernel write to page. Then checks is the page compound, if so does system halt. If page is not anon nor swap backed then does system halt. The page should have only one reference, this property checked by _count variable. Then it locks the page.

I'm looking isolate_lru_page(), Lru list includes inactive file/page, active file/page. But I didn't understand why there is PG_lru flag and we check it with PageLRU(page) at line 1344, vmscan.c

Rik's answer: If the page is not currently on an LRU, a different task may have that page on a pagevec, and do something with it later. That could race with trying to collapse the hugepage, and cause all sorts of problems.

In isolate_lru_page(), it checks again VM_BUG_ONE(!page_count(page), page), but already it checked for page_count() before calling isolate_lru_page() line at: 2171. Why it does this again?

Rik's answer: The page_count check is debugging code, in case somebody changes the kernel and calls isolate_lru_page on a page that got freed. It checks PageLRU once outside the lock (it can be changed by another CPU), and once inside the lock (taking a lock is expensive, and only done conditionally).

And also it checks PageLRU two times, in isolate_lru_page(). It gets lruvec then runs page_lru(), which checks page unevictable, if so sets lru as unevictable; if not, calls page_lru_base_type(), this decides base type for page - file or anon after adds active property and returns lru. Then isolate function runs get_page(), if page head or normal, increments _count. Then clear page lru and calls del_page_from_lru_list(), this function deletes lru from page using list_del()

It checks for page young conditions, then set referenced as 1. If it goes to label out, it runs release_pte_pages().

Note: That function gets a pointer to the start of a page table page, and iterates over all the ptes inside that page table page. A 2MB THP contains 512 4kB pages, which is 1<<HPAGE_PMD_ORDER pages.

23 Aralık 2014 Salı

Begining to Read Memory Management Codes

My Linux Kernel internship started two weeks ago and will take 3 months. My mentor is Rik Van Riel. My project aim to fix transparent huge page swapping issues, if system needs to swap huge pages, it has to split the pages to small sized ones but then the system can not reconstitute the huge pages.

Rik asked me some questions about huge page and swapping and I've replied them. Before the reply the questions I've looked for following data structures and definitions.

Firstly I've started to examine struct page and mm_struct in mm_types.h. The kernel holds all information in mm_struct, it includes vm_area_struct *mmap which involves list of memory areas.  vm_areas_struct is an object to show memory areas. Also, the kernel threads don't use mm_struct so if you see if (!mm) {...} it means this is  kernel thread.

Likely & Unlikely Functions: Theese are for branch prediction so used for compiler optimization. They supply to guess which instruction will run and do read ahead.
http://kernelnewbies.org/FAQ/LikelyUnlikely
http://stackoverflow.com/questions/109710/likely-unlikely-macros-in-the-linux-kernel

Numa & Uma Systems: I've understood the two keywords looking the picture :).










Hot &  Cold Page: If a page in cpu cache, it is hot page however cold page is vice versa.

struct scan_control: It is used for page scaning, holds following variables:
unsigned long nr_scanned: How many inactive pages were scanned.
int may_writepage: It determines whether the kernel can write backing store.
swap_cluster_max: It is restriction for a lru list.

struct zone: The kernel divides memory to nodes, and the nodes include zone lists. Every zone area include pages. You can look for struct zone.

struct list_head: Doubly linked list, to build & manage lists.

Page Flags: http://lxr.free-electrons.com/source/include/linux/page-flags.h

High Memory: Linux Kernel seperate high rate of memory for user space so high memory means user space.
http://unix.stackexchange.com/questions/4929/what-are-high-memory-and-low-memory-on-linux

Page Vector: Provides operations on page list instead of individual pages.

Slot: Swap area is divided to slots. Size of each slot equals to page frame.

up_read/write, down_read/write functions: They are for spinlock issues and includes assembly instructions.

BUG_ON* functions: Checks given condition and returns system halt or nothing.
http://lxr.free-electrons.com/source/include/linux/mmdebug.h#L18

Swap Cache: Some pages after swapped out, if the page is not changed, it has an entry on swap cache and system can read data on memory withouth get the page to back memory.
http://www.linux-tutorial.info/modules.php?name=MContent&pageid=314

Transparent Huge Page vs. Huge Page: Transparent huge page supplies a layer for huge page. http://goo.gl/qGksYX

Note-1: Swap space used by user space tools (mkswap)

Note-2: x86 systems don't use pte level for THP (transparent huge page), it can direct access data on pmd.

Following questions which are asked to me by my mentor. I've explained just important points for my project and their function traces because there are a lot of functions, sometimes they can be very complex :).

Below call chains for Linux Kernel - 3.18

1) from do_page_fault(), sometimes the VM uses transparent huge pages
   (2MB size on x86) for anonymous memory. What functions does the
   code go through between do_page_fault() and the function that
   installs 2MB pages in the process page tables?
When I examined functions, I saw a lot of spinlock functions and Rik said, they for ensure that multiple concurrent instances of the page fault code do not manipulate the page table simultaneously.

do_page_fault()
  __do_page_fault() /* checks the fault is belong to bad area or good area */
    handle_mm_fault()
      __handle_mm_fault()
        __do_huge_pmd_anonymous_page()
       
         
pgtable_trans_huge_withdraw takes a page table page from the process's
reserve of page table pages, so the 2MB page (mapped at pmd level) can
be mapped as 4kB page entries (at the pte level).


2) When are 2MB pages used?

If PAE is enabled, then use 2mb pages. I've looked for it following links:
http://en.wikipedia.org/wiki/Physical_Address_Extension https://www.cs.rutgers.edu/~pxk/416/notes/09a-paging.html
http://en.wikipedia.org/wiki/Page_Size_Extension
http://en.wikipedia.org/wiki/Page_%28computer_memory%29#Huge_pages

3) What does the VM do when a 2MB page cannot be allocated?
   (still in memory.c and huge_memory.c)
In  do_huge_pmd_anonymous_page(), if it can not allocate 2MB page;
it returns, out of memory or fall back. It also calls count_vm_event()
with THP_FAULT_FALLBACK argument. At line: 824, it tries to set
huge zero page, if it can't do that, calls put_huge_zero_page(),
which calls atomic_dec_and_test(). 

At line: 839: If it couldn't install huge page, it calls
put_page(). I've thought;in put_page, it checks whether
the page compound or not, but the page will be compound
always, because the page comes from alloc_hugepage_vma().


4) When the system runs low on memory and wants to swap something
   out, it will split up a huge page before assigning it space in
   a swap area. Find the code in vmscan.c, swapfile.c and huge_memory.c
   that does that. What does the function trace look like from
   try_to_free_pages to the function that splits the huge pages?
try_to_free_pages()
  throttle_direct_reclaim(gfp_mask, zonelist, nodemask)
    do_try_to_free_pages(zonelist, &sc)
      delayacct_freepages_start()
      global_reclaim()
      do while { vmpressure_prio()
      shrink_zones() /* if a zone reclaimable it returns true */}


I've seperated shrink_zones() to below:

shrink_zones()
  nodes_clear(shrink.nodes_to_scan)
  loop:
  populated_zone() {return (!!zone->present_pages);}
  zone_reclaimable_pages(zone) -> get_nr_swap_pages()
  node_set()
  zone_reclaimable()
  shrink_zone()
     shrink_lruvec()
       shrink_list()
          shrink_active_list()
          shrink_inactive_list()
             shrink_page_list()
               add_to_swap()
                 split_huge_page_to_list()
                    __split_huge_page()
                       __split_huge_page_map()


try_to_free_pages(): If memory is not sufficent, it checks pages and removes least used one.
shrink_zones(): It is runned by kswapd with specified time interval and used for remove rarely used
pages. It also balances inactive and active lists using shrink_active_list().
shrink_active_list(): Provides to transfer pages between active_list and inactive_list and detect least used active lists and also implements page selection.
shrink_inactive_list(): Removes lists from inactive_list and send the lists to shrink_page_list().

In general, shrink_* functions run per zone.

5) in huge_memory.c look at collapse_huge_page and the functions
   that call it - under what conditions does the kernel gather up
   512 4kB pages and collapse them into one 2MB page?
collapse_huge_page()
                khugepaged_alloc_page() /* allocate new page */
                __collapse_huge_page_isolate(vma, address, pte); /* this one is new function for me */
                if (isolate_lru_page(page)) { ... }
                if (pte_young(pteval) || PageReferenced(page) ||
                        mmu_notifier_test_young(vma->vm_mm, address)) { ... }
                __collapse_huge_page_copy()

collapse_huge_page_isolate() removes pages from lru with isolate_lru_page().
I've thought: when collapsing pages, their lru's will change. So it isolates
pages.


Note-1: __collapse_huge_page_copy(): 
The 4kB pages could be anywhere in memory.
The 2MB page needs to be one contiguous page.
That means the contents of the 4kB pages need
to be copied over into the one 2MB page.
khugepaged_scan_pmd(), if page is young, it will call collapse_huge_page().
If the collapse function can correct vma, pmd and isolate pages, it collapses
pages.


6) under what conditions does the kernel decide not to collapse
   the 4kB pages in a 2MB area into a 2MB page?
There some conditions for it:
1) If can't alloc khuge page, it won't collapse.
2) I've looked to this condition in collapse_huge_page():
        if (unlikely(khugepaged_test_exit(mm))) {goto out;}
   if mm has no user, it goes to label out and doesn't collapse pages.
3) If it can't find vma and pmd
4) If it can't isolate pages


7)  look at what happens when shrink_page_list()
passes a 2MB transparent huge page to add_to_swap()
When it sent 2 MB page to add_to_swap function, it firstly checks whether page locked and up to date then calls get_swap_page(). If there is no swap page returns 0, If not it checks transHugePAge() then implements split_huge_page_to_list(). In split_huge_page_to_list it gets anonymous vma and does write-lock for it and checks PageCompound. With PageCompound it controls the is huge or not.  Then it checks PageSwapBacked. Then calls __split_huge_page() and the function wants the page shouldn't be tail and splits the page in __split_huge_page_splitting(). The function backs to add_to_swap and does swapcache_free() issues.

8) Can you explains what the page looks like after it has been split?
What happened to the 2MB page?  What do we have instead?
What happened with the PageCompound flag?
__split_huge_page(), it calls __split_huge_page_splitting() in the iteration. It counts number of mapped pmds before splitted it and increase mapcount.

In split_huge_page_map(), it takes page offset with address argument. Firstly, it checks pmd address validity. It
creates small entries in for loop with mk_pte(), set_pte_at(), pte_unmap (this one is just nop instruction for x86 systems). The for loop does one entry for page one, then page two, then page three etc. It changes address of entry adding pagesize (haddr += PAGE_SIZE) up to number of pmd.

I've asked, why pmd_populate()  is performed two times at lines: 1790, 1843?
Rik's answer: The first pmd_populate puts in place a special transparent huge page
PMD that says "this transparent hugepage is being split, do not mess
with it".


The second pmd_populate puts in place the page table page containing
the 4kB pages that map the 2MB area.


Note-1: In __split_huge_page() iterates vma from root of red black tree at line: 1864 but the function gets only one page and a page can match just one vma. So why it needs to iterate vma?

Rik replied my question: "The same page may be shared by multiple processes, if the
process that created the 2MB page originally called fork() afterwards."

Note-2: In  __split_huge_page_splitting(), it calls  pmdp_splitting_flush() what does it do also pmd_update and flush_tlb_range function? I think it should save pmd's content before splitting, it shouldn't lose it. Why it flushes pmd?
Rik's answer: if a small page is touched or dirtied afterwards, we want the MMU to set the accessed and/or dirty bit on the 4kB page entry.

Note-3: We can ignore PVOP_VCALL stuff - that is for Xen, which uses an alternate function for filling in page table info. 

9) Under what conditions can a region with 4kB pages be
turned into a 2MB transparent huge page?
I've traced following call chain:
do_page_fault()
        __do_page_fault()
                handle_mm_fault()
                        __handle_mm_fault() /* check conditions */
                                do_huge_pmd_anonymous_page() /* check conditions */
                                __do_huge_pmd_anonymous_page() /* check conditions */

In __handle_mm_fault(), "if (pmd_none(*pmd) && transparent_hugepage_enabled(vma)) { ... }" if the expression is correct, it can realize do_huge_pmd_anonymous_page(). I've seen this quote for pmd_none() "if page is not in RAM, returns true." But I think, if page is not used for any process, it includes zeros and should be in RAM.

In do_huge_pmd_anonymous_page(), "if (!(flags & FAULT_FLAG_WRITE) && transparent_hugepage_use_zero_page()) { ... }"
if it can correct the condition, it can start to create transparet huge page. I've looked for condition values.
flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE; allow retry and killable flag values are defined with special values (0x08, 0x02)?
I think their values only for to check something. And transparent_hugepage_flags is 0UL, is it always have this value? I've looked for its value,
probably always have same value. The last condition creates huge zero page using  set_huge_zero_page() which calls pmd_mkhuge().


One more condition: __do_huge_pmd_anonymous_page(mm, vma, haddr, pmd, page), if it returns false, that means created transparent huge page at line: huge_memory.c#L808
If pmd_none() returns true, creates thp.


10) What code turns 4kB pages into a 2MB page?
pmd_mkhuge() installs 2 MB page. Actually, it does pmd_set_flags(pmd, _PAGE_PSE).
_PAGE_PSE uses _PAGE_BIT_PSE which means huge page.

11) Under what conditions can a region with 4kB pages not
be turned into a 2MB transparent huge page?
There are a lot conditions for this.
1) If the entire 2MB page inside vma, return fall back.
2) If it can't create anonymous vma, return out of memory.
3) If it can't create huge page vma, return fall back.
4) If it get true from __do_huge_pmd_anonymous_page(), return fall back.
5) in __do_huge_pmd_anonymous_page(), if page is not support huge page, the code create kernel panic, and halt.
   VM_BUG_ON_PAGE(!PageCompound(page), page);

6)  If it cannot allocate a huge page

7 Aralık 2014 Pazar

Page Fault Handler

I've started to read something about memory issue. Firstly, I've looked for basic concepts for it. This link is pretty good for basic concepts.

MMU (Memory Management Unit) translates physical memory addresses to virtual addresses. It creates an interrupt when a page fault occured. When a process try to access an address and if the address is unknown for MMU then it creates page fault exception. In this case page fault exception handler examines current state of MMU and process.  do_page_fault(...) function is page fault handler for Linux. It is processor specific function, I've studied for x86 based systems.

do_page_fault() function gets two arguments which are error code and registers of the process. The error code specifies the page fault whether because of read operation or write operation.

Firstly the function saves address of line which is cause of the exception (control register two), then saves prev state of process.

Page fault handler needs to detect whether the page fault is good or bad. Good page fault means the process needs more memory. Bad page fault can occur for different cases, in general it causes of terminate the process by the handler.

Actually do_page_fault calls __do_page_fault(...) function and it is main area to handle the page fault.

In Linux based systems every process has a page directory and page table. We can understand which pages used by which process with the data structures. If process needs more memory, the handler gets a page from pglist_data which is a global list and adds the page to page table of process.

The function using mm_struct can detect whether the process has permission access for the address. It uses find_vma function for this operation. If process has to access then the address assigned to the process else the process is terminated and segmentation fault occured.

Processes are created as instance of task_struct which includes mm_structs and keeps info about processes.

You can see process resources under /proc/pid/*. If you want to see process vma, then type "cat /proc/pid/maps" on bash. To understand memory issues better, I've read the chapter, this book is very good for kernel newbies.

Also this two links are very helpful for me, they are for kernel 2.6x series but very good to understand big picture of the topic.

Other sources:
http://www.stillhq.com/pdfdb/000446/data.pdf
http://duartes.org/gustavo/blog/post/how-the-kernel-manages-your-memory/

25 Kasım 2014 Salı

Linux Kernel Internship

Last month I've applied Gnome Outreach Program for Women and sent patches for Linux Kernel. I've applied it because wanted to learn low level things. I also really like computer design and architecture topics. Actually, I have not enough knowledge about them but like to learn them.

Linux Kernel Community accepted to me as an intern. I'll study on Khugepaged swap readahead project. Working with Linux Kernel team will be great experience for me. They really want to help kernel newbies :).

Actually, studying on Linux Kernel needs a lot reading. Just for writing a few code lines needs to read one chapter from one book, a few blog posts about topic and ask something to developers :).

Nowadays, I've started to read about memory management issues like TLB, Huge Pages, Page Fault from one operating system book and also examine do_page_fault() function.

22 Kasım 2014 Cumartesi

Google Hiring Process

This story started 4 months ago. I've got an email from a Google recruiter. She wanted to do a phone conversation with me. I was very happy to hear this and accepted the conversation immediately.

First phone conversation was initial phone interview, she asked me basic questions about data structures, bitwise operations, linux commands etc. But I think the questions were not basic :p I passed initial phone interview and preferred Site Reliability System Engineer position for myself. I took first round telephone interview with an Google engineer and used Google Doc for coding questions.

Before the first round to prepare myself I was studying algorithms, data structures, network, linux commands, troubleshooting. Following links were really helpful for me:

Geeks For GeeksGlassadorCareerupCracking Code InterviewsSystem DesignDevops Interview Questions.

I passed first round, the engineer said to me you did great most of this interview! I was really happy to hear this and couldn't believe what I heard :) The whole process was very excited, funny and nice for me.

We moved the process for second phone interview. Again I studied for same things and used Google Doc for coding questions. My second interview has only one question, when I replied the question, interviewer generated new questions which was derived from same question. Second round interview was not very good but my recruiter called me and said you passed it, we would like to invite you for onsite interview at one Google office, Google will pay your all expenses. I preferred Dublin office of Google which is headquarters for the Europe offices.

I prepared to practising English myself, and whole summer went English speaking courses, because in my country have no other chance to practising English unfortunately :(

Actually, my English is not very good and when talked with employees of Google I feel really excited so I couldn't talk much so many times :) however during the onsite interviews I discussed a lot on questions because it is my job, but for usual questions how are you?, are you excited?, do you have question? etc. this kind of questions I could talk less :) Engineers of Google are very understanding people to my English. Also in Google Dublin office, people coming from 65 different countries and there are 45 different languages.

Onsite interview have 5 different steps. For SRE (Site Reliability Engineer) position, I've got following steps and each step has 45 minutes with 5 different interviewers. Onsite interview is last round for Google hiring process.

1) ​​Non Abstract Large System Design
2) Troubleshooting / Problem Solving
3) ​Practical Coding - ​Ruby​
4) ​Design/Coding
5) Unix/ Linux ​Systems​

Onsite interview questions were not expected things for me :(. I read a lot of blog posts, they say the questions are very expected, but I think some of them really expected things however most of them were not. I also solved a lot of onsite interview questions before mine.

I couldn't pass the onsite interview however this was really great experience for me. The whole process was very exciting, every steps made me very happy and excited :).  I also met a few Google engineers and my recruiters. They are really helpful and friendly people.

Dublin is not big city so there is no a lot of people, it is not crowded. It was very rainy on my interview day. I stayed two nights in Dublin. After my interview I had time to discover the city. There is river which called as River Liffey in Dublin. It is like a map to find your road :p You can follow along the river so can find your hotel very quickly :).

I'm very happy to met with Google engineers. This was very good experience for me. I'm only 22 years old I can retry it, thanks a lot to Google.

14 Temmuz 2014 Pazartesi

Android Cihazlarda Rom Değiştirmek

Androidli telefonlarda yüklü olarak gelen rom dışında istediğimiz başka romları kurmak da mümkün. En bilinen romlar ise cynmod, miyui, aokp, paranoid android. Rom chip üzerindeki kalıcı yazılımları oluşturur. Romu değiştirerek cihazın içeriğini baştan sonra değiştirmiş olabiliriz. Bu değişim işlemci ve bellek kullanımı, kısayolları, ekran kilidi gibi birçok özelliği değiştirebilir. Telefondan aldığımız verimi artırabilir azaltabilir.

Ben şimdiye kadar cynmod'u denedim. Cihazınıza uygun cynmod romlarını buradan bulabilirsiniz. Uygun .zip dosyasını indirdikten sonra telefona sdcard içerisine kopyalamalıyız. adb reboot recovery diyerek telefonu recovery modda açıp zip dosyası kurmayı seçerek .zip'in konumunu da belirtmeliyiz. Cynmod'u kurduktan sonra Google Play Store sistemden kalkıyor. Play Store'u kurmak için gapps paketini indirmeliyiz. Gapps paketini de telefona kopyalayıp yine recovery moddan açarak kurulumu gerçekleştirmeliyiz.

Cihazın kendi sahipleri dışında bir firmanın yayınladığı romlara custom rom deniliyor. Cihaza kurulabilecek resmi (offical) romlara ise stock rom deniliyor. Custom rom kurduktan sonra stock romu indirerek tekrar cihazı ilk günkü haline çevirebiliriz.

Genelde stock romların içerisinde bir kurulum betiği oluyor. Nexus cihazlar için stock romlara buradan ulaşabilirsiniz. Nexus-5 için hammerhead .tgz dosyası içerisinde flash-all.sh dosyası var. İndridiğimiz .tgz dosyasını bilgisayarda açmalıyız. Cihazı ise adb reboot bootloader şeklinde fastboot modundan açarak bu dosyayı bilgisayardan çalıştırıp kurulumu gerçekleştirebiliriz.